Struct heim::process::Process

pub struct Process(_);

This is supported on feature="process" only.

System process.

Some extra methods can be found in the OS extensions

Implementations

impl Process

pub fn pid(&self) -> i32

This is supported on feature="process" only.

Returns the process pid.

pub async fn parent_pid(&'_ self) -> Result<i32, ProcessError>

This is supported on feature="process" only.

Returns process parent pid.

pub async fn parent(&'_ self) -> Result<Process, ProcessError>

This is supported on feature="process" only.

Returns parent Process.

pub async fn name(&'_ self) -> Result<String, ProcessError>

This is supported on feature="process" only.

Returns process name.

pub async fn exe(&'_ self) -> Result<PathBuf, ProcessError>

This is supported on feature="process" only.

Returns process executable as an absolute path.

pub async fn command(&'_ self) -> Result<Command, ProcessError>

This is supported on feature="process" only.

Returns process command line.

Example

let process = process::current().await?;
let command = process.command().await?;
println!("Command line arguments:");
for arg in &command {
    println!("{:?}", arg);
}

pub async fn cwd(&'_ self) -> Result<PathBuf, ProcessError>

This is supported on feature="process" only.

Returns process current working directory.

Compatibility

For Windows this method is not implemented yet and will always panic, see #105.

pub async fn status(&'_ self) -> Result<Status, ProcessError>

This is supported on feature="process" only.

Returns current process status.

pub async fn environment(&'_ self) -> Result<Environment, ProcessError>

This is supported on feature="process" only.

Returns process environment.

pub async fn create_time(
    &'_ self
) -> Result<Quantity<dyn Dimension<J = Z0, N = Z0, T = PInt<UInt<UTerm, B1>>, I = Z0, L = Z0, M = Z0, Kind = dyn Kind + 'static, Th = Z0> + 'static, dyn Units<f64, time = second, thermodynamic_temperature = kelvin, length = meter, electric_current = ampere, amount_of_substance = mole, luminous_intensity = candela, mass = kilogram> + 'static, f64>, ProcessError>

This is supported on feature="process" only.

Returns process creation time, expressed as a Time amount since the UNIX epoch.

pub async fn cpu_time(&'_ self) -> Result<CpuTime, ProcessError>

This is supported on feature="process" only.

Returns accumulated process time.

pub async fn cpu_usage(&'_ self) -> Result<CpuUsage, ProcessError>

This is supported on feature="process" only.

Returns CPU usage measurement.

Returned CpuUsage struct represents instantaneous CPU usage and does not represent any reasonable value by itself. It is suggested to wait for a while with help of any async timer (for accuracy recommended delay should be at least 100 ms), call this method once again and subtract former CpuUsage from the new one.

Same to any *nix system, calculated CPU usage might exceed 100 % if the process is running multiple threads on different CPU cores.

Example

let process = process::current().await?;
let measurement_1 = process.cpu_usage().await?;
// Or any other async timer at your choice
futures_timer::Delay::new(Duration::from_millis(100)).await;
let measurement_2 = process.cpu_usage().await?;

println!("CPU usage: {} %", (measurement_2 - measurement_1).get::<ratio::percent>());

pub async fn memory(&'_ self) -> Result<Memory, ProcessError>

This is supported on feature="process" only.

Returns memory usage information for this process.

pub async fn is_running(&'_ self) -> Result<bool, ProcessError>

This is supported on feature="process" only.

Checks if this Process is still running.

pub async fn suspend(&'_ self) -> Result<(), ProcessError>

This is supported on feature="process" only.

Suspends the current process.

Before the signal send, it checks whether process PID has been reused, and if it is a case, NoSuchProcess error will be returned.

Compatibility

For *nix systems it sends the SIGSTOP signal to process.

pub async fn resume(&'_ self) -> Result<(), ProcessError>

This is supported on feature="process" only.

Resumes the current process.

Before the signal send, it checks whether process PID has been reused, and if it is a case, NoSuchProcess error will be returned.

Compatibility

For *nix systems it sends the SIGCONT signal to process.

pub async fn terminate(&'_ self) -> Result<(), ProcessError>

This is supported on feature="process" only.

Terminates the current process.

Before the signal send, it checks whether process PID has been reused, and if it is a case, NoSuchProcess error will be returned.

Compatibility

For *nix systems it sends the SIGTERM signal to process.

For Windows it is an alias for the Process::kill

pub async fn kill(&'_ self) -> Result<(), ProcessError>

This is supported on feature="process" only.

Kills the current process.

Before the signal send, it checks whether process PID has been reused, and if it is a case, NoSuchProcess error will be returned.

Compatibility

For *nix systems it sends the SIGKILL signal to process.

TerminateProcess function is used for Windows, it initiates the termination but does not awaits for completion.

pub async fn wait(&'_ self) -> Result<(), ProcessError>

This is supported on feature="process" only.

Wait for the current process termination.

Returns

If the process is already terminated, this method returns Ok(()).

Trait Implementations

impl Debug for Process

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for Process

impl Hash for Process

fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<Process> for Process

fn eq(&self, other: &Process) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Process) -> bool

This method tests for !=.

impl ProcessExt for Process

fn signal<'life0, 'async_trait>(
    &'life0 self,
    signal: Signal
) -> Pin<Box<dyn Future<Output = Result<(), ProcessError>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Process: 'async_trait, 

Send the signal to process.

fn niceness<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<i32, ProcessError>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Process: 'async_trait, 

Get process niceness.

fn set_niceness<'life0, 'async_trait>(
    &'life0 self,
    value: i32
) -> Pin<Box<dyn Future<Output = Result<(), ProcessError>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Process: 'async_trait, 

Set process niceness.

impl ProcessExt for Process

fn io_counters<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<IoCounters, ProcessError>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Process: 'async_trait, 

Returns future which resolves into process IO counters.

fn net_io_counters<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<IoCounters, ProcessError>> + 'life0 + Send>>, ProcessError>> + 'async_trait + Send>> where
    'life0: 'async_trait,
    Process: 'async_trait, 

Returns stream which yield this process [IO counters] for each network interface.

impl StructuralEq for Process

impl StructuralPartialEq for Process