use std::sync::Arc;
use tokio_util::sync::CancellationToken;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StopReason {
Interrupt,
Terminate,
}
impl StopReason {
#[must_use]
pub const fn exit_number(self) -> crate::error::ExitNumber {
match self {
Self::Interrupt | Self::Terminate => crate::error::ExitNumber::Interrupted,
}
}
}
#[derive(Debug, Clone)]
pub struct Shutdown {
token: CancellationToken,
reason: Arc<std::sync::OnceLock<StopReason>>,
}
impl Default for Shutdown {
fn default() -> Self {
Self::new()
}
}
impl Shutdown {
#[must_use]
pub fn new() -> Self {
Self {
token: CancellationToken::new(),
reason: Arc::new(std::sync::OnceLock::new()),
}
}
#[must_use]
pub fn token(&self) -> CancellationToken {
self.token.clone()
}
#[must_use]
pub fn is_stopping(&self) -> bool {
self.token.is_cancelled()
}
#[must_use]
pub fn reason(&self) -> Option<StopReason> {
self.reason.get().copied()
}
pub fn stop(&self, reason: StopReason) {
let _ = self.reason.set(reason);
self.token.cancel();
}
#[must_use]
pub fn watch_signals(&self) -> tokio::task::JoinHandle<()> {
let shutdown = self.clone();
tokio::spawn(async move {
let token = shutdown.token();
tokio::select! {
() = token.cancelled() => {}
reason = next_signal() => shutdown.stop(reason),
}
})
}
}
#[cfg(unix)]
async fn next_signal() -> StopReason {
use tokio::signal::unix::{signal, SignalKind};
let Ok(mut interrupt) = signal(SignalKind::interrupt()) else {
return std::future::pending().await;
};
let Ok(mut terminate) = signal(SignalKind::terminate()) else {
return std::future::pending().await;
};
tokio::select! {
_ = interrupt.recv() => StopReason::Interrupt,
_ = terminate.recv() => StopReason::Terminate,
}
}
#[cfg(windows)]
async fn next_signal() -> StopReason {
use tokio::signal::windows;
let mut ctrl_c = match windows::ctrl_c() {
Ok(stream) => stream,
Err(_) => return std::future::pending().await,
};
let mut ctrl_close = match windows::ctrl_close() {
Ok(stream) => stream,
Err(_) => return std::future::pending().await,
};
tokio::select! {
_ = ctrl_c.recv() => StopReason::Interrupt,
_ = ctrl_close.recv() => StopReason::Terminate,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_fresh_signal_has_not_fired() {
let shutdown = Shutdown::new();
assert!(!shutdown.is_stopping());
assert_eq!(shutdown.reason(), None);
}
#[test]
fn the_first_reason_wins() {
let shutdown = Shutdown::new();
shutdown.stop(StopReason::Interrupt);
shutdown.stop(StopReason::Terminate);
assert_eq!(shutdown.reason(), Some(StopReason::Interrupt));
assert!(shutdown.is_stopping());
}
#[test]
fn stopping_reaches_every_clone() {
let shutdown = Shutdown::new();
let watcher = shutdown.clone();
shutdown.stop(StopReason::Terminate);
assert!(watcher.is_stopping());
assert!(watcher.token().is_cancelled());
}
}