Struct InteractiveProcess 

pub struct InteractiveProcess { /* private fields */ }

Wraps a Child object in an interface for doing newline-dellimited string IO with a child process.

Calling send sends a string to the process’s stdin. A newline delimiter is automatically appended. If newline characters are present in the provided string, they will not be escaped.

Each newline-separated string sent by the child process over stdout results a call to the provided line_callback function. The line is wrapped in a std::io::Result; it will be in the Err state if the line is not valid UTF-8.

A callback may optionally be provided (via new_with_exit_callback) which is invoked when the child’s stdout stream is closed.

Implementations

impl InteractiveProcess

pub fn new<T>(command: &mut Command, line_callback: T) -> Result<Self>

where T: Fn(Result<String>) + Send + 'static,

Attempt to start a process for the provided Command, capturing the standard in and out streams for later use. The provided callback is called for every newline-terminated string written to stdout by the process.

Examples found in repository

examples/bash.rs (lines 12-14)

fn main() {
    let mut cmd = Command::new("/usr/bin/bash");
    let mut proc = InteractiveProcess::new(&mut cmd, |line| {
        println!("Got: {}", line.unwrap());
    })
    .unwrap();

    sleep(Duration::from_millis(10));

    proc.send("echo 'Hi from bash. Running ls:'").unwrap();
    proc.send("ls").unwrap();

    sleep(Duration::from_millis(10));

    proc.close();
}

examples/echo_stream.rs (lines 6-8)

fn main() {
    let mut cmd = Command::new("examples/echo_stream.py");
    let mut proc = InteractiveProcess::new(&mut cmd, |line| {
        println!("Got: {}", line.unwrap());
    })
    .unwrap();

    proc.send("data1").unwrap();
    sleep(Duration::from_secs(1));
    proc.send("data2").unwrap();
    sleep(Duration::from_secs(1));
    proc.send("data3").unwrap();

    // If we don't sleep here, the process won't have time to reply
    // before we kill it.
    sleep(Duration::from_millis(1));

    proc.close().kill().unwrap();
}

pub fn new_with_exit_callback<T, S>( command: &mut Command, line_callback: T, exit_callback: S, ) -> Result<Self>

where T: Fn(Result<String>) + Send + 'static, S: Fn() + Send + 'static,

Constructor with the same semantics as new, except that an additional no-argument closure is provided which is called when the client exits.

Examples found in repository

examples/closing_stream.rs (lines 6-12)

fn main() {
    let mut cmd = Command::new("examples/closing_stream.py");
    let proc = InteractiveProcess::new_with_exit_callback(
        &mut cmd,
        |line| {
            println!("Got: {}", line.unwrap());
        },
        || println!("Child exited."),
    )
    .unwrap();

    println!("{}", proc.wait().unwrap());
}

pub fn send(&mut self, data: &str) -> Result<()>

Send a string to the client process’s stdin stream. A newline will be appended to the string.

Examples found in repository

examples/bash.rs (line 19)

fn main() {
    let mut cmd = Command::new("/usr/bin/bash");
    let mut proc = InteractiveProcess::new(&mut cmd, |line| {
        println!("Got: {}", line.unwrap());
    })
    .unwrap();

    sleep(Duration::from_millis(10));

    proc.send("echo 'Hi from bash. Running ls:'").unwrap();
    proc.send("ls").unwrap();

    sleep(Duration::from_millis(10));

    proc.close();
}

examples/echo_stream.rs (line 11)

fn main() {
    let mut cmd = Command::new("examples/echo_stream.py");
    let mut proc = InteractiveProcess::new(&mut cmd, |line| {
        println!("Got: {}", line.unwrap());
    })
    .unwrap();

    proc.send("data1").unwrap();
    sleep(Duration::from_secs(1));
    proc.send("data2").unwrap();
    sleep(Duration::from_secs(1));
    proc.send("data3").unwrap();

    // If we don't sleep here, the process won't have time to reply
    // before we kill it.
    sleep(Duration::from_millis(1));

    proc.close().kill().unwrap();
}

pub fn send_unterminated(&mut self, data: &str) -> Result<()>

Send a string to the client process’s stdin stream, without appending a newline.

pub fn close(self) -> Child

Consume this InteractiveProcess and return its child. This closes the process’s stdin stream, which usually kills the process. If it doesn’t, you can use the returned Child object to kill it:

proc = InteractiveProces::new(...);
proc.take().kill().unwrap();

Examples found in repository

examples/bash.rs (line 24)

fn main() {
    let mut cmd = Command::new("/usr/bin/bash");
    let mut proc = InteractiveProcess::new(&mut cmd, |line| {
        println!("Got: {}", line.unwrap());
    })
    .unwrap();

    sleep(Duration::from_millis(10));

    proc.send("echo 'Hi from bash. Running ls:'").unwrap();
    proc.send("ls").unwrap();

    sleep(Duration::from_millis(10));

    proc.close();
}

examples/echo_stream.rs (line 21)

fn main() {
    let mut cmd = Command::new("examples/echo_stream.py");
    let mut proc = InteractiveProcess::new(&mut cmd, |line| {
        println!("Got: {}", line.unwrap());
    })
    .unwrap();

    proc.send("data1").unwrap();
    sleep(Duration::from_secs(1));
    proc.send("data2").unwrap();
    sleep(Duration::from_secs(1));
    proc.send("data3").unwrap();

    // If we don't sleep here, the process won't have time to reply
    // before we kill it.
    sleep(Duration::from_millis(1));

    proc.close().kill().unwrap();
}

pub fn wait(self) -> Result<ExitStatus>

Block the current thread on the process exiting, and return the exit code when it does. This does not send a signal to kill the child, so it only makes sense when the child process is self-terminating.

Examples found in repository

examples/closing_stream.rs (line 15)

fn main() {
    let mut cmd = Command::new("examples/closing_stream.py");
    let proc = InteractiveProcess::new_with_exit_callback(
        &mut cmd,
        |line| {
            println!("Got: {}", line.unwrap());
        },
        || println!("Child exited."),
    )
    .unwrap();

    println!("{}", proc.wait().unwrap());
}