use std::time::Duration;
use super::{CancelKind, flush_stdio};
use crate::error::EXIT_INTERRUPTED;
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 second = sigint.recv();
tokio::pin!(second);
match tokio::time::timeout(
Duration::from_secs(DOUBLE_INTERRUPT_FORCE_SECS),
&mut second,
)
.await
{
Ok(Some(())) => {
let _ = writeln_force_hint();
flush_stdio();
std::process::exit(i32::from(EXIT_INTERRUPTED));
}
Ok(None) => {
}
Err(_) => {
}
}
}
#[cfg(not(unix))]
{
portable_double_interrupt().await;
}
})
}
#[cfg_attr(unix, allow(dead_code))]
async fn portable_double_interrupt() {
let _ = tokio::signal::ctrl_c().await;
if let Ok(Ok(())) = tokio::time::timeout(
Duration::from_secs(DOUBLE_INTERRUPT_FORCE_SECS),
tokio::signal::ctrl_c(),
)
.await
{
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()
}