Struct shell_protocol::ProcessHandler

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

Structure to handle lifetime and communications with child process

Fields

stdout_reader: Option<BufReader<TimeoutReader<ChildStdout>>>

Buffered timeout reader pointed to stdout pipe

stderr_reader: Option<BufReader<TimeoutReader<ChildStderr>>>

Buffered timeout reader pointed to stderr pipe

Implementations

impl ProcessHandler

pub fn spawn(
    command: &str,
    args: Option<Vec<String>>
) -> Result<ProcessHandler, ProtocolError>

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

pub fn read_stdout(&mut self) -> Result<Option<String>, ProtocolError>

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),
}

pub fn read_stderr(&mut self) -> Result<Option<String>, ProtocolError>

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),
}

pub fn write_stdin(&mut self, data: &[u8]) -> Result<(), ProtocolError>

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),
}

pub fn close_stdin(&mut self) -> Result<(), ProtocolError>

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),
}

pub fn id(&self) -> u32

Retrieve ID of process

Examples

use shell_protocol::*;

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

pub fn status(&mut self) -> Result<Option<(u32, u32)>, ProtocolError>

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)
}

pub fn kill(&mut self, signal: Option<u32>) -> Result<(), ProtocolError>

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),
}