tokio-signal

Unix signal handling for Tokio.

License

This project is licensed under the MIT license.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Tokio by you, shall be licensed as MIT, without any additional terms or conditions.

lib.rs:

Asynchronous signal handling for Tokio

This crate implements asynchronous signal handling for Tokio, an asynchronous I/O framework in Rust. The primary type exported from this crate, unix::Signal, allows listening for arbitrary signals on Unix platforms, receiving them in an asynchronous fashion.

Note that signal handling is in general a very tricky topic and should be used with great care. This crate attempts to implement 'best practice' for signal handling, but it should be evaluated for your own applications' needs to see if it's suitable.

The are some fundamental limitations of this crate documented on the Signal structure as well.

Examples

Print out all ctrl-C notifications received

#![feature(async_await)]

use futures_util::future;
use futures_util::stream::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create an infinite stream of "Ctrl+C" notifications. Each item received
    // on this stream may represent multiple ctrl-c signals.
    let ctrl_c = tokio_signal::CtrlC::new()?;

    // Process each ctrl-c as it comes in
    let prog = ctrl_c.for_each(|_| {
        println!("ctrl-c received!");
        future::ready(())
    });

    prog.await;

    Ok(())
}

Wait for SIGHUP on Unix

#![feature(async_await)]

use futures_util::future;
use futures_util::stream::StreamExt;
use tokio_signal::unix::{Signal, SIGHUP};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create an infinite stream of "Ctrl+C" notifications. Each item received
    // on this stream may represent multiple ctrl-c signals.
    let ctrl_c = tokio_signal::CtrlC::new()?;

    // Process each ctrl-c as it comes in
    let prog = ctrl_c.for_each(|_| {
        println!("ctrl-c received!");
        future::ready(())
    });

    prog.await;

    // Like the previous example, this is an infinite stream of signals
    // being received, and signals may be coalesced while pending.
    let stream = Signal::new(SIGHUP)?;

    // Convert out stream into a future and block the program
    let (signal, _signal) = stream.into_future().await;
    println!("got signal {:?}", signal);
    Ok(())
}