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].
On unix, 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.
```rust use asyncsignal::{Signal, Signals}; use futureslite::prelude::*; use signalhook::lowlevel;
// Register the signals we want to receive. let 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();
} ```
Licensed under either of
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.