1.0.0[−][src]Struct boolean_enums::lstd::process::Command
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 std::process::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 std::process::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 std::process::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"); println!(""); // Change `ls` to execute in the root directory. list_dir.current_dir("/"); // And then execute `ls` again but in the root directory. list_dir.status().expect("process failed to execute");
Methods
impl Command
[src]
impl Command
pub fn new<S>(program: S) -> Command where | [src] |
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.
The search path to be used may be controlled by setting the
PATH
environment variable on the Command,
but this has some implementation limitations on Windows
(see https://github.com/rust-lang/rust/issues/37519).
Examples
Basic usage:
use std::process::Command; Command::new("sh") .spawn() .expect("sh command failed to start");
pub fn arg<S>(&mut self, arg: S) -> &mut Command where | [src] |
Add 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
.
Examples
Basic usage:
use std::process::Command; Command::new("ls") .arg("-l") .arg("-a") .spawn() .expect("ls command failed to start");
pub fn args<I, S>(&mut self, args: I) -> &mut Command where | [src] |
Add multiple arguments to pass to the program.
To pass a single argument see arg
.
Examples
Basic usage:
use std::process::Command; Command::new("ls") .args(&["-l", "-a"]) .spawn() .expect("ls command failed to start");
pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Command where | [src] |
Inserts or updates an environment variable mapping.
Note that environment variable names are case-insensitive (but case-preserving) on Windows, and case-sensitive on all other platforms.
Examples
Basic usage:
use std::process::Command; Command::new("ls") .env("PATH", "/bin") .spawn() .expect("ls command failed to start");
pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Command where | 1.19.0 [src] |
Add or update multiple environment variable mappings.
Examples
Basic usage:
use std::process::{Command, Stdio}; use std::env; use std::collections::HashMap; let filtered_env : HashMap<String, String> = env::vars().filter(|&(ref k, _)| k == "TERM" || k == "TZ" || k == "LANG" || k == "PATH" ).collect(); Command::new("printenv") .stdin(Stdio::null()) .stdout(Stdio::inherit()) .env_clear() .envs(&filtered_env) .spawn() .expect("printenv failed to start");
pub fn env_remove<K>(&mut self, key: K) -> &mut Command where | [src] |
Removes an environment variable mapping.
Examples
Basic usage:
use std::process::Command; Command::new("ls") .env_remove("PATH") .spawn() .expect("ls command failed to start");
pub fn env_clear(&mut self) -> &mut Command | [src] |
Clears the entire environment map for the child process.
Examples
Basic usage:
use std::process::Command; Command::new("ls") .env_clear() .spawn() .expect("ls command failed to start");
pub fn current_dir<P>(&mut self, dir: P) -> &mut Command where | [src] |
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 std::process::Command; Command::new("ls") .current_dir("/bin") .spawn() .expect("ls command failed to start");
pub fn stdin<T>(&mut self, cfg: T) -> &mut Command where | [src] |
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 std::process::{Command, Stdio}; Command::new("ls") .stdin(Stdio::null()) .spawn() .expect("ls command failed to start");
pub fn stdout<T>(&mut self, cfg: T) -> &mut Command where | [src] |
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");
pub fn stderr<T>(&mut self, cfg: T) -> &mut Command where | [src] |
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");
pub fn spawn(&mut self) -> Result<Child, Error> | [src] |
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 std::process::Command; Command::new("ls") .spawn() .expect("ls command failed to start");
pub fn output(&mut self) -> Result<Output, Error> | [src] |
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 std::process::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());
pub fn status(&mut self) -> Result<ExitStatus, Error> | [src] |
Executes a command as a child process, waiting for it to finish and collecting its exit status.
By default, stdin, stdout and stderr are inherited from the parent.
Examples
use std::process::Command; let status = Command::new("/bin/cat") .arg("file.txt") .status() .expect("failed to execute process"); println!("process exited with: {}", status); assert!(status.success());
Trait Implementations
impl Debug for Command
[src]
impl Debug for Command
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> | [src] |
Format the program and arguments of a Command for display. Any non-utf8 data is lossily converted using the utf8 replacement character.
impl CommandExt for Command
[src]
impl CommandExt for Command
Auto Trait Implementations
Blanket Implementations
impl<T, U> Into for T where
U: From<T>,
[src]
impl<T, U> Into for T where
U: From<T>,
impl<T> From for T
[src]
impl<T> From for T
impl<T, U> TryFrom for T where
T: From<U>,
[src]
impl<T, U> TryFrom for T where
T: From<U>,
type Error = !
try_from
)The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error> | [src] |
impl<T> Borrow for T where
T: ?Sized,
[src]
impl<T> Borrow for T where
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
impl<T> Any for T where
T: 'static + ?Sized,
fn get_type_id(&self) -> TypeId | [src] |
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
try_from
)The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> | [src] |
impl<T> BorrowMut for T where
T: ?Sized,
[src]
impl<T> BorrowMut for T where
T: ?Sized,
ⓘImportant traits for &'a mut W
fn borrow_mut(&mut self) -> &mut T | [src] |