pub struct Command { /* private fields */ }
Expand description
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§
source§impl Command
impl Command
sourcepub fn arg<S>(&mut self, arg: S) -> &mut Command
pub fn arg<S>(&mut self, arg: S) -> &mut Command
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");
sourcepub fn args<I, S>(&mut self, args: I) -> &mut Command
pub fn args<I, S>(&mut self, args: I) -> &mut Command
Adds multiple arguments to pass to the program.
Examples
use async_process::Command;
let mut cmd = Command::new("echo");
cmd.args(&["hello", "world"]);
sourcepub fn env<K, V>(&mut self, key: K, val: V) -> &mut Command
pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Command
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");
sourcepub fn envs<I, K, V>(&mut self, vars: I) -> &mut Command
pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Command
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")]);
sourcepub fn env_remove<K>(&mut self, key: K) -> &mut Command
pub fn env_remove<K>(&mut self, key: K) -> &mut Command
Removes an environment variable mapping.
Examples
use async_process::Command;
let mut cmd = Command::new("ls");
cmd.env_remove("PATH");
sourcepub fn env_clear(&mut self) -> &mut Command
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();
sourcepub fn current_dir<P>(&mut self, dir: P) -> &mut Command
pub fn current_dir<P>(&mut self, dir: P) -> &mut Command
Configures the working directory for the new process.
Examples
use async_process::Command;
let mut cmd = Command::new("ls");
cmd.current_dir("/");
sourcepub fn stdin<T>(&mut self, cfg: T) -> &mut Command
pub fn stdin<T>(&mut self, cfg: T) -> &mut Command
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());
sourcepub fn stdout<T>(&mut self, cfg: T) -> &mut Command
pub fn stdout<T>(&mut self, cfg: T) -> &mut Command
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());
sourcepub fn stderr<T>(&mut self, cfg: T) -> &mut Command
pub fn stderr<T>(&mut self, cfg: T) -> &mut Command
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());
sourcepub fn reap_on_drop(&mut self, reap_on_drop: bool) -> &mut Command
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);
sourcepub fn kill_on_drop(&mut self, kill_on_drop: bool) -> &mut Command
pub fn kill_on_drop(&mut self, kill_on_drop: bool) -> &mut Command
sourcepub fn spawn(&mut self) -> Result<Child, Error>
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()
.
Examples
use async_process::Command;
let child = Command::new("ls").spawn()?;
sourcepub fn status(&mut self) -> impl Future<Output = Result<ExitStatus, Error>>
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()
.
Examples
use async_process::Command;
let status = Command::new("cp")
.arg("a.txt")
.arg("b.txt")
.status()
.await?;
sourcepub fn output(&mut self) -> impl Future<Output = Result<Output, Error>>
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()
.
Examples
use async_process::Command;
let output = Command::new("cat")
.arg("a.txt")
.output()
.await?;
Trait Implementations§
source§impl CommandExt for Command
impl CommandExt for Command
source§fn uid(&mut self, id: u32) -> &mut Command
fn uid(&mut self, id: u32) -> &mut Command
setuid
call in the child process. Failure in the setuid
call will cause the spawn to fail.source§fn gid(&mut self, id: u32) -> &mut Command
fn gid(&mut self, id: u32) -> &mut Command
uid
, but sets the group ID of the child process. This has
the same semantics as the uid
field.source§unsafe fn pre_exec<F>(&mut self, f: F) -> &mut Command
unsafe fn pre_exec<F>(&mut self, f: F) -> &mut Command
exec
function is
invoked. Read more