Execute

This library is used for extending Command in order to execute programs more easily.

Usage

```rust extern crate execute;

use std::process::Command;

use execute::Execute;

// ... ```

Verify the Program

Since Command is used for spawning a process of a command and the executed progrom is external which may not exist or may not be the program that we expected, we usually need to verify the external program at runtime.

The execute_check_exit_status_code method can be used to execute a command and check its exit status. For example,

```rust extern crate execute;

use std::process::Command;

use execute::Execute;

const FFMPEG_PATH: &str = "/path/to/ffmpeg";

let mut firstcommand = Command::new(FFMPEGPATH);

first_command.arg("-version");

if firstcommand.executecheckexitstatuscode(0).iserr() { eprintln!("The path {} is not a correct FFmpeg executable binary file.", FFMPEG_PATH); } ```

Execute and Get the Exit Status

```rust extern crate execute;

use std::process::Command;

use execute::Execute;

const FFMPEG_PATH: &str = "/path/to/ffmpeg";

let mut command = Command::new(FFMPEG_PATH);

command.arg("-i"); command.arg("/path/to/media-file"); command.arg("/path/to/output-file");

if let Some(exitcode) = command.execute().unwrap() { if exitcode == 0 { println!("Ok."); } else { eprintln!("Failed."); } } else { eprintln!("Interrupted!"); } ```

Execute and Get the Output

Output to the Screen

```rust extern crate execute;

use std::process::Command;

use execute::Execute;

const FFMPEG_PATH: &str = "/path/to/ffmpeg";

let mut command = Command::new(FFMPEG_PATH);

command.arg("-i"); command.arg("/path/to/media-file"); command.arg("/path/to/output-file");

let output = command.execute_output().unwrap();

if let Some(exitcode) = output.status.code() { if exitcode == 0 { println!("Ok."); } else { eprintln!("Failed."); } } else { eprintln!("Interrupted!"); } ```

Output to Memory (Captured)

```rust extern crate execute;

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

use execute::Execute;

const FFMPEG_PATH: &str = "/path/to/ffmpeg";

let mut command = Command::new(FFMPEG_PATH);

command.arg("-i"); command.arg("/path/to/media-file"); command.arg("/path/to/output-file");

command.stdout(Stdio::piped()); command.stderr(Stdio::piped());

let output = command.execute_output().unwrap();

if let Some(exitcode) = output.status.code() { if exitcode == 0 { println!("Ok."); } else { eprintln!("Failed."); } } else { eprintln!("Interrupted!"); }

println!("{}", String::fromutf8(output.stdout).unwrap()); println!("{}", String::fromutf8(output.stderr).unwrap()); ```

Execute and Input Data

Input In-memory Data

```rust extern crate execute;

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

use execute::Execute;

let mut bc_command = Command::new("bc");

bc_command.stdout(Stdio::piped());

let output = bccommand.executeinput_output("2^99\n").unwrap();

println!("Answer: {}", String::fromutf8(output.stdout).unwrap().trimend()); ```

Input from a Reader

```rust extern crate execute;

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

use execute::Execute;

let mut cat_command = Command::new("cat");

cat_command.stdout(Stdio::piped());

let mut file = File::open("Cargo.toml").unwrap();

let output = catcommand.executeinputreaderoutput(&mut file).unwrap();

println!("{}", String::from_utf8(output.stdout).unwrap()); ```

By default, the buffer size is 256 bytes. If you want to change that, you can use the _reader_output2 or _reader2 methods and define a length explicitly.

For example, to change the buffer size to 4096 bytes,

```rust extern crate execute;

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

use execute::generic_array::typenum::U4096; use execute::Execute;

let mut cat_command = Command::new("cat");

cat_command.stdout(Stdio::piped());

let mut file = File::open("Cargo.toml").unwrap();

let output = catcommand.executeinputreaderoutput2::(&mut file).unwrap();

println!("{}", String::from_utf8(output.stdout).unwrap()); ```

Execute Multiple Commands and Pipe Them Together

```rust extern crate execute;

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

use execute::Execute;

let mut command1 = Command::new("echo"); command1.arg("HELLO WORLD");

let mut command2 = Command::new("cut"); command2.arg("-d").arg(" ").arg("-f").arg("1");

let mut command3 = Command::new("tr"); command3.arg("A-Z").arg("a-z");

command3.stdout(Stdio::piped());

let output = command1.executemultipleoutput(&mut [&mut command2, &mut command3]).unwrap();

asserteq!(b"hello\n", output.stdout.asslice()); ```

Run a Command String in the Current Shell

The shell function can be used to create a Command instance with a single command string instead of a program name and scattered arguments.

```rust extern crate execute;

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

use execute::{Execute, shell};

if cfg!(target_os = "linux") {

let mut command = shell("cat /proc/meminfo");

command.stdout(Stdio::piped());

let output = command.execute_output().unwrap();

println!("{}", String::from_utf8(output.stdout).unwrap());

}

```

Parse a Command String

The command function can be used to create a Command instance with a single command string instead of a program name and scattered arguments. The difference between the shell function and the command function is that the former is interpreted by the current shell while the latter is parsed by this crate.

```rust extern crate execute;

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

use execute::{Execute, command};

if cfg!(target_os = "linux") {

let mut command = command("cat '/proc/meminfo'");

command.stdout(Stdio::piped());

let output = command.execute_output().unwrap();

println!("{}", String::from_utf8(output.stdout).unwrap());

}

```

Crates.io

https://crates.io/crates/execute

Documentation

https://docs.rs/execute

License

MIT