Struct shell_protocol::ProcessHandler [−][src]
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
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
Methods
impl ProcessHandler
[src]
impl ProcessHandler
pub fn spawn(
command: &str,
args: Option<Vec<String>>
) -> Result<ProcessHandler, ProtocolError>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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
[src]
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>
[src]
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>
[src]
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), }
Auto Trait Implementations
impl Send for ProcessHandler
impl Send for ProcessHandler
impl Sync for ProcessHandler
impl Sync for ProcessHandler