Crate async_signal

source ·
Expand description

Asynchronous signal handling.

This crate provides the Signals type, which can be used to listen for POSIX signals asynchronously. It can be seen as an asynchronous version of signal_hook::iterator::Signals.

Implementation

This crate uses the signal_hook_registry crate to register a listener for each signal. That listener will then send a message through a Unix socket to the Signals type, which will receive it and notify the user. Asynchronous notification is done through the async-io crate.

Note that the internal pipe has a limited capacity. Once it has reached capacity, additional signals will be dropped.

On Windows, a different implementation that only supports SIGINT is used. This implementation uses a channel to notify the user.

Examples

use async_signal::{Signal, Signals};
use futures_lite::prelude::*;
use signal_hook::low_level;

// Register the signals we want to receive.
let mut signals = Signals::new(&[
    Signal::Term,
    Signal::Quit,
    Signal::Int,
])?;

// Wait for a signal to be received.
while let Some(signal) = signals.next().await {
    // Print the signal.
    eprintln!("Received signal {:?}", signal);

    // After printing it, do whatever the signal was supposed to do in the first place.
    low_level::emulate_default_handler(signal.unwrap() as i32).unwrap();
}

Structs

  • Wait for a specific set of signals.

Enums

  • The signal types that we are able to listen for.