Struct std::process::Command1.0.0 [−] [src]

pub struct Command {
    // some fields omitted
}

The Command type acts as 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:

fn main() { use std::process::Command; let output = Command::new("sh") .arg("-c") .arg("echo hello") .output() .expect("failed to execute proces"); let hello = output.stdout; }
use std::process::Command;

let output = Command::new("sh")
                     .arg("-c")
                     .arg("echo hello")
                     .output()
                     .expect("failed to execute proces");

let hello = output.stdout;

Methods

impl Command
[src]

fn new<S: AsRef<OsStr>>(program: S) -> Command

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 or status, but create pipes for output

Builder methods are provided to change these defaults and otherwise configure the process.

Examples

Basic usage:

fn main() { use std::process::Command; Command::new("sh") .spawn() .expect("sh command failed to start"); }
use std::process::Command;

Command::new("sh")
        .spawn()
        .expect("sh command failed to start");

fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Command

Add an argument to pass to the program.

Examples

Basic usage:

fn main() { use std::process::Command; Command::new("ls") .arg("-l") .arg("-a") .spawn() .expect("ls command failed to start"); }
use std::process::Command;

Command::new("ls")
        .arg("-l")
        .arg("-a")
        .spawn()
        .expect("ls command failed to start");

fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut Command

Add multiple arguments to pass to the program.

Examples

Basic usage:

fn main() { use std::process::Command; Command::new("ls") .args(&["-l", "-a"]) .spawn() .expect("ls command failed to start"); }
use std::process::Command;

Command::new("ls")
        .args(&["-l", "-a"])
        .spawn()
        .expect("ls command failed to start");

fn env<K, V>(&mut self, key: K, val: V) -> &mut Command where K: AsRef<OsStr>, V: AsRef<OsStr>

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:

fn main() { use std::process::Command; Command::new("ls") .env("PATH", "/bin") .spawn() .expect("ls command failed to start"); }
use std::process::Command;

Command::new("ls")
        .env("PATH", "/bin")
        .spawn()
        .expect("ls command failed to start");

fn env_remove<K: AsRef<OsStr>>(&mut self, key: K) -> &mut Command

Removes an environment variable mapping.

Examples

Basic usage:

fn main() { use std::process::Command; Command::new("ls") .env_remove("PATH") .spawn() .expect("ls command failed to start"); }
use std::process::Command;

Command::new("ls")
        .env_remove("PATH")
        .spawn()
        .expect("ls command failed to start");

fn env_clear(&mut self) -> &mut Command

Clears the entire environment map for the child process.

Examples

Basic usage:

fn main() { use std::process::Command; Command::new("ls") .env_clear() .spawn() .expect("ls command failed to start"); }
use std::process::Command;

Command::new("ls")
        .env_clear()
        .spawn()
        .expect("ls command failed to start");

fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Command

Sets the working directory for the child process.

Examples

Basic usage:

fn main() { use std::process::Command; Command::new("ls") .current_dir("/bin") .spawn() .expect("ls command failed to start"); }
use std::process::Command;

Command::new("ls")
        .current_dir("/bin")
        .spawn()
        .expect("ls command failed to start");

fn stdin(&mut self, cfg: Stdio) -> &mut Command

Configuration for the child process's stdin handle (file descriptor 0).

Examples

Basic usage:

fn main() { use std::process::{Command, Stdio}; Command::new("ls") .stdin(Stdio::null()) .spawn() .expect("ls command failed to start"); }
use std::process::{Command, Stdio};

Command::new("ls")
        .stdin(Stdio::null())
        .spawn()
        .expect("ls command failed to start");

fn stdout(&mut self, cfg: Stdio) -> &mut Command

Configuration for the child process's stdout handle (file descriptor 1).

Examples

Basic usage:

fn main() { use std::process::{Command, Stdio}; Command::new("ls") .stdout(Stdio::null()) .spawn() .expect("ls command failed to start"); }
use std::process::{Command, Stdio};

Command::new("ls")
        .stdout(Stdio::null())
        .spawn()
        .expect("ls command failed to start");

fn stderr(&mut self, cfg: Stdio) -> &mut Command

Configuration for the child process's stderr handle (file descriptor 2).

Examples

Basic usage:

fn main() { use std::process::{Command, Stdio}; Command::new("ls") .stderr(Stdio::null()) .spawn() .expect("ls command failed to start"); }
use std::process::{Command, Stdio};

Command::new("ls")
        .stderr(Stdio::null())
        .spawn()
        .expect("ls command failed to start");

fn spawn(&mut self) -> Result<Child>

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:

fn main() { use std::process::Command; Command::new("ls") .spawn() .expect("ls command failed to start"); }
use std::process::Command;

Command::new("ls")
        .spawn()
        .expect("ls command failed to start");

fn output(&mut self) -> Result<Output>

Executes the command as a child process, waiting for it to finish and collecting all of its output.

By default, stdin, stdout and stderr are captured (and used to provide the resulting output).

Examples

fn main() { use std::process::Command; let output = Command::new("/bin/cat") .arg("file.txt") .output() .expect("failed to execute process"); println!("status: {}", output.status); println!("stdout: {}", String::from_utf8_lossy(&output.stdout)); println!("stderr: {}", String::from_utf8_lossy(&output.stderr)); assert!(output.status.success()); }
use std::process::Command;
let output = Command::new("/bin/cat")
                     .arg("file.txt")
                     .output()
                     .expect("failed to execute process");

println!("status: {}", output.status);
println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
println!("stderr: {}", String::from_utf8_lossy(&output.stderr));

assert!(output.status.success());

fn status(&mut self) -> Result<ExitStatus>

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

fn main() { 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()); }
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 CommandExt for Command
[src]

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

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

fn session_leader(&mut self, on: bool) -> &mut Command

Create a new session (cf. setsid(2)) for the child process. This means that the child is the leader of a new process group. The parent process remains the child reaper of the new process. Read more

fn before_exec<F>(&mut self, f: F) -> &mut Command where F: FnMut() -> Result<()> + Send + Sync + 'static

Schedules a closure to be run just before the exec function is invoked. Read more

fn exec(&mut self) -> Error

Performs all the required setup by this Command, followed by calling the execvp syscall. Read more

impl Debug for Command
[src]

fn fmt(&self, f: &mut Formatter) -> Result

Format the program and arguments of a Command for display. Any non-utf8 data is lossily converted using the utf8 replacement character.