mod signals;
#[cfg(test)]
mod tests;
pub use signals::{
DOUBLE_INTERRUPT_FORCE_SECS, spawn_double_interrupt_force_exit, wait_for_cancel,
};
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::sync::atomic::{AtomicU8, Ordering};
use std::task::{Context, Poll};
use std::time::Duration;
use tokio::time::{Instant, timeout};
use crate::error::{AppError, AppResult, ErrorDetail};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CancelKind {
Interrupt,
Terminate,
}
const FLAG_NONE: u8 = 0;
const FLAG_INTERRUPT: u8 = 1;
const FLAG_TERMINATE: u8 = 2;
#[derive(Debug, Clone, Default)]
pub struct CancelFlag {
state: Arc<AtomicU8>,
}
impl CancelFlag {
pub fn new() -> Self {
Self {
state: Arc::new(AtomicU8::new(FLAG_NONE)),
}
}
pub fn cancel(&self) {
self.cancel_with(CancelKind::Terminate);
}
pub fn cancel_with(&self, kind: CancelKind) {
let v = match kind {
CancelKind::Interrupt => FLAG_INTERRUPT,
CancelKind::Terminate => FLAG_TERMINATE,
};
let _ = self
.state
.compare_exchange(FLAG_NONE, v, Ordering::SeqCst, Ordering::SeqCst);
}
pub fn is_cancelled(&self) -> bool {
self.state.load(Ordering::SeqCst) != FLAG_NONE
}
pub fn kind(&self) -> Option<CancelKind> {
match self.state.load(Ordering::SeqCst) {
FLAG_INTERRUPT => Some(CancelKind::Interrupt),
FLAG_TERMINATE => Some(CancelKind::Terminate),
_ => None,
}
}
pub fn check(&self) -> AppResult<()> {
match self.kind() {
None => Ok(()),
Some(CancelKind::Interrupt) => Err(AppError::interrupted()),
Some(CancelKind::Terminate) => Err(AppError::terminated()),
}
}
}
pub async fn with_wall_clock<T, F, Fut>(deadline: Duration, fut: F) -> AppResult<T>
where
F: FnOnce() -> Fut,
Fut: Future<Output = AppResult<T>>,
{
match timeout(deadline, fut()).await {
Ok(inner) => inner,
Err(_) => Err(AppError::of(ErrorDetail::WallClockTimeout {
secs: deadline.as_secs(),
})),
}
}
pub async fn race_op_with_cancel_and_deadline<T, Fut>(
deadline: Duration,
cancel_flag: CancelFlag,
op: Fut,
) -> AppResult<T>
where
Fut: Future<Output = AppResult<T>>,
{
tokio::pin!(op);
let cancel = wait_for_cancel();
tokio::pin!(cancel);
let timed = timeout(deadline, async {
tokio::select! {
biased;
kind = &mut cancel => {
cancel_flag.cancel_with(kind);
match kind {
CancelKind::Interrupt => Err(AppError::interrupted()),
CancelKind::Terminate => Err(AppError::terminated()),
}
}
res = &mut op => res,
}
});
match timed.await {
Ok(inner) => inner,
Err(_) => {
cancel_flag.cancel_with(CancelKind::Terminate);
Err(AppError::of(ErrorDetail::WallClockTimeout {
secs: deadline.as_secs(),
}))
}
}
}
pub fn duration_ms(start: Instant) -> u64 {
start.elapsed().as_millis() as u64
}
pub fn flush_stdio() {
use std::io::Write;
let _ = std::io::stdout().flush();
let _ = std::io::stderr().flush();
}
pub struct ProgressGuard {
done: Arc<std::sync::atomic::AtomicBool>,
handle: Option<tokio::task::JoinHandle<()>>,
}
impl ProgressGuard {
pub fn start(quiet: bool, delay: Duration, message: String) -> Self {
let done = Arc::new(std::sync::atomic::AtomicBool::new(false));
if quiet {
return Self { done, handle: None };
}
let flag = Arc::clone(&done);
let handle = tokio::spawn(async move {
tokio::time::sleep(delay).await;
if !flag.load(Ordering::SeqCst) {
use std::io::Write;
let _ = writeln!(std::io::stderr(), "{message}");
let _ = std::io::stderr().flush();
}
});
Self {
done,
handle: Some(handle),
}
}
pub fn finish(mut self) {
self.shutdown();
}
fn shutdown(&mut self) {
self.done.store(true, Ordering::SeqCst);
if let Some(h) = self.handle.take() {
h.abort();
}
}
}
impl Drop for ProgressGuard {
fn drop(&mut self) {
self.shutdown();
}
}
pub struct CancelPoll<'a> {
flag: &'a CancelFlag,
}
impl Future for CancelPoll<'_> {
type Output = AppResult<()>;
fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
Poll::Ready(self.flag.check())
}
}