Struct wasi_net::process::Command [−][src]
pub struct Command { /* fields omitted */ }
Expand description
A process builder, providing fine-grained control over how a new process should be spawned.
A default configuration can be
generated using Command::new(program)
, where program
gives a path to the
program to be executed. Additional builder methods allow the configuration
to be changed (for example, by adding arguments) prior to spawning:
use wasi_net::Command;
let output = if cfg!(target_os = "windows") {
Command::new("cmd")
.args(&["/C", "echo hello"])
.output()
.expect("failed to execute process")
} else {
Command::new("sh")
.arg("-c")
.arg("echo hello")
.output()
.expect("failed to execute process")
};
let hello = output.stdout;
Command
can be reused to spawn multiple processes. The builder methods
change the command without needing to immediately spawn the process.
use wasi_net::Command;
let mut echo_hello = Command::new("sh");
echo_hello.arg("-c")
.arg("echo hello");
let hello_1 = echo_hello.output().expect("failed to execute process");
let hello_2 = echo_hello.output().expect("failed to execute process");
Similarly, you can call builder methods after spawning a process and then spawn a new process with the modified settings.
use wasi_net::Command;
let mut list_dir = Command::new("ls");
// Execute `ls` in the current directory of the program.
list_dir.status().expect("process failed to execute");
Implementations
Constructs a new Command
for launching the program at
path program
, with the following default configuration:
- No arguments to the program
- Inherit the current process’s environment
- Inherit the current process’s working directory
- Inherit stdin/stdout/stderr for
spawn
orstatus
, but create pipes foroutput
Builder methods are provided to change these defaults and otherwise configure the process.
If program
is not an absolute path, the PATH
will be searched in
an OS-defined way.
Examples
Basic usage:
use wasi_net::Command;
Command::new("sh")
.spawn()
.expect("sh command failed to start");
Adds an argument to pass to the program.
Only one argument can be passed per use. So instead of:
.arg("-C /path/to/repo")
usage would be:
.arg("-C")
.arg("/path/to/repo")
To pass multiple arguments see args
.
Note that the argument is not passed through a shell, but given literally to the program. This means that shell syntax like quotes, escaped characters, word splitting, glob patterns, substitution, etc. have no effect.
Examples
Basic usage:
use wasi_net::Command;
Command::new("ls")
.arg("-l")
.arg("-a")
.spawn()
.expect("ls command failed to start");
Adds multiple arguments to pass to the program.
To pass a single argument see arg
.
Note that the arguments are not passed through a shell, but given literally to the program. This means that shell syntax like quotes, escaped characters, word splitting, glob patterns, substitution, etc. have no effect.
Examples
Basic usage:
use wasi_net::Command;
Command::new("ls")
.args(&["-l", "-a"])
.spawn()
.expect("ls command failed to start");
Sets the working directory for the child process.
Platform-specific behavior
If the program path is relative (e.g., "./script.sh"
), it’s ambiguous
whether it should be interpreted relative to the parent’s working
directory or relative to current_dir
. The behavior in this case is
platform specific and unstable, and it’s recommended to use
canonicalize
to get an absolute program path instead.
Examples
Basic usage:
use wasi_net::Command;
Command::new("ls")
.current_dir("/bin")
.spawn()
.expect("ls command failed to start");
Configuration for the child process’s standard input (stdin) handle.
Defaults to inherit
when used with spawn
or status
, and
defaults to piped
when used with output
.
Examples
Basic usage:
use wasi_net::{Command, Stdio};
Command::new("ls")
.stdin(Stdio::null())
.spawn()
.expect("ls command failed to start");
Configuration for the child process’s standard output (stdout) handle.
Defaults to inherit
when used with spawn
or status
, and
defaults to piped
when used with output
.
Examples
Basic usage:
use std::process::{Command, Stdio};
Command::new("ls")
.stdout(Stdio::null())
.spawn()
.expect("ls command failed to start");
Configuration for the child process’s standard error (stderr) handle.
Defaults to inherit
when used with spawn
or status
, and
defaults to piped
when used with output
.
Examples
Basic usage:
use std::process::{Command, Stdio};
Command::new("ls")
.stderr(Stdio::null())
.spawn()
.expect("ls command failed to start");
Pre-opens a directory before launching the process
Executes the command as a child process, returning a handle to it.
By default, stdin, stdout and stderr are inherited from the parent.
Examples
Basic usage:
use wasi_net::Command;
Command::new("ls")
.spawn()
.expect("ls command failed to start");
Executes the command as a child process, waiting for it to finish and collecting all of its output.
By default, stdout and stderr are captured (and used to provide the resulting output). Stdin is not inherited from the parent and any attempt by the child process to read from the stdin stream will result in the stream immediately closing.
Examples
use wasi_net::Command;
use std::io::{self, Write};
let output = Command::new("/bin/cat")
.arg("file.txt")
.output()
.expect("failed to execute process");
println!("status: {}", output.status);
io::stdout().write_all(&output.stdout).unwrap();
io::stderr().write_all(&output.stderr).unwrap();
assert!(output.status.success());
Executes a command as a child process, waiting for it to finish and collecting its status.
By default, stdin, stdout and stderr are inherited from the parent.
Examples
use wasi_net::Command;
let status = Command::new("/bin/cat")
.arg("file.txt")
.status()
.expect("failed to execute process");
println!("process finished with: {}", status);
assert!(status.success());
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Command
impl UnwindSafe for Command
Blanket Implementations
Mutably borrows from an owned value. Read more