How do I invoke a system command and capture its output?

Question

Is there a way to invoke a system command, like ls or fuser in Rust? How about capturing its output?

Answer 1

std::process::Command allows for that.

There are multiple ways to spawn a child process and execute an arbitrary command on the machine:

• spawn — runs the program and returns a value with details
• output — runs the program and returns the output
• status — runs the program and returns the exit code

One simple example from the docs:

use std::process::Command;

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

Answer 2

a very clear example from the docs:

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());

Answer 3

It is indeed possible! The relevant module is std::run.

let mut options = std::run::ProcessOptions::new();
let process = std::run::Process::new("ls", &[your, arguments], options);

ProcessOptions’ standard file descriptors default to None (create a new pipe), so you can just use process.output() (for example) to read from its output.

If you want to run the command and get all its output after it’s done, there’s wait_with_output for that.

Process::new, as of yesterday, returns an Option<Process> instead of a Process, by the way.

Answer 4

Command builds and configures a child process. When you create a new instance of Command and specify the command you want to execute, any arguments, environment variables, and other settings, you are defining the configuration for a child process.

use std::process::{Command, Stdio};

let system_command = "echo";
let argument = "Hello World";

let echo_hello: std::process::Output = Command::new(system_command)
                        .arg(argument)
                        //.current_dir(TEST_PATH)
                        // Stdio::piped() creates pipes to capture stdout and stderr of a child process which is created by Command. 
                        // we are telling the Command to create a pipe to capture the standard output (stdout) of the child process.
                        .stdout(Stdio::piped())
                        // creating a pipe to capture the standard error (stderr) of the child process.
                        .stderr(Stdio::piped())
                        // output() executes the child process synchronously and captures its output. 
                        //It returns a std::process::Output struct containing information about the process's exit status, stdout, and stderr.
                        .output()
                        .expect("Failed to echo");

you could use spawn() instead of output() to execute the child process asynchronously. Using spawn() will allow the child process to run independently of the parent process. spawn() returns

std::process::Child 

If you need to terminate the child process prematurely for some reason, you can call the kill() method on the std::process::Child handle. On the other hand, once the output() method is called, the child process runs to completion, and there is no direct mechanism provided by output() to terminate the process prematurely.