use std::{
cell::RefCell,
panic::{self, AssertUnwindSafe},
sync::{
Arc, Condvar, Mutex, PoisonError,
atomic::{AtomicBool, Ordering},
mpsc,
},
};
#[derive(Clone, Debug, Default)]
pub struct StopSignal(Arc<Inner>);
#[derive(Debug, Default)]
struct Inner {
stopped: AtomicBool,
waiting: Mutex<()>,
woken: Condvar,
}
impl StopSignal {
pub fn new() -> Self {
Self::default()
}
pub fn stop(&self) {
self.0.stopped.store(true, Ordering::SeqCst);
let _held = self.lock();
self.0.woken.notify_all();
}
pub fn is_stopped(&self) -> bool {
self.0.stopped.load(Ordering::SeqCst)
}
fn lock(&self) -> std::sync::MutexGuard<'_, ()> {
self.0
.waiting
.lock()
.unwrap_or_else(PoisonError::into_inner)
}
}
thread_local! {
static SIGNAL: RefCell<Option<StopSignal>> = const { RefCell::new(None) };
}
pub fn with_stop_signal<T>(signal: StopSignal, operation: impl FnOnce() -> T) -> T {
struct Restore(Option<StopSignal>);
impl Drop for Restore {
fn drop(&mut self) {
let previous = self.0.take();
SIGNAL.with(|current| *current.borrow_mut() = previous);
}
}
let _restore = Restore(SIGNAL.with(|current| current.replace(Some(signal))));
operation()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Stopped;
fn current() -> Option<StopSignal> {
SIGNAL.with(|current| current.borrow().clone())
}
pub(crate) fn scoped() -> bool {
SIGNAL.with(|current| current.borrow().is_some())
}
pub(crate) fn requested() -> bool {
SIGNAL.with(|current| {
current
.borrow()
.as_ref()
.is_some_and(StopSignal::is_stopped)
})
}
pub(crate) fn check() -> Result<(), Stopped> {
if requested() { Err(Stopped) } else { Ok(()) }
}
pub(crate) fn with_interrupt<T>(operation: impl FnOnce(&AtomicBool) -> T) -> T {
match current() {
Some(signal) => operation(&signal.0.stopped),
None => operation(&AtomicBool::new(false)),
}
}
pub(crate) fn run<T: Send + 'static>(
work: impl FnOnce(&AtomicBool) -> T + Send + 'static,
) -> Result<T, Stopped> {
let Some(signal) = current() else {
return Ok(work(&AtomicBool::new(false)));
};
if signal.is_stopped() {
return Err(Stopped);
}
let resolver = crate::source::current_resolver();
let (sender, receiver) = mpsc::sync_channel(1);
let worker = signal.clone();
std::thread::Builder::new()
.name("toha-remote".into())
.spawn(move || {
let scoped = || {
with_stop_signal(worker.clone(), || {
panic::catch_unwind(AssertUnwindSafe(|| work(&worker.0.stopped)))
})
};
let outcome = match resolver {
Some(resolver) => crate::source::with_credential_resolver(resolver, scoped),
None => scoped(),
};
let _ = sender.send(outcome);
drop(worker.lock());
worker.0.woken.notify_all();
})
.expect("failed to spawn a Toha remote thread");
let mut held = signal.lock();
loop {
if signal.is_stopped() {
return Err(Stopped);
}
match receiver.try_recv() {
Ok(Ok(value)) => return Ok(value),
Ok(Err(payload)) => {
drop(held);
panic::resume_unwind(payload)
}
Err(mpsc::TryRecvError::Empty) => {}
Err(mpsc::TryRecvError::Disconnected) => {
unreachable!("the remote thread sends before it ends")
}
}
held = signal
.0
.woken
.wait(held)
.unwrap_or_else(PoisonError::into_inner);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::time::{Duration, Instant};
#[test]
fn without_a_signal_work_runs_on_the_calling_thread() {
let caller = std::thread::current().id();
let ran = run(move |interrupt| {
assert!(!interrupt.load(Ordering::SeqCst));
std::thread::current().id()
});
assert_eq!(ran, Ok(caller));
assert!(!requested());
assert_eq!(check(), Ok(()));
}
#[test]
fn a_signal_is_scoped_to_its_operation_and_thread() {
let signal = StopSignal::new();
signal.stop();
let inner = StopSignal::new();
with_stop_signal(signal.clone(), || {
assert!(requested());
assert_eq!(check(), Err(Stopped));
with_stop_signal(inner.clone(), || assert!(!requested()));
assert!(requested());
assert!(!std::thread::spawn(requested).join().unwrap());
});
assert!(!requested());
}
#[test]
fn work_runs_with_the_signal_on_another_thread() {
let signal = StopSignal::new();
let caller = std::thread::current().id();
let observed = with_stop_signal(signal.clone(), || {
run(move |interrupt| {
(
std::thread::current().id(),
requested(),
interrupt.load(Ordering::SeqCst),
current().is_some(),
)
})
});
let (thread, stopped, interrupted, scoped) = observed.unwrap();
assert_ne!(thread, caller);
assert!(!stopped && !interrupted && scoped);
}
#[test]
fn a_stop_ends_the_wait_for_blocked_work() {
let signal = StopSignal::new();
let (release, held) = mpsc::channel::<()>();
let (ended, finished) = mpsc::channel();
let stopper = signal.clone();
std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(100));
stopper.stop();
});
let started = Instant::now();
let result = with_stop_signal(signal, || {
run(move |interrupt| {
held.recv().ok();
ended.send(interrupt.load(Ordering::SeqCst)).unwrap();
})
});
assert_eq!(result, Err(Stopped));
assert!(started.elapsed() < Duration::from_secs(5));
release.send(()).unwrap();
assert_eq!(
finished.recv_timeout(Duration::from_secs(5)),
Ok(true),
"the work sees the interrupt flag once it is unblocked"
);
}
#[test]
fn a_stopped_signal_starts_no_work() {
let signal = StopSignal::new();
signal.stop();
let result = with_stop_signal(signal, || run(|_| panic!("work started")));
assert_eq!(result, Err(Stopped));
}
#[test]
fn a_panic_in_the_work_resumes_on_the_caller() {
let result = panic::catch_unwind(|| {
with_stop_signal(StopSignal::new(), || run(|_| panic!("from the work")))
});
let payload = result.unwrap_err();
assert_eq!(payload.downcast_ref::<&str>(), Some(&"from the work"));
}
}