use std::sync::Arc;
use tokio::time::Duration;
use tokio_util::sync::CancellationToken;
const SHUTDOWN_TIMEOUT_SECS: u64 = 2;
pub async fn shutdown_gracefully(
cancel: CancellationToken,
logging_task: Option<tokio::task::JoinHandle<()>>,
rate_limiter_shutdown: Option<CancellationToken>,
status_server: Option<crate::status_server::StatusServerHandle>,
) {
cancel.cancel();
if let Some(logging_task) = logging_task {
let task_handle = Arc::new(tokio::sync::Mutex::new(Some(logging_task)));
let timeout_future = tokio::time::sleep(Duration::from_secs(SHUTDOWN_TIMEOUT_SECS));
tokio::pin!(timeout_future);
tokio::select! {
result = async {
let task = {
let mut handle_guard = task_handle.lock().await;
handle_guard.take()
};
if let Some(task) = task {
task.await
} else {
Ok(())
}
} => {
match result {
Ok(()) => {
}
Err(e) => {
log::debug!("Logging task completed with error: {e:?}");
}
}
}
() = timeout_future.as_mut() => {
log::debug!(
"Logging task did not complete within {SHUTDOWN_TIMEOUT_SECS} seconds, aborting"
);
let task = {
let mut handle_guard = task_handle.lock().await;
handle_guard.take()
};
if let Some(task) = task {
task.abort();
let _ = task.await;
}
}
}
}
if let Some(shutdown) = rate_limiter_shutdown {
shutdown.cancel();
}
if let Some(status_server) = status_server {
if let Err(error) = status_server.shutdown().await {
log::debug!("Status server completed with error during shutdown: {error}");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use tokio::time::Duration;
#[tokio::test]
async fn test_shutdown_gracefully_no_tasks() {
let cancel = CancellationToken::new();
shutdown_gracefully(cancel, None, None, None).await;
}
#[tokio::test]
async fn test_shutdown_gracefully_with_logging_task() {
let cancel = CancellationToken::new();
let cancel_clone = cancel.clone();
let logging_task = tokio::spawn(async move {
let mut interval = tokio::time::interval(Duration::from_millis(10));
loop {
tokio::select! {
_ = interval.tick() => {
}
_ = cancel_clone.cancelled() => {
break;
}
}
}
});
shutdown_gracefully(cancel, Some(logging_task), None, None).await;
}
#[tokio::test]
async fn test_shutdown_gracefully_with_stuck_task() {
let cancel = CancellationToken::new();
let logging_task = tokio::spawn(async move {
loop {
tokio::time::sleep(Duration::from_millis(100)).await;
}
});
shutdown_gracefully(cancel, Some(logging_task), None, None).await;
}
#[tokio::test]
async fn test_shutdown_gracefully_with_rate_limiter() {
let cancel = CancellationToken::new();
let rate_limiter_shutdown = CancellationToken::new();
shutdown_gracefully(cancel, None, Some(rate_limiter_shutdown.clone()), None).await;
assert!(rate_limiter_shutdown.is_cancelled());
}
#[tokio::test]
async fn test_shutdown_gracefully_with_all_tasks() {
let cancel = CancellationToken::new();
let cancel_clone = cancel.clone();
let rate_limiter_shutdown = CancellationToken::new();
let logging_task = tokio::spawn(async move {
let mut interval = tokio::time::interval(Duration::from_millis(10));
loop {
tokio::select! {
_ = interval.tick() => {}
_ = cancel_clone.cancelled() => {
break;
}
}
}
});
shutdown_gracefully(
cancel,
Some(logging_task),
Some(rate_limiter_shutdown.clone()),
None,
)
.await;
assert!(rate_limiter_shutdown.is_cancelled());
}
}