Crate tokio_signal

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

extern crate futures;
extern crate tokio_core;
extern crate tokio_signal;

use tokio_core::reactor::Core;
use futures::{Future, Stream};

fn main() {
    let mut core = Core::new().unwrap();

    // 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::ctrl_c().flatten_stream();

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

    core.run(prog).unwrap();
}

Wait for SIGHUP on Unix

extern crate futures;
extern crate tokio_core;
extern crate tokio_signal;

use tokio_core::reactor::Core;
use futures::{Future, Stream};
use tokio_signal::unix::{Signal, SIGHUP};

fn main() {
    let mut core = Core::new().unwrap();

    // 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).flatten_stream();

    // Convert out stream into a future and block the program
    core.run(stream.into_future()).ok().unwrap();
}

Modules

unix	Unix-specific types for signal handling.

Functions

ctrl_c	Creates a stream which receives "ctrl-c" notifications sent to a process.
ctrl_c_handle	Creates a stream which receives "ctrl-c" notifications sent to a process.

Type Definitions

IoFuture	A future whose error is io::Error
IoStream	A stream whose error is io::Error