mirror of
https://github.com/nushell/nushell.git
synced 2025-03-21 11:07:10 +01:00
e3be849c2a
* Upgrade futures, async-stream, and futures_codec These were the last three dependencies on futures-preview. `nu` itself is now fully dependent on `futures@0.3`, as opposed to `futures-preview` alpha. Because the update to `futures` from `0.3.0-alpha.19` to `0.3.0` removed the `Stream` implementation of `VecDeque` ([changelog][changelog]), most commands that convert a `VecDeque` to an `OutputStream` broke and had to be fixed. The current solution is to now convert `VecDeque`s to a `Stream` via `futures::stream::iter`. However, it may be useful for `futures` to create an `IntoStream` trait, implemented on the `std::collections` (or really any `IntoIterator`). If something like this happends, it may be worthwhile to update the trait implementations on `OutputStream` and refactor these commands again. While upgrading `futures_codec`, we remove a custom implementation of `LinesCodec`, as one has been added to the library. There's also a small refactor to make the stream output more idiomatic. [changelog]: https://github.com/rust-lang/futures-rs/blob/master/CHANGELOG.md#030---2019-11-5 * Upgrade sys & ps plugin dependencies They were previously dependent on `futures-preview`, and `nu_plugin_ps` was dependent on an old version of `futures-timer`. * Remove dependency on futures-timer from nu * Update Cargo.lock * Fix formatting * Revert fmt regressions CI is still on 1.40.0, but the latest rustfmt v1.41.0 has changes to the `val @ pattern` syntax, causing the linting job to fail. * Fix clippy warnings
67 lines
2.1 KiB
Rust
67 lines
2.1 KiB
Rust
use futures::{StreamExt, TryStreamExt};
|
|
use heim::process::{self as process, Process, ProcessResult};
|
|
use heim::units::{information, ratio, Ratio};
|
|
use std::usize;
|
|
|
|
use nu_protocol::{TaggedDictBuilder, UntaggedValue, Value};
|
|
use nu_source::Tag;
|
|
|
|
use std::time::Duration;
|
|
|
|
#[derive(Default)]
|
|
pub struct Ps;
|
|
|
|
impl Ps {
|
|
pub fn new() -> Ps {
|
|
Ps
|
|
}
|
|
}
|
|
|
|
async fn usage(process: Process) -> ProcessResult<(process::Process, Ratio, process::Memory)> {
|
|
let usage_1 = process.cpu_usage().await?;
|
|
futures_timer::Delay::new(Duration::from_millis(100)).await;
|
|
let usage_2 = process.cpu_usage().await?;
|
|
|
|
let memory = process.memory().await?;
|
|
|
|
Ok((process, usage_2 - usage_1, memory))
|
|
}
|
|
|
|
pub async fn ps(tag: Tag) -> Vec<Value> {
|
|
let processes = process::processes()
|
|
.map_ok(|process| {
|
|
// Note that there is no `.await` here,
|
|
// as we want to pass the returned future
|
|
// into the `.try_buffer_unordered`.
|
|
usage(process)
|
|
})
|
|
.try_buffer_unordered(usize::MAX);
|
|
pin_utils::pin_mut!(processes);
|
|
|
|
let mut output = vec![];
|
|
while let Some(res) = processes.next().await {
|
|
if let Ok((process, usage, memory)) = res {
|
|
let mut dict = TaggedDictBuilder::new(&tag);
|
|
dict.insert_untagged("pid", UntaggedValue::int(process.pid()));
|
|
if let Ok(name) = process.name().await {
|
|
dict.insert_untagged("name", UntaggedValue::string(name));
|
|
}
|
|
if let Ok(status) = process.status().await {
|
|
dict.insert_untagged("status", UntaggedValue::string(format!("{:?}", status)));
|
|
}
|
|
dict.insert_untagged("cpu", UntaggedValue::decimal(usage.get::<ratio::percent>()));
|
|
dict.insert_untagged(
|
|
"mem",
|
|
UntaggedValue::bytes(memory.rss().get::<information::byte>()),
|
|
);
|
|
dict.insert_untagged(
|
|
"virtual",
|
|
UntaggedValue::bytes(memory.vms().get::<information::byte>()),
|
|
);
|
|
output.push(dict.into_value());
|
|
}
|
|
}
|
|
|
|
output
|
|
}
|