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, EXIT_INTERRUPTED, ErrorKind};
#[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::new(
ErrorKind::Timeout,
format!("wall-clock timeout after {}s", 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::new(
ErrorKind::Timeout,
format!("wall-clock timeout after {}s", 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 async fn wait_for_cancel() -> CancelKind {
#[cfg(unix)]
{
use tokio::signal::unix::{SignalKind, signal};
let mut sigint = match signal(SignalKind::interrupt()) {
Ok(s) => s,
Err(_) => {
let _ = tokio::signal::ctrl_c().await;
return CancelKind::Interrupt;
}
};
let mut sigterm = match signal(SignalKind::terminate()) {
Ok(s) => s,
Err(_) => {
let _ = tokio::signal::ctrl_c().await;
return CancelKind::Interrupt;
}
};
let mut sighup = match signal(SignalKind::hangup()) {
Ok(s) => s,
Err(_) => {
tokio::select! {
_ = sigint.recv() => return CancelKind::Interrupt,
_ = sigterm.recv() => return CancelKind::Terminate,
}
}
};
tokio::select! {
_ = sigint.recv() => CancelKind::Interrupt,
_ = sigterm.recv() => CancelKind::Terminate,
_ = sighup.recv() => CancelKind::Terminate,
}
}
#[cfg(windows)]
{
use tokio::signal::windows::{ctrl_break, ctrl_c, ctrl_close};
let mut c_c = match ctrl_c() {
Ok(s) => s,
Err(_) => {
let _ = tokio::signal::ctrl_c().await;
return CancelKind::Interrupt;
}
};
let mut c_break = match ctrl_break() {
Ok(s) => s,
Err(_) => {
let _ = c_c.recv().await;
return CancelKind::Interrupt;
}
};
let mut c_close = match ctrl_close() {
Ok(s) => s,
Err(_) => {
tokio::select! {
_ = c_c.recv() => return CancelKind::Interrupt,
_ = c_break.recv() => return CancelKind::Terminate,
}
}
};
tokio::select! {
_ = c_c.recv() => CancelKind::Interrupt,
_ = c_break.recv() => CancelKind::Terminate,
_ = c_close.recv() => CancelKind::Terminate,
}
}
#[cfg(not(any(unix, windows)))]
{
let _ = tokio::signal::ctrl_c().await;
CancelKind::Interrupt
}
}
pub const DOUBLE_INTERRUPT_FORCE_SECS: u64 = 5;
pub fn spawn_double_interrupt_force_exit() -> tokio::task::JoinHandle<()> {
tokio::spawn(async move {
#[cfg(unix)]
{
use tokio::signal::unix::{SignalKind, signal};
let mut sigint = match signal(SignalKind::interrupt()) {
Ok(s) => s,
Err(_) => return,
};
let _ = sigint.recv().await;
let first = Instant::now();
let second = sigint.recv();
tokio::pin!(second);
match tokio::time::timeout(
Duration::from_secs(DOUBLE_INTERRUPT_FORCE_SECS),
&mut second,
)
.await
{
Ok(Some(())) => {
let _ = first;
let _ = writeln_force_hint();
flush_stdio();
std::process::exit(i32::from(EXIT_INTERRUPTED));
}
Ok(None) => {
}
Err(_) => {
}
}
}
#[cfg(not(unix))]
{
let _ = tokio::signal::ctrl_c().await;
let first = Instant::now();
match tokio::time::timeout(
Duration::from_secs(DOUBLE_INTERRUPT_FORCE_SECS),
tokio::signal::ctrl_c(),
)
.await
{
Ok(Ok(())) => {
if first.elapsed() <= Duration::from_secs(DOUBLE_INTERRUPT_FORCE_SECS) {
let _ = writeln_force_hint();
flush_stdio();
std::process::exit(i32::from(EXIT_INTERRUPTED));
}
}
_ => {}
}
}
})
}
fn writeln_force_hint() -> std::io::Result<()> {
use std::io::Write;
let mut err = std::io::stderr();
writeln!(
err,
"docsrs-cli: second interrupt within {DOUBLE_INTERRUPT_FORCE_SECS}s; forcing exit {EXIT_INTERRUPTED}"
)?;
err.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())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn wall_clock_timeout() {
let err = with_wall_clock(Duration::from_millis(20), || async {
tokio::time::sleep(Duration::from_millis(200)).await;
Ok::<(), AppError>(())
})
.await
.unwrap_err();
assert_eq!(err.kind(), ErrorKind::Timeout);
}
#[tokio::test]
async fn cancel_flag_check_defaults_to_terminated() {
let f = CancelFlag::new();
assert!(f.check().is_ok());
f.cancel();
assert_eq!(f.check().unwrap_err().kind(), ErrorKind::Terminated);
assert_eq!(f.kind(), Some(CancelKind::Terminate));
}
#[tokio::test]
async fn cancel_flag_preserves_interrupt_kind() {
let f = CancelFlag::new();
f.cancel_with(CancelKind::Interrupt);
assert_eq!(f.check().unwrap_err().kind(), ErrorKind::Interrupted);
f.cancel_with(CancelKind::Terminate);
assert_eq!(f.check().unwrap_err().kind(), ErrorKind::Interrupted);
}
#[test]
fn duration_ms_non_zero_after_sleep() {
let start = Instant::now();
std::thread::sleep(Duration::from_millis(5));
assert!(duration_ms(start) >= 1);
}
#[tokio::test]
async fn race_deadline_wins() {
let flag = CancelFlag::new();
let err = race_op_with_cancel_and_deadline(Duration::from_millis(15), flag, async {
tokio::time::sleep(Duration::from_millis(200)).await;
Ok::<(), AppError>(())
})
.await
.unwrap_err();
assert_eq!(err.kind(), ErrorKind::Timeout);
}
#[tokio::test]
async fn progress_guard_quiet_is_noop() {
let g = ProgressGuard::start(true, Duration::from_millis(1), "x".into());
g.finish();
}
#[tokio::test]
async fn progress_guard_drop_aborts_without_finish() {
let g = ProgressGuard::start(false, Duration::from_secs(60), "must-not-print".into());
drop(g);
}
#[test]
fn flush_stdio_does_not_panic() {
flush_stdio();
}
#[test]
fn double_interrupt_window_is_five_seconds() {
assert_eq!(DOUBLE_INTERRUPT_FORCE_SECS, 5);
}
#[tokio::test]
async fn spawn_double_interrupt_handle_aborts_cleanly() {
let h = spawn_double_interrupt_force_exit();
h.abort();
let _ = h.await;
}
}