Struct tokio::signal::unix::Signal [−][src]
A stream of events for receiving a particular type of OS signal.
In general signal handling on Unix is a pretty tricky topic, and this
structure is no exception! There are some important limitations to keep in
mind when using Signal
streams:
-
Signals handling in Unix already necessitates coalescing signals together sometimes. This
Signal
stream is also no exception here in that it will also coalesce signals. That is, even if the signal handler for this process runs multiple times, theSignal
stream may only return one signal notification. Specifically, beforepoll
is called, all signal notifications are coalesced into one item returned frompoll
. Oncepoll
has been called, however, a further signal is guaranteed to be yielded as an item.Put another way, any element pulled off the returned stream corresponds to at least one signal, but possibly more.
-
Signal handling in general is relatively inefficient. Although some improvements are possible in this crate, it’s recommended to not plan on having millions of signal channels open.
If you’ve got any questions about this feel free to open an issue on the repo! New approaches to alleviate some of these limitations are always appreciated!
Caveats
The first time that a Signal
instance is registered for a particular
signal kind, an OS signal-handler is installed which replaces the default
platform behavior when that signal is received, for the duration of the
entire process.
For example, Unix systems will terminate a process by default when it
receives SIGINT. But, when a Signal
instance is created to listen for
this signal, the next SIGINT that arrives will be translated to a stream
event, and the process will continue to execute. Even if this Signal
instance is dropped, subsequent SIGINT deliveries will end up captured by
Tokio, and the default platform behavior will NOT be reset.
Thus, applications should take care to ensure the expected signal behavior occurs as expected after listening for specific signals.
Examples
Wait for SIGHUP
use tokio::signal::unix::{signal, SignalKind}; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { // An infinite stream of hangup signals. let mut stream = signal(SignalKind::hangup())?; // Print whenever a HUP signal is received loop { stream.recv().await; println!("got signal HUP"); } }
Implementations
impl Signal
[src]
pub async fn recv(&mut self) -> Option<()>
[src]
Receives the next signal notification event.
None
is returned if no more events can be received by this stream.
Examples
Wait for SIGHUP
use tokio::signal::unix::{signal, SignalKind}; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { // An infinite stream of hangup signals. let mut stream = signal(SignalKind::hangup())?; // Print whenever a HUP signal is received loop { stream.recv().await; println!("got signal HUP"); } }
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Signal
impl Send for Signal
impl Sync for Signal
impl Unpin for Signal
impl !UnwindSafe for Signal
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<St> StreamExt for St where
St: Stream + ?Sized,
[src]
St: Stream + ?Sized,
fn next(&mut self) -> Next<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
fn try_next<T, E>(&mut self) -> TryNext<'_, Self> where
Self: Stream<Item = Result<T, E>> + Unpin,
[src]
Self: Stream<Item = Result<T, E>> + Unpin,
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
Self: Sized,
[src]
F: FnMut(Self::Item) -> T,
Self: Sized,
fn merge<U>(self, other: U) -> Merge<Self, U> where
U: Stream<Item = Self::Item>,
Self: Sized,
[src]
U: Stream<Item = Self::Item>,
Self: Sized,
fn filter<F>(self, f: F) -> Filter<Self, F> where
F: FnMut(&Self::Item) -> bool,
Self: Sized,
[src]
F: FnMut(&Self::Item) -> bool,
Self: Sized,
fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<T>,
Self: Sized,
[src]
F: FnMut(Self::Item) -> Option<T>,
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self: Sized,
[src]
Self: Sized,
fn take(self, n: usize) -> Take<Self> where
Self: Sized,
[src]
Self: Sized,
fn take_while<F>(self, f: F) -> TakeWhile<Self, F> where
F: FnMut(&Self::Item) -> bool,
Self: Sized,
[src]
F: FnMut(&Self::Item) -> bool,
Self: Sized,
fn skip(self, n: usize) -> Skip<Self> where
Self: Sized,
[src]
Self: Sized,
fn skip_while<F>(self, f: F) -> SkipWhile<Self, F> where
F: FnMut(&Self::Item) -> bool,
Self: Sized,
[src]
F: FnMut(&Self::Item) -> bool,
Self: Sized,
fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> bool,
[src]
Self: Unpin,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> bool,
[src]
Self: Unpin,
F: FnMut(Self::Item) -> bool,
fn chain<U>(self, other: U) -> Chain<Self, U> where
U: Stream<Item = Self::Item>,
Self: Sized,
[src]
U: Stream<Item = Self::Item>,
Self: Sized,
fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F> where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn collect<T>(self) -> Collect<Self, T> where
T: FromStream<Self::Item>,
Self: Sized,
[src]
T: FromStream<Self::Item>,
Self: Sized,
fn timeout(self, duration: Duration) -> Timeout<Self> where
Self: Sized,
[src]
Self: Sized,
fn throttle(self, duration: Duration) -> Throttle<Self> where
Self: Sized,
[src]
Self: Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,