[][src]Struct shell_protocol::ProcessHandler

pub struct ProcessHandler {
    pub stdout_reader: Option<BufReader<TimeoutReader<ChildStdout>>>,
    pub stderr_reader: Option<BufReader<TimeoutReader<ChildStderr>>>,
    // some fields omitted
}

Structure to handle lifetime and communications with child process

Fields

Buffered timeout reader pointed to stdout pipe

Buffered timeout reader pointed to stderr pipe

Methods

impl ProcessHandler
[src]

Spawn a process and setup handler structure

Arguments

  • command - Path to binary to execute
  • args - Optional arguments for binary

Examples

use shell_protocol::*;

let proc = ProcessHandler::spawn(&"/bin/bash".to_owned(), None);
use shell_protocol::*;

let proc = ProcessHandler::spawn(&"ls".to_owned(), Some(vec!["-l".to_owned()]));

Attempt to read from stdout

A return value of None indicates the stream is no longer available and likewise the process is likely no longer alive.

Examples

use shell_protocol::*;

let mut proc = ProcessHandler::spawn(&"ls".to_owned(), None).unwrap();
match proc.read_stdout() {
    Ok(Some(output)) => println!("Stdout: {}", output),
    Ok(None) => println!("Stdout time out"),
    Err(e) => eprintln!("Stdout err {}", e),
}

Attempt to read from stderr

A return value of None indicates the stream is no longer available and likewise the process is likely no longer alive.

Examples

use shell_protocol::*;

let mut proc = ProcessHandler::spawn(&"ls".to_owned(), None).unwrap();
match proc.read_stderr() {
    Ok(Some(output)) => println!("Stderr: {}", output),
    Ok(None) => println!("Stderr time out"),
    Err(e) => eprintln!("Stderr err {}", e),
}

Attempt to write to stdin

Arguments

  • data - Slice of bytes to write

Examples

use shell_protocol::*;

let cmd = "ls\n".as_bytes();
let mut proc = ProcessHandler::spawn(&"/bin/bash".to_owned(), None).unwrap();
match proc.write_stdin(&cmd) {
    Ok(()) => println!("Stdin write success"),
    Err(e) => eprintln!("Stdin err {}", e),
}

Close process' stdin pipe

Examples

use shell_protocol::*;

let mut proc = ProcessHandler::spawn(&"/bin/bash".to_owned(), None).unwrap();
match proc.close_stdin() {
    Ok(()) => println!("Stdin closed"),
    Err(e) => eprintln!("Stdin close err {}", e),
}

Retrieve ID of process

Examples

use shell_protocol::*;

let proc = ProcessHandler::spawn(&"/bin/bash".to_owned(), None).unwrap();
let pid = proc.id();

Check to see if a process has exited and if the exit status is available

Examples

use shell_protocol::*;

let mut proc = ProcessHandler::spawn(&"/bin/bash".to_owned(), None).unwrap();
match proc.status() {
    Ok(Some((code, signal))) => println!("Process has exited: {}, {}", code, signal),
    Ok(None) => println!("Process has not exited"),
    Err(e) => eprintln!("Error getting process status {}", e)
}

Send killing signal to process

Arguments

  • signal - Optional signal to send to process

Examples

use shell_protocol::*;

let mut proc = ProcessHandler::spawn(&"/bin/bash".to_owned(), None).unwrap();
match proc.kill(None) {
    Ok(()) => println!("Process killed"),
    Err(e) => eprintln!("Error killing process: {}", e),
}

Auto Trait Implementations

impl Send for ProcessHandler

impl Sync for ProcessHandler

Blanket Implementations

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> From for T
[src]

impl<T, U> TryFrom for T where
    T: From<U>, 
[src]

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> BorrowMut for T where
    T: ?Sized
[src]