Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
1.9 KB
Raw Blame
use std::{
    collections::BTreeMap,
    sync::{
        atomic::{AtomicBool, Ordering},
        Arc, Mutex,
    },
};

#[derive(Clone, Default)]
pub(super) struct CancellationRegistry(Arc<Mutex<BTreeMap<String, Arc<AtomicBool>>>>);

impl CancellationRegistry {
    pub(super) fn register(&self, id: &str) -> Result<RunningTurn, String> {
        let mut running = self.0.lock().map_err(|_| "Agent runtime lock failed.")?;
        if running.contains_key(id) {
            return Err("This agent request is already running.".into());
        }
        let flag = Arc::new(AtomicBool::new(false));
        running.insert(id.to_owned(), flag.clone());
        Ok(RunningTurn {
            registry: self.clone(),
            id: id.to_owned(),
            flag,
        })
    }

    pub(super) fn cancel(&self, id: &str) -> bool {
        self.0
            .lock()
            .ok()
            .and_then(|running| running.get(id).cloned())
            .is_some_and(|flag| {
                flag.store(true, Ordering::Release);
                true
            })
    }
}

pub(super) struct RunningTurn {
    registry: CancellationRegistry,
    id: String,
    pub(super) flag: Arc<AtomicBool>,
}

impl Drop for RunningTurn {
    fn drop(&mut self) {
        let mut running = self
            .registry
            .0
            .lock()
            .unwrap_or_else(|poisoned| poisoned.into_inner());
        running.remove(&self.id);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn duplicate_ids_cannot_replace_cancellation_and_drop_unregisters() {
        let registry = CancellationRegistry::default();
        let running = registry.register("turn").unwrap();
        assert!(registry.register("turn").is_err());
        assert!(registry.cancel("turn"));
        assert!(running.flag.load(Ordering::Acquire));
        drop(running);
        assert!(!registry.cancel("turn"));
        assert!(registry.register("turn").is_ok());
    }
}