#[derive(Debug)]
pub struct Signals {
interrupt: Option<tokio::signal::unix::Signal>,
terminate: Option<tokio::signal::unix::Signal>,
}
impl Signals {
#[must_use]
pub fn install() -> Self {
use tokio::signal::unix::{SignalKind, signal};
Self {
interrupt: signal(SignalKind::interrupt()).ok(),
terminate: signal(SignalKind::terminate()).ok(),
}
}
#[must_use]
pub const fn is_armed(&self) -> bool {
self.interrupt.is_some() || self.terminate.is_some()
}
pub async fn next(&mut self) {
match (self.interrupt.as_mut(), self.terminate.as_mut()) {
(Some(interrupt), Some(terminate)) => {
tokio::select! {
_ = interrupt.recv() => {}
_ = terminate.recv() => {}
}
}
(Some(one), None) | (None, Some(one)) => {
let _ = one.recv().await;
}
(None, None) => std::future::pending().await,
}
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use std::time::Duration;
#[tokio::test]
async fn installing_twice_is_harmless_and_both_handlers_arm() {
let first = Signals::install();
let second = Signals::install();
assert!(first.is_armed());
assert!(second.is_armed());
}
#[tokio::test]
async fn a_real_signal_resolves_the_wait() {
let mut signals = Signals::install();
let pid = rustix::process::Pid::from_raw(std::process::id().cast_signed())
.expect("this process has a pid");
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(20)).await;
let _ = rustix::process::kill_process(pid, rustix::process::Signal::INT);
});
tokio::time::timeout(Duration::from_secs(5), signals.next())
.await
.expect("the handler must observe SIGINT");
}
#[tokio::test]
async fn a_wait_with_no_handlers_never_resolves() {
let mut signals = Signals {
interrupt: None,
terminate: None,
};
assert!(!signals.is_armed());
let timed_out = tokio::time::timeout(Duration::from_millis(30), signals.next())
.await
.is_err();
assert!(timed_out, "an unarmed wait must never resolve");
}
}