Struct Child 

pub struct Child { /* private fields */ }

A wrapper around smol::process::Child that ensures all subprocesses are killed when the process is terminated: on Unix by using process groups, and on Windows by using job objects.

On Windows, dropping this struct closes the job object handle, which terminates all processes in the job. This also applies when the Open GPUI process exits for any reason, since the OS closes its handles, so spawned process trees can never outlive their owner.

Implementations

impl Child

pub fn spawn( command: Command, stdin: Stdio, stdout: Stdio, stderr: Stdio, ) -> Result<Self>

pub async fn output(self) -> Result<Output>

Consumes the child, drains stdout/stderr, and waits for exit.

pub fn kill(&mut self) -> Result<()>

Methods from Deref<Target = Child>

pub fn id(&self) -> u32

Returns the OS-assigned process identifier associated with this child.

Examples

use async_process::Command;

let mut child = Command::new("ls").spawn()?;
println!("id: {}", child.id());

pub fn kill(&mut self) -> Result<(), Error>

Forces the child process to exit.

If the child has already exited, an InvalidInput error is returned.

This is equivalent to sending a SIGKILL on Unix platforms.

Examples

use async_process::Command;

let mut child = Command::new("yes").spawn()?;
child.kill()?;
println!("exit status: {}", child.status().await?);

pub fn try_status(&mut self) -> Result<Option<ExitStatus>, Error>

Returns the exit status if the process has exited.

Unlike status(), this method will not drop the stdin handle.

Examples

use async_process::Command;

let mut child = Command::new("ls").spawn()?;

match child.try_status()? {
    None => println!("still running"),
    Some(status) => println!("exited with: {}", status),
}

pub fn status(&mut self) -> impl Future<Output = Result<ExitStatus, Error>>

Drops the stdin handle and waits for the process to exit.

Closing the stdin of the process helps avoid deadlocks. It ensures that the process does not block waiting for input from the parent process while the parent waits for the child to exit.

Examples

use async_process::{Command, Stdio};

let mut child = Command::new("cp")
    .arg("a.txt")
    .arg("b.txt")
    .spawn()?;

println!("exit status: {}", child.status().await?);

Trait Implementations

impl Deref for Child

type Target = Child

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Child

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.