Struct async_std::process::Command

pub struct Command { /* private fields */ }

A builder for spawning processes.

Examples

use async_process::Command;

let output = if cfg!(target_os = "windows") {
    Command::new("cmd").args(&["/C", "echo hello"]).output().await?
} else {
    Command::new("sh").arg("-c").arg("echo hello").output().await?
};

Implementations

impl Command

pub fn new<S>(program: S) -> Command where
    S: AsRef<OsStr>, 

Constructs a new Command for launching program.

The initial configuration (the working directory and environment variables) is inherited from the current process.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");

pub fn arg<S>(&mut self, arg: S) -> &mut Command where
    S: AsRef<OsStr>, 

Adds a single argument to pass to the program.

Examples

use async_process::Command;

let mut cmd = Command::new("echo");
cmd.arg("hello");
cmd.arg("world");

pub fn args<I, S>(&mut self, args: I) -> &mut Command where
    I: IntoIterator<Item = S>,
    S: AsRef<OsStr>, 

Adds multiple arguments to pass to the program.

Examples

use async_process::Command;

let mut cmd = Command::new("echo");
cmd.args(&["hello", "world"]);

pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Command where
    K: AsRef<OsStr>,
    V: AsRef<OsStr>, 

Configures an environment variable for the new process.

Note that environment variable names are case-insensitive (but case-preserving) on Windows, and case-sensitive on all other platforms.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.env("PATH", "/bin");

pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Command where
    I: IntoIterator<Item = (K, V)>,
    K: AsRef<OsStr>,
    V: AsRef<OsStr>, 

Configures multiple environment variables for the new process.

Note that environment variable names are case-insensitive (but case-preserving) on Windows, and case-sensitive on all other platforms.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.envs(vec![("PATH", "/bin"), ("TERM", "xterm-256color")]);

pub fn env_remove<K>(&mut self, key: K) -> &mut Command where
    K: AsRef<OsStr>, 

Removes an environment variable mapping.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.env_remove("PATH");

pub fn env_clear(&mut self) -> &mut Command

Removes all environment variable mappings.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.env_clear();

pub fn current_dir<P>(&mut self, dir: P) -> &mut Command where
    P: AsRef<Path>, 

Configures the working directory for the new process.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.current_dir("/");

pub fn stdin<T>(&mut self, cfg: T) -> &mut Command where
    T: Into<Stdio>, 

Configures the standard input (stdin) for the new process.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("cat");
cmd.stdin(Stdio::null());

pub fn stdout<T>(&mut self, cfg: T) -> &mut Command where
    T: Into<Stdio>, 

Configures the standard output (stdout) for the new process.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("ls");
cmd.stdout(Stdio::piped());

pub fn stderr<T>(&mut self, cfg: T) -> &mut Command where
    T: Into<Stdio>, 

Configures the standard error (stderr) for the new process.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("ls");
cmd.stderr(Stdio::piped());

pub fn reap_on_drop(&mut self, reap_on_drop: bool) -> &mut Command

Configures whether to reap the zombie process when Child is dropped.

When the process finishes, it becomes a “zombie” and some resources associated with it remain until Child::try_status(), Child::status(), or Child::output() collects its exit code.

If its exit code is never collected, the resources may leak forever. This crate has a background thread named “async-process” that collects such “zombie” processes and then “reaps” them, thus preventing the resource leaks.

The default value of this option is true.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("cat");
cmd.reap_on_drop(false);

pub fn kill_on_drop(&mut self, kill_on_drop: bool) -> &mut Command

Configures whether to kill the process when Child is dropped.

The default value of this option is false.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("cat");
cmd.kill_on_drop(true);

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

Executes the command and returns the Child handle to it.

If not configured, stdin, stdout and stderr will be set to Stdio::inherit().

After spawning the process, stdin, stdout, and stderr become unconfigured again.

Examples

use async_process::Command;

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

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

Executes the command, waits for it to exit, and returns the exit status.

If not configured, stdin, stdout and stderr will be set to Stdio::inherit().

After spawning the process, stdin, stdout, and stderr become unconfigured again.

Examples

use async_process::Command;

let status = Command::new("cp")
    .arg("a.txt")
    .arg("b.txt")
    .status()
    .await?;

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

Executes the command and collects its output.

If not configured, stdin will be set to Stdio::null(), and stdout and stderr will be set to Stdio::piped().

After spawning the process, stdin, stdout, and stderr become unconfigured again.

Examples

use async_process::Command;

let output = Command::new("cat")
    .arg("a.txt")
    .output()
    .await?;

Trait Implementations

impl CommandExt for Command

fn uid(&mut self, id: u32) -> &mut Command

Sets the child process’s user ID. This translates to a setuid call in the child process. Failure in the setuid call will cause the spawn to fail.

fn gid(&mut self, id: u32) -> &mut Command

Similar to uid, but sets the group ID of the child process. This has the same semantics as the uid field.

unsafe fn pre_exec<F>(&mut self, f: F) -> &mut Command where
    F: 'static + FnMut() -> Result<(), Error> + Send + Sync, 

Schedules a closure to be run just before the exec function is invoked.

fn exec(&mut self) -> Error

Performs all the required setup by this Command, followed by calling the execvp syscall.

fn arg0<S>(&mut self, arg: S) -> &mut Command where
    S: AsRef<OsStr>, 

Set executable argument

impl Debug for Command

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

Formats the value using the given formatter.