1use 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}