use std::future::Future;
use tokio::task::AbortHandle;
pub fn spawn_supervised<F>(name: impl Into<String>, fut: F) -> AbortHandle
where
F: Future<Output = ()> + Send + 'static,
{
let name = name.into();
let handle = tokio::spawn(fut);
let abort_handle = handle.abort_handle();
tokio::spawn(async move {
match handle.await {
Ok(()) => {}
Err(join_error) if join_error.is_cancelled() => {}
Err(join_error) => {
tracing::error!(
task = %name,
error = %join_error,
"background task panicked"
);
}
}
});
abort_handle
}
#[cfg(test)]
mod tests {
use std::sync::{
Arc,
atomic::{
AtomicBool,
Ordering,
},
};
use super::*;
#[tokio::test]
async fn spawn_supervised_returns_working_abort_handle() {
let started = Arc::new(AtomicBool::new(false));
let started_task = Arc::clone(&started);
let abort_handle = spawn_supervised("test", async move {
started_task.store(true, Ordering::SeqCst);
std::future::pending::<()>().await;
});
tokio::task::yield_now().await;
assert!(started.load(Ordering::SeqCst), "task must actually run");
abort_handle.abort();
tokio::task::yield_now().await;
assert!(abort_handle.is_finished(), "aborted task must stop");
}
#[tokio::test]
async fn spawn_supervised_survives_a_panicking_task() {
let abort_handle = spawn_supervised("test", async {
panic!("simulated task panic");
});
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
assert!(
abort_handle.is_finished(),
"the panicked task must be observably finished, not stuck"
);
tokio::task::yield_now().await;
}
}