Struct procspawn::JoinHandle

pub struct JoinHandle<T> { /* private fields */ }

An owned permission to join on a process (block on its termination).

The join handle can be used to join a process but also provides the ability to kill it.

Implementations

impl<T> JoinHandle<T>

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

Returns the process ID if available.

The process ID is unavailable when pooled calls are not scheduled to processes.

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

Kill the child process.

If the join handle was created from a pool this call will do one of two things depending on the situation:

• if the call was already picked up by the process, the process will be killed.
• if the call was not yet scheduled to a process it will be cancelled.

Examples found in repository

examples/kill.rs (line 7)

fn main() {
    procspawn::init();
    let mut handle = spawn((), |()| loop {});
    handle.kill().unwrap();
}

pub fn stdin(&mut self) -> Option<&mut ChildStdin>

Fetch the stdin handle if it has been captured

pub fn stdout(&mut self) -> Option<&mut ChildStdout>

Fetch the stdout handle if it has been captured

Examples found in repository

examples/stdout.rs (line 15)

fn main() {
    procspawn::init();

    let mut builder = procspawn::Builder::new();
    builder.stdout(Stdio::piped());

    let mut handle = builder.spawn((1, 2), |(a, b)| {
        println!("{:?} {:?}", a, b);
    });

    let mut s = String::new();
    handle.stdout().unwrap().read_to_string(&mut s).unwrap();
    assert_eq!(s, "1 2\n");
}

pub fn stderr(&mut self) -> Option<&mut ChildStderr>

Fetch the stderr handle if it has been captured

impl<T: Serialize + DeserializeOwned> JoinHandle<T>

pub fn join(self) -> Result<T, SpawnError>

Wait for the child process to return a result.

If the join handle was created from a pool the join is virtualized.

Examples found in repository

examples/args.rs (line 8)

fn main() {
    procspawn::init();

    let handle = spawn((), |()| std::env::args().collect::<Vec<_>>());

    let args = handle.join().unwrap();

    println!("args in subprocess: {:?}", args);
}

examples/simple.rs (line 11)

fn main() {
    procspawn::init();

    let handle = spawn((1, 2), |(a, b)| {
        println!("in process: {:?} {:?}", a, b);
        a + b
    });

    println!("result: {}", handle.join().unwrap());
}

examples/macro.rs (line 13)

fn main() {
    procspawn::init();

    let a = 42u32;
    let b = 23u32;
    let c = 1;
    let handle = spawn!((a => new_name1, b, mut c) || -> Result<_, ()> {
        c += 1;
        Ok(new_name1 + b + c)
    });
    let value = handle.join().unwrap();

    println!("{:?}", value);
}

examples/custom-serialization.rs (line 80)

fn main() {
    procspawn::init();

    let bytes = MyBytes::open("Cargo.toml").unwrap();

    let bytes_two = procspawn::spawn!((bytes.clone() => bytes) || {
        println!("length: {}", bytes.bytes.len());
        bytes
    })
    .join()
    .unwrap();

    assert_eq!(bytes, bytes_two);
}

examples/join.rs (line 9)

fn main() {
    procspawn::init();

    let five = spawn(5, fibonacci);
    let ten = spawn(10, fibonacci);
    let thirty = spawn(30, fibonacci);
    assert_eq!(five.join().unwrap(), 5);
    assert_eq!(ten.join().unwrap(), 55);
    assert_eq!(thirty.join().unwrap(), 832_040);
    println!("Successfully calculated fibonacci values!");
}

examples/panic.rs (line 10)

fn main() {
    procspawn::init();

    let handle = spawn((), |()| {
        panic!("Whatever!");
    });

    match handle.join() {
        Ok(()) => unreachable!(),
        Err(err) => {
            let panic = err.panic_info().expect("got a non panic error");
            println!("process panicked with {}", panic.message());
            println!("{:#?}", panic);
        }
    }
}

Additional examples can be found in:

• examples/bad-serialization.rs
• examples/pool.rs

pub fn join_timeout(&mut self, timeout: Duration) -> Result<T, SpawnError>

Like join but with a timeout.

Can be called multiple times. If anything other than a timeout error is returned, the handle becomes unusuable, and subsequent calls to either join or join_timeout will return an error.

Examples found in repository

examples/timeout.rs (line 12)

fn main() {
    procspawn::init();

    let mut handle = spawn((), |()| {
        thread::sleep(Duration::from_secs(10));
    });

    println!("result: {:?}", handle.join_timeout(Duration::from_secs(1)));
}

Trait Implementations

impl<T> Debug for JoinHandle<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.