I/O Process

Set of I/O-free Rust coroutines and runtimes to manage processes.

This library allows you to manage processes using an I/O-agnostic approach, based on 3 concepts:

Coroutine

A coroutine is an I/O-free, resumable and composable state machine that emits I/O requests. A coroutine is considered terminated when it does not emit I/O requests anymore.

See available coroutines at ./src/coroutines.

Runtime

A runtime contains all the I/O logic, and is responsible for processing I/O requests emitted by coroutines.

See available runtimes at ./src/runtimes.

Loop

The loop is the glue between coroutines and runtimes. It makes the coroutine progress while allowing runtime to process I/O.

Examples

See complete examples at ./examples.

Spawn std blocking command

use io_process::{
    coroutines::spawn_then_wait::{SpawnThenWaitResult, SpawnThenWait},
    runtimes::std::handle,
    command::Command,
};

let mut command = Command::new("ls");
command.arg("-al");
command.arg("/tmp");

let mut arg = None;
let mut spawn = SpawnThenWait::new(command);

let status = loop {
    match spawn.resume(arg.take()) {
        SpawnThenWaitResult::Ok(status) => break status,
        SpawnThenWaitResult::Io(io) => arg = Some(handle(io).unwrap()),
        SpawnThenWaitResult::Err(err) => panic!("{err}"),
    }
}

Spawn tokio async command then wait for output

use io_process::{
    coroutines::spawn_then_wait_with_output::{
	SpawnThenWaitWithOutputResult,
        SpawnThenWaitWithOutput,
    },
    runtimes::std::handle,
    command::Command,
};

let mut command = Command::new("ls");
command.arg("-al");
command.arg("/tmp");

let mut arg = None;
let mut spawn = SpawnThenWaitWithOutput::new(command);

let output = loop {
    match spawn.resume(arg.take()) {
        SpawnThenWaitWithOutputResult::Ok(status) => break status,
        SpawnThenWaitWithOutputResult::Io(io) => arg = Some(handle(io).await.unwrap()),
        SpawnThenWaitWithOutputResult::Err(err) => panic!("{err}"),
    }
}

More examples

Have a look at projects built on the top of this library:

Comodoro: CLI to manage timers
Ortie: CLI to manage OAuth access tokens

License

This project is licensed under either of:

at your option.

Sponsoring

Special thanks to the NLnet foundation and the European Commission that helped the project to receive financial support from various programs:

NGI Assure in 2022
NGI Zero Entrust in 2023
NGI Zero Core in 2024 (still ongoing)

If you appreciate the project, feel free to donate using one of the following providers:

io-process 0.0.2