cruxx-core 0.2.5

Core types, traits, and runtime for the cruxx agentic DSL
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

/// Adapter: in-memory registry backend for tests and single-process agents.
use std::collections::HashMap;
use std::sync::{Arc, RwLock};

use crate::types::id::TaskId;

use super::backend::RegistryBackend;
use super::error::RegistryErr;

#[derive(Debug, Clone, Default)]
pub struct InMemoryBackend {
    store: Arc<RwLock<HashMap<String, Vec<u8>>>>,
}

impl InMemoryBackend {
    pub fn new() -> Self {
        Self::default()
    }
}

impl RegistryBackend for InMemoryBackend {
    async fn get(&self, id: &TaskId) -> Result<Option<Vec<u8>>, RegistryErr> {
        let store = self
            .store
            .read()
            .map_err(|e| RegistryErr::Storage(e.to_string()))?;
        Ok(store.get(id.as_str()).cloned())
    }

    async fn put(&self, id: &TaskId, data: Vec<u8>) -> Result<(), RegistryErr> {
        let mut store = self
            .store
            .write()
            .map_err(|e| RegistryErr::Storage(e.to_string()))?;
        store.insert(id.as_str().to_string(), data);
        Ok(())
    }

    async fn list(&self, prefix: &str) -> Result<Vec<TaskId>, RegistryErr> {
        let store = self
            .store
            .read()
            .map_err(|e| RegistryErr::Storage(e.to_string()))?;
        let ids = store
            .keys()
            .filter(|k| k.starts_with(prefix))
            .filter_map(|k| k.parse().ok())
            .collect();
        Ok(ids)
    }

    async fn cas(&self, id: &TaskId, expected: Vec<u8>, new: Vec<u8>) -> Result<bool, RegistryErr> {
        let mut store = self
            .store
            .write()
            .map_err(|e| RegistryErr::Storage(e.to_string()))?;
        let key = id.as_str().to_string();
        match store.get(&key) {
            Some(current) if *current == expected => {
                store.insert(key, new);
                Ok(true)
            }
            _ => Ok(false),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn put_and_get() {
        let backend = InMemoryBackend::new();
        let id = TaskId::new();
        backend.put(&id, b"hello".to_vec()).await.unwrap();

        let data = backend.get(&id).await.unwrap();
        assert_eq!(data, Some(b"hello".to_vec()));
    }

    #[tokio::test]
    async fn get_missing_returns_none() {
        let backend = InMemoryBackend::new();
        let id = TaskId::new();
        assert_eq!(backend.get(&id).await.unwrap(), None);
    }

    #[tokio::test]
    async fn cas_succeeds_on_match() {
        let backend = InMemoryBackend::new();
        let id = TaskId::new();
        backend.put(&id, b"v1".to_vec()).await.unwrap();

        let ok = backend
            .cas(&id, b"v1".to_vec(), b"v2".to_vec())
            .await
            .unwrap();
        assert!(ok);
        assert_eq!(backend.get(&id).await.unwrap(), Some(b"v2".to_vec()));
    }

    #[tokio::test]
    async fn cas_fails_on_mismatch() {
        let backend = InMemoryBackend::new();
        let id = TaskId::new();
        backend.put(&id, b"v1".to_vec()).await.unwrap();

        let ok = backend
            .cas(&id, b"wrong".to_vec(), b"v2".to_vec())
            .await
            .unwrap();
        assert!(!ok);
        assert_eq!(backend.get(&id).await.unwrap(), Some(b"v1".to_vec()));
    }
}