Expand description
An implementation of asynchronous process management for Tokio.
This module provides a Command struct that imitates the interface of the
std::process::Command type in the standard library, but provides asynchronous versions of
functions that create processes. These functions (spawn, status, output and their
variants) return “future aware” types that interoperate with Tokio. The asynchronous process
support is provided through signal handling on Unix and system APIs on Windows.
Examples
Here’s an example program which will spawn echo hello world and then wait
for it complete.
use tokio::process::Command;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// The usage is the same as with the standard library's `Command` type, however the value
// returned from `spawn` is a `Result` containing a `Future`.
let child = Command::new("echo").arg("hello").arg("world")
.spawn();
// Make sure our child succeeded in spawning and process the result
let future = child.expect("failed to spawn");
// Await until the future (and the command) completes
let status = future.await?;
println!("the command exited with: {}", status);
Ok(())
}Next, let’s take a look at an example where we not only spawn echo hello world but we also capture its output.
use tokio::process::Command;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Like above, but use `output` which returns a future instead of
// immediately returning the `Child`.
let output = Command::new("echo").arg("hello").arg("world")
.output();
let output = output.await?;
assert!(output.status.success());
assert_eq!(output.stdout, b"hello world\n");
Ok(())
}We can also read input line by line.
use tokio::io::{BufReader, AsyncBufReadExt};
use tokio::process::Command;
use std::process::Stdio;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut cmd = Command::new("cat");
// Specify that we want the command's standard output piped back to us.
// By default, standard input/output/error will be inherited from the
// current process (for example, this means that standard input will
// come from the keyboard and standard output/error will go directly to
// the terminal if this process is invoked from the command line).
cmd.stdout(Stdio::piped());
let mut child = cmd.spawn()
.expect("failed to spawn command");
let stdout = child.stdout.take()
.expect("child did not have a handle to stdout");
let mut reader = BufReader::new(stdout).lines();
// Ensure the child process is spawned in the runtime so it can
// make progress on its own while we await for any output.
tokio::spawn(async {
let status = child.await
.expect("child process encountered an error");
println!("child status was: {}", status);
});
while let Some(line) = reader.next_line().await? {
println!("Line: {}", line);
}
Ok(())
}Caveats
Similar to the behavior to the standard library, and unlike the futures
paradigm of dropping-implies-cancellation, a spawned process will, by
default, continue to execute even after the Child handle has been dropped.
The Command::kill_on_drop method can be used to modify this behavior
and kill the child process if the Child wrapper is dropped before it
has exited.
Structs
Representation of a child process spawned onto an event loop.
The standard error stream for spawned children.
The standard input stream for spawned children.
The standard output stream for spawned children.
This structure mimics the API of std::process::Command found in the standard library, but
replaces functions that create a process with an asynchronous variant. The main provided
asynchronous functions are spawn, status, and
output.