use std::future::Future;
use std::sync::OnceLock;
use tokio::task::JoinHandle;
use tokio_util::sync::CancellationToken;
use tracing::{Instrument, Span};
fn global_monitor_shutdown_token() -> &'static CancellationToken {
static TOKEN: OnceLock<CancellationToken> = OnceLock::new();
TOKEN.get_or_init(CancellationToken::new)
}
pub fn shutdown_background_monitors() {
global_monitor_shutdown_token().cancel();
}
pub(crate) fn spawn_background_monitor<F>(span: Span, task: F) -> JoinHandle<()>
where
F: Future<Output = ()> + Send + 'static,
{
spawn_background_monitor_on(global_monitor_shutdown_token().clone(), span, task)
}
fn spawn_background_monitor_on<F>(shutdown: CancellationToken, span: Span, task: F) -> JoinHandle<()>
where
F: Future<Output = ()> + Send + 'static,
{
tokio::spawn(
async move {
tokio::select! {
_ = shutdown.cancelled() => {}
_ = task => {}
}
}
.instrument(span),
)
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
#[tokio::test]
async fn spawn_background_monitor_on_stops_when_token_cancelled() {
let shutdown = CancellationToken::new();
let ran_to_completion = Arc::new(AtomicBool::new(false));
let flag = Arc::clone(&ran_to_completion);
let handle = spawn_background_monitor_on(shutdown.clone(), Span::none(), async move {
std::future::pending::<()>().await;
flag.store(true, Ordering::SeqCst);
});
shutdown.cancel();
tokio::time::timeout(Duration::from_secs(5), handle)
.await
.expect("monitor task should stop after shutdown")
.expect("monitor task should not panic");
assert!(!ran_to_completion.load(Ordering::SeqCst), "inner future must be cancelled, not completed");
}
#[tokio::test]
async fn spawn_background_monitor_on_completes_when_task_finishes() {
let shutdown = CancellationToken::new();
let handle = spawn_background_monitor_on(shutdown, Span::none(), async {});
tokio::time::timeout(Duration::from_secs(5), handle)
.await
.expect("finished monitor task should join")
.expect("monitor task should not panic");
}
}