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
sourceimpl Command
impl Command
sourcepub fn arg<S>(&mut self, arg: S) -> &mut Command where
S: AsRef<OsStr>,
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");
sourcepub fn args<I, S>(&mut self, args: I) -> &mut Command where
I: IntoIterator<Item = S>,
S: AsRef<OsStr>,
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"]);
sourcepub fn env<K, V>(&mut self, key: K, val: V) -> &mut Command where
K: AsRef<OsStr>,
V: AsRef<OsStr>,
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");
sourcepub fn envs<I, K, V>(&mut self, vars: I) -> &mut Command where
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
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")]);
sourcepub fn env_remove<K>(&mut self, key: K) -> &mut Command where
K: AsRef<OsStr>,
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");
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 where
P: AsRef<Path>,
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("/");
sourcepub fn stdin<T>(&mut self, cfg: T) -> &mut Command where
T: Into<Stdio>,
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());
sourcepub fn stdout<T>(&mut self, cfg: T) -> &mut Command where
T: Into<Stdio>,
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());
sourcepub fn stderr<T>(&mut self, cfg: T) -> &mut Command where
T: Into<Stdio>,
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());
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()
.
After spawning the process, stdin, stdout, and stderr become unconfigured again.
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()
.
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?;
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()
.
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
sourceimpl CommandExt for Command
impl CommandExt for Command
sourcefn uid(&mut self, id: u32) -> &mut 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. Read more
sourcefn gid(&mut self, id: u32) -> &mut Command
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. Read more
sourceunsafe fn pre_exec<F>(&mut self, f: F) -> &mut Command where
F: 'static + FnMut() -> Result<(), Error> + Send + Sync,
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. Read more
Auto Trait Implementations
impl !RefUnwindSafe for Command
impl Send for Command
impl Sync for Command
impl Unpin for Command
impl !UnwindSafe for Command
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more