compio

The compio-process crate provides the following capabilities:

• Async process spawning and management: Control the lifecycle of child processes.
• Async stdio access: Asynchronously interact with stdin, stdout, and stderr streams.
• Cross-platform support: Works on both Unix and Windows.
• Compio integration: Built to work with compio's completion-based IO model.
• Linux pidfd support: Optional support for efficient process monitoring on Linux via pidfd.

The compio-ws crate provides:

• WebSocket client and server support.
• A foundation built on the tungstenite WebSocket library.
• TLS/SSL support via multiple backends:
  • native-tls: Platform-specific TLS.
  • rustls: Pure Rust TLS implementation.
• Various certificate verification options: platform-verifier, native-certs, and webpki-roots.

The compio-driver crate provides the low-level Proactor implementation for the compio ecosystem. It acts as the platform-specific abstraction layer that manages the submission and completion of I/O operations.

While most users will interact with compio indirectly through its high-level runtime, compio-driver can be used directly if you require low-level control over the I/O driver itself.

Supported OS backends:

• Windows: Uses IOCP (IO Completion Ports).
• Linux: Uses io_uring (with an optional polling fallback).
• Other Unix platforms: Uses polling.

To use filesystem operations directly through the main compio crate, you must enable the fs feature. You can do this using cargo add:

cargo add compio --features fs

To use Compio in your Rust project, add it as a dependency using cargo add. It is recommended to enable the macros and fs features for high-level API support and filesystem operations.

cargo add compio --features macros,fs

The compio-compat layer allows you to run compio-specific code within other asynchronous runtimes, such as Tokio. To use this, you should use the compio::compat module re-exported from the main compio crate.

To integrate compio with Tokio:

1. Create a standard compio::runtime::Runtime.
2. Wrap that runtime in a RuntimeCompat using a specific adapter (e.g., TokioAdapter).
3. Use the resulting compat layer to execute your futures.

use compio::compat::{RuntimeCompat, TokioAdapter};

#[tokio::main]
async fn main() {
    // Create a compio runtime:
    let runtime = compio::runtime::Runtime::new().unwrap();
    // Create the compat layer:
    let runtime = RuntimeCompat::<TokioAdapter>::new(runtime).unwrap();
    // Execute your future:
    runtime.execute(async {
        // Run compio-specific code
    }).await;
}

To use the multithreading dispatcher, you must enable the dispatcher feature in your compio dependency via Cargo.

cargo add compio --features dispatcher

To use QUIC protocol support, you must add the compio crate with the quic feature enabled in your Cargo.toml.

cargo add compio --features quic

If you are building an application using the main compio crate, you do not need to add compio-io as a direct dependency. Instead, use the traits re-exported by the compio crate.

use compio::io::{AsyncRead, AsyncWrite};

If you are already using the compio runtime, you can enable signal handling capabilities by enabling the signal feature flag. This allows you to use compio::signal functions directly in your application.

cargo add compio --features signal