use std::cell::RefCell;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, Weak};
pub(crate) const CANCELLED_SENTINEL: &str = "__isle_cancelled__";
#[derive(Clone)]
pub struct CancelToken {
inner: Arc<Inner>,
}
struct Inner {
flag: AtomicBool,
#[cfg(feature = "tokio")]
notify: tokio::sync::Notify,
_parent: Option<Arc<Inner>>,
children: Mutex<Children>,
}
#[derive(Default)]
struct Children {
list: Vec<Weak<Inner>>,
sweep_at: usize,
}
impl Inner {
fn new(parent: Option<Arc<Inner>>) -> Self {
Self {
flag: AtomicBool::new(false),
#[cfg(feature = "tokio")]
notify: tokio::sync::Notify::new(),
_parent: parent,
children: Mutex::new(Children::default()),
}
}
fn cancel(&self) {
if self.flag.swap(true, Ordering::AcqRel) {
return;
}
#[cfg(feature = "tokio")]
self.notify.notify_waiters();
let children = std::mem::take(&mut lock(&self.children).list);
for child in children.iter().filter_map(Weak::upgrade) {
child.cancel();
}
}
}
fn lock(m: &Mutex<Children>) -> std::sync::MutexGuard<'_, Children> {
m.lock().unwrap_or_else(|e| e.into_inner())
}
impl CancelToken {
pub fn new() -> Self {
Self {
inner: Arc::new(Inner::new(None)),
}
}
pub fn child_token(&self) -> CancelToken {
let child = Arc::new(Inner::new(Some(self.inner.clone())));
let mut children = lock(&self.inner.children);
if self.is_cancelled() {
drop(children);
child.cancel();
} else {
if children.list.len() >= children.sweep_at {
children.list.retain(|w| w.strong_count() > 0);
children.sweep_at = (children.list.len() * 2).max(16);
}
children.list.push(Arc::downgrade(&child));
}
CancelToken { inner: child }
}
pub fn cancel(&self) {
self.inner.cancel();
}
pub fn is_cancelled(&self) -> bool {
self.inner.flag.load(Ordering::Acquire)
}
#[cfg(feature = "tokio")]
pub async fn cancelled(&self) {
if self.is_cancelled() {
return;
}
let notified = self.inner.notify.notified();
tokio::pin!(notified);
notified.as_mut().enable();
if self.is_cancelled() {
return;
}
notified.await;
}
#[cfg(test)]
fn live_children(&self) -> usize {
lock(&self.inner.children)
.list
.iter()
.filter(|w| w.strong_count() > 0)
.count()
}
#[cfg(test)]
fn stored_children(&self) -> usize {
lock(&self.inner.children).list.len()
}
}
impl Default for CancelToken {
fn default() -> Self {
Self::new()
}
}
impl std::fmt::Debug for CancelToken {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CancelToken")
.field("cancelled", &self.is_cancelled())
.finish()
}
}
thread_local! {
static CURRENT: RefCell<Option<CancelToken>> = const { RefCell::new(None) };
}
pub fn current_token() -> Option<CancelToken> {
CURRENT.with(|c| c.borrow().clone())
}
pub(crate) fn current_is_cancelled() -> bool {
CURRENT.with(|c| c.borrow().as_ref().is_some_and(CancelToken::is_cancelled))
}
pub(crate) struct EnterGuard {
prev: Option<CancelToken>,
}
impl EnterGuard {
pub(crate) fn new(token: &CancelToken) -> Self {
let prev = CURRENT.with(|c| c.replace(Some(token.clone())));
Self { prev }
}
}
impl Drop for EnterGuard {
fn drop(&mut self) {
let prev = self.prev.take();
CURRENT.with(|c| *c.borrow_mut() = prev);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn token_default_not_cancelled() {
let token = CancelToken::new();
assert!(!token.is_cancelled());
}
#[test]
fn token_cancel_sets_flag() {
let token = CancelToken::new();
let clone = token.clone();
token.cancel();
assert!(clone.is_cancelled());
}
#[test]
fn cancel_reaches_descendants_not_ancestors() {
let root = CancelToken::new();
let child = root.child_token();
let grandchild = child.child_token();
let sibling = root.child_token();
child.cancel();
assert!(child.is_cancelled());
assert!(grandchild.is_cancelled());
assert!(!root.is_cancelled());
assert!(!sibling.is_cancelled());
root.cancel();
assert!(sibling.is_cancelled());
}
#[test]
fn child_of_cancelled_token_starts_cancelled() {
let root = CancelToken::new();
root.cancel();
assert!(root.child_token().is_cancelled());
}
#[test]
fn grandchild_stays_reachable_after_middle_handle_is_dropped() {
let root = CancelToken::new();
let grandchild = root.child_token().child_token();
root.cancel();
assert!(grandchild.is_cancelled());
}
#[test]
fn dropped_children_are_swept() {
let root = CancelToken::new();
let keep = root.child_token();
for _ in 0..10_000 {
let _ = root.child_token();
}
assert_eq!(root.live_children(), 1);
assert!(
root.stored_children() <= 32,
"dead children were not swept: {}",
root.stored_children()
);
root.cancel();
assert!(keep.is_cancelled());
}
#[test]
fn current_token_follows_enter_guards() {
assert!(current_token().is_none());
let outer = CancelToken::new();
let inner = CancelToken::new();
{
let _o = EnterGuard::new(&outer);
{
let _i = EnterGuard::new(&inner);
inner.cancel();
assert!(current_is_cancelled());
}
assert!(!current_is_cancelled());
}
assert!(current_token().is_none());
}
}