Skip to main content

yaiko_core/
task_results.rs

1//! Inspectable task lifecycle and result storage for workers and clients.
2
3use std::collections::BTreeMap;
4use std::sync::{Arc, Mutex};
5use std::time::{SystemTime, UNIX_EPOCH};
6use uuid::Uuid;
7
8#[derive(Debug, Clone, PartialEq, Eq)]
9pub enum TaskState {
10    Pending,
11    Running,
12    Succeeded,
13    Failed,
14    CancelRequested,
15    Cancelled,
16}
17#[derive(Debug, Clone, PartialEq, Eq)]
18pub struct TaskResult {
19    pub id: String,
20    pub state: TaskState,
21    pub progress_percent: u8,
22    pub result: Option<Vec<u8>>,
23    pub error: Option<String>,
24    pub created_at: u64,
25    pub updated_at: u64,
26}
27#[derive(Debug, Clone, PartialEq, Eq)]
28pub enum TaskResultError {
29    Capacity,
30    NotFound,
31    InvalidState,
32    NotOwner,
33    InvalidError,
34}
35
36#[derive(Clone)]
37pub struct TaskResultStore {
38    tasks: Arc<Mutex<BTreeMap<String, TaskResult>>>,
39    capacity: usize,
40}
41
42impl TaskResultStore {
43    pub fn new(capacity: usize) -> Self {
44        Self {
45            tasks: Arc::new(Mutex::new(BTreeMap::new())),
46            capacity: capacity.max(1),
47        }
48    }
49    pub fn create(&self) -> Result<TaskResult, TaskResultError> {
50        let mut tasks = self.tasks.lock().expect("task result store poisoned");
51        if tasks.len() >= self.capacity {
52            return Err(TaskResultError::Capacity);
53        }
54        let now = now();
55        let task = TaskResult {
56            id: Uuid::new_v4().to_string(),
57            state: TaskState::Pending,
58            progress_percent: 0,
59            result: None,
60            error: None,
61            created_at: now,
62            updated_at: now,
63        };
64        tasks.insert(task.id.clone(), task.clone());
65        Ok(task)
66    }
67    pub fn start(&self, id: &str) -> Result<(), TaskResultError> {
68        self.transition(id, |task| {
69            if task.state != TaskState::Pending {
70                return Err(TaskResultError::InvalidState);
71            }
72            task.state = TaskState::Running;
73            Ok(())
74        })
75    }
76    pub fn progress(&self, id: &str, percent: u8) -> Result<u8, TaskResultError> {
77        self.transition(id, |task| {
78            if !matches!(task.state, TaskState::Running | TaskState::CancelRequested) {
79                return Err(TaskResultError::InvalidState);
80            }
81            task.progress_percent = percent.min(100);
82            Ok(task.progress_percent)
83        })
84    }
85    pub fn succeed(&self, id: &str, result: Vec<u8>) -> Result<(), TaskResultError> {
86        self.transition(id, |task| {
87            if !matches!(task.state, TaskState::Running) {
88                return Err(TaskResultError::InvalidState);
89            }
90            task.progress_percent = 100;
91            task.result = Some(result);
92            task.state = TaskState::Succeeded;
93            Ok(())
94        })
95    }
96    pub fn fail(&self, id: &str, error: impl Into<String>) -> Result<(), TaskResultError> {
97        let error = error.into();
98        if error.is_empty() || error.len() > 4096 {
99            return Err(TaskResultError::InvalidError);
100        }
101        self.transition(id, |task| {
102            if !matches!(task.state, TaskState::Running | TaskState::CancelRequested) {
103                return Err(TaskResultError::InvalidState);
104            }
105            task.error = Some(error);
106            task.state = TaskState::Failed;
107            Ok(())
108        })
109    }
110    pub fn request_cancel(&self, id: &str) -> Result<(), TaskResultError> {
111        self.transition(id, |task| {
112            if !matches!(task.state, TaskState::Pending | TaskState::Running) {
113                return Err(TaskResultError::InvalidState);
114            }
115            task.state = if task.state == TaskState::Pending {
116                TaskState::Cancelled
117            } else {
118                TaskState::CancelRequested
119            };
120            Ok(())
121        })
122    }
123    pub fn cancel(&self, id: &str) -> Result<(), TaskResultError> {
124        self.transition(id, |task| {
125            if task.state != TaskState::CancelRequested {
126                return Err(TaskResultError::NotOwner);
127            }
128            task.state = TaskState::Cancelled;
129            Ok(())
130        })
131    }
132    pub fn get(&self, id: &str) -> Option<TaskResult> {
133        self.tasks
134            .lock()
135            .expect("task result store poisoned")
136            .get(id)
137            .cloned()
138    }
139    pub fn cleanup_before(&self, timestamp: u64) -> usize {
140        let mut tasks = self.tasks.lock().expect("task result store poisoned");
141        let before = tasks.len();
142        tasks.retain(|_, task| {
143            task.updated_at >= timestamp
144                || matches!(
145                    task.state,
146                    TaskState::Pending | TaskState::Running | TaskState::CancelRequested
147                )
148        });
149        before - tasks.len()
150    }
151    fn transition<F, T>(&self, id: &str, update: F) -> Result<T, TaskResultError>
152    where
153        F: FnOnce(&mut TaskResult) -> Result<T, TaskResultError>,
154    {
155        let mut tasks = self.tasks.lock().expect("task result store poisoned");
156        let task = tasks.get_mut(id).ok_or(TaskResultError::NotFound)?;
157        let result = update(task)?;
158        task.updated_at = now();
159        Ok(result)
160    }
161}
162fn now() -> u64 {
163    SystemTime::now()
164        .duration_since(UNIX_EPOCH)
165        .unwrap_or_default()
166        .as_secs()
167}
168
169#[cfg(test)]
170mod tests {
171    use super::*;
172    #[test]
173    fn tracks_lifecycle_and_clamps_progress() {
174        let store = TaskResultStore::new(2);
175        let task = store.create().unwrap();
176        store.start(&task.id).unwrap();
177        assert_eq!(store.progress(&task.id, 240).unwrap(), 100);
178        store.succeed(&task.id, b"done".to_vec()).unwrap();
179        let result = store.get(&task.id).unwrap();
180        assert_eq!(result.state, TaskState::Succeeded);
181        assert_eq!(result.result, Some(b"done".to_vec()));
182    }
183    #[test]
184    fn supports_cancellation_and_rejects_invalid_transitions() {
185        let store = TaskResultStore::new(2);
186        let task = store.create().unwrap();
187        store.start(&task.id).unwrap();
188        store.request_cancel(&task.id).unwrap();
189        assert_eq!(
190            store.get(&task.id).unwrap().state,
191            TaskState::CancelRequested
192        );
193        store.cancel(&task.id).unwrap();
194        assert_eq!(store.get(&task.id).unwrap().state, TaskState::Cancelled);
195        assert_eq!(
196            store.succeed(&task.id, Vec::new()),
197            Err(TaskResultError::InvalidState)
198        );
199    }
200    #[test]
201    fn bounds_capacity_and_errors() {
202        let store = TaskResultStore::new(1);
203        let task = store.create().unwrap();
204        assert_eq!(store.create(), Err(TaskResultError::Capacity));
205        store.start(&task.id).unwrap();
206        assert_eq!(store.fail(&task.id, ""), Err(TaskResultError::InvalidError));
207    }
208    #[test]
209    fn cleans_only_terminal_old_records() {
210        let store = TaskResultStore::new(3);
211        let task = store.create().unwrap();
212        store.start(&task.id).unwrap();
213        store.succeed(&task.id, Vec::new()).unwrap();
214        assert_eq!(store.cleanup_before(u64::MAX), 1);
215    }
216}