Struct ProcessRunner 

pub struct ProcessRunner { /* private fields */ }

A running or completed process

Implementations

impl ProcessRunner

pub fn new(command: impl Into<String>, options: RunOptions) -> Self

Create a new process runner

pub async fn start(&mut self) -> Result<()>

Start the process

pub fn child(&mut self) -> Option<ProcessChild<'_>>

Borrow the active operating-system child.

Call start first. The result is None before startup, for built-in commands (which run in-process), and after run consumes and reaps the child. Killing through the returned handle keeps the runner’s process-group and graceful-escalation behavior.

use command_stream::{ProcessRunner, RunOptions};

let mut runner = ProcessRunner::new("sleep 30", RunOptions::default());
runner.start().await?;
if let Some(mut child) = runner.child() {
    println!("child pid: {:?}", child.pid());
    child.kill_with("SIGTERM")?;
}
let _ = runner.run().await?;

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

Write bytes to the stdin pipe of a running command.

Configure the runner with StdinOption::Pipe, call start, write as many chunks as needed, and finish with close_stdin.

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

Close a running command’s stdin pipe so it can observe end-of-input.

pub async fn run(&mut self) -> Result<CommandResult>

Run the process to completion

pub fn kill(&mut self) -> Result<()>

Stop the process using the configured kill signal (RunOptions::kill_signal, default SIGTERM).

Mirrors the JavaScript kill() with no argument.

pub fn kill_with(&mut self, signal: &str) -> Result<()>

Stop the process using an explicit signal, overriding RunOptions::kill_signal for this call.

Mirrors the JavaScript kill(signal). The signal is delivered to the child and its process group, so grandchildren behind a sh -c wrapper are stopped too - except for a child sharing the caller’s terminal, which stays in the caller’s group so CTRL+C keeps reaching it. The child then has RunOptions::kill_grace_ms to run its own handler before SIGKILL follows, so a process that ignores the signal still terminates.

use command_stream::{ProcessRunner, RunOptions};

let mut runner = ProcessRunner::new("sleep 30", RunOptions::default());
runner.start().await?;
runner.kill_with("SIGINT")?; // the CTRL+C signal

pub fn is_finished(&self) -> bool

Check if the process is finished

pub fn result(&self) -> Option<&CommandResult>

Get the result if available

pub fn pid(&self) -> Option<u32>

Process id of the command, or None when there is no operating system process to identify.

It is None before the command starts, and stays None for built-in (virtual) commands such as echo or sleep, which run inside this process and never spawn a child. Once a real command has been spawned the value is stable: it remains readable after the command finishes, unlike the child handle, which run consumes.

Mirrors the JavaScript runner.pid property.

use command_stream::{ProcessRunner, RunOptions};

let mut runner = ProcessRunner::new("/bin/sleep 1", RunOptions::default());
runner.start().await?;
println!("running as pid {:?}", runner.pid());
runner.run().await?;
println!("still readable: {:?}", runner.pid());

pub fn command(&self) -> &str

Get the command string

pub fn options(&self) -> &RunOptions

Get the options

Trait Implementations

impl IntoStream for ProcessRunner

fn into_stream(self) -> OutputStream

Convert into an output stream

impl PipelineExt for ProcessRunner

fn pipe(self, command: impl Into<String>) -> PipelineBuilder

Pipe the output of this command to another command