1use serde::{Deserialize, Serialize};
5use std::collections::HashMap;
6
7mod timestamp_deserializer {
9 use chrono::{DateTime, Utc};
10 use serde::{self, Deserialize, Deserializer};
11
12 pub fn deserialize<'de, D>(deserializer: D) -> Result<i64, D::Error>
14 where
15 D: Deserializer<'de>,
16 {
17 #[derive(Deserialize)]
18 #[serde(untagged)]
19 enum TimestampOrString {
20 Timestamp(i64),
21 String(String),
22 }
23
24 match TimestampOrString::deserialize(deserializer)? {
25 TimestampOrString::Timestamp(ts) => Ok(ts),
26 TimestampOrString::String(s) => {
27 DateTime::parse_from_rfc3339(&s)
29 .map(|dt| dt.with_timezone(&Utc).timestamp_millis())
30 .or_else(|_| {
31 s.parse::<i64>()
33 })
34 .map_err(serde::de::Error::custom)
35 }
36 }
37 }
38}
39
40#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
42#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
43pub enum TaskStatus {
44 #[default]
46 Scheduled,
47 InProgress,
49 Completed,
51 Failed,
53 FailedWithTerminalError,
55 Canceled,
57 Skipped,
59 TimedOut,
61}
62
63#[derive(Clone, Default, Serialize, Deserialize)]
65#[serde(rename_all = "camelCase")]
66pub struct Task {
67 #[serde(default)]
69 pub task_id: String,
70
71 #[serde(default)]
73 pub task_type: String,
74
75 #[serde(default)]
77 pub reference_task_name: String,
78
79 #[serde(default)]
81 pub status: TaskStatus,
82
83 #[serde(default)]
85 pub input_data: HashMap<String, serde_json::Value>,
86
87 #[serde(default)]
89 pub output_data: HashMap<String, serde_json::Value>,
90
91 #[serde(default)]
93 pub workflow_instance_id: String,
94
95 #[serde(default)]
97 pub workflow_type: String,
98
99 #[serde(default)]
101 pub task_def_name: String,
102
103 #[serde(default)]
105 pub retry_count: i32,
106
107 #[serde(default)]
109 pub poll_count: i32,
110
111 #[serde(default)]
113 pub worker_id: Option<String>,
114
115 #[serde(default)]
117 pub domain: Option<String>,
118
119 #[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
121 pub scheduled_time: i64,
122
123 #[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
125 pub start_time: i64,
126
127 #[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
129 pub end_time: i64,
130
131 #[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
133 pub update_time: i64,
134
135 #[serde(default)]
137 pub queue_wait_time: i64,
138
139 #[serde(default)]
141 pub callback_after_seconds: i64,
142
143 #[serde(default)]
145 pub response_timeout_seconds: i64,
146
147 #[serde(default)]
149 pub execution_name_space: Option<String>,
150
151 #[serde(default)]
153 pub isolation_group_id: Option<String>,
154
155 #[serde(default)]
157 pub correlation_id: Option<String>,
158
159 #[serde(default)]
161 pub reason_for_incompletion: Option<String>,
162
163 #[serde(default)]
165 pub external_input_payload_storage_path: Option<String>,
166
167 #[serde(default)]
169 pub external_output_payload_storage_path: Option<String>,
170
171 #[serde(default)]
173 pub logs: Vec<TaskExecLog>,
174
175 #[serde(default)]
177 pub sub_workflow_id: Option<String>,
178
179 #[serde(default)]
181 pub iteration: i32,
182
183 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
187 pub runtime_metadata: HashMap<String, String>,
188}
189
190impl std::fmt::Debug for Task {
191 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
192 let mut runtime_metadata_keys: Vec<&str> =
193 self.runtime_metadata.keys().map(String::as_str).collect();
194 runtime_metadata_keys.sort_unstable();
195 f.debug_struct("Task")
196 .field("task_id", &self.task_id)
197 .field("task_type", &self.task_type)
198 .field("reference_task_name", &self.reference_task_name)
199 .field("status", &self.status)
200 .field("input_data", &self.input_data)
201 .field("output_data", &self.output_data)
202 .field("workflow_instance_id", &self.workflow_instance_id)
203 .field("workflow_type", &self.workflow_type)
204 .field("task_def_name", &self.task_def_name)
205 .field("retry_count", &self.retry_count)
206 .field("poll_count", &self.poll_count)
207 .field("worker_id", &self.worker_id)
208 .field("domain", &self.domain)
209 .field("scheduled_time", &self.scheduled_time)
210 .field("start_time", &self.start_time)
211 .field("end_time", &self.end_time)
212 .field("update_time", &self.update_time)
213 .field("queue_wait_time", &self.queue_wait_time)
214 .field("callback_after_seconds", &self.callback_after_seconds)
215 .field("response_timeout_seconds", &self.response_timeout_seconds)
216 .field("execution_name_space", &self.execution_name_space)
217 .field("isolation_group_id", &self.isolation_group_id)
218 .field("correlation_id", &self.correlation_id)
219 .field("reason_for_incompletion", &self.reason_for_incompletion)
220 .field(
221 "external_input_payload_storage_path",
222 &self.external_input_payload_storage_path,
223 )
224 .field(
225 "external_output_payload_storage_path",
226 &self.external_output_payload_storage_path,
227 )
228 .field("logs", &self.logs)
229 .field("sub_workflow_id", &self.sub_workflow_id)
230 .field("iteration", &self.iteration)
231 .field("runtime_metadata_keys", &runtime_metadata_keys)
233 .finish()
234 }
235}
236
237impl Task {
238 #[must_use]
240 pub fn get_input<T>(&self, key: &str) -> Option<T>
241 where
242 T: serde::de::DeserializeOwned,
243 {
244 let v = self.input_data.get(key)?;
245 serde_json::from_value(v.clone()).ok()
246 }
247
248 #[must_use]
250 pub fn get_input_string(&self, key: &str) -> Option<String> {
251 self.input_data.get(key).map(|v| {
252 if let serde_json::Value::String(s) = v {
253 s.clone()
254 } else {
255 v.to_string()
256 }
257 })
258 }
259
260 #[must_use]
262 pub fn is_terminal(&self) -> bool {
263 matches!(
264 self.status,
265 TaskStatus::Completed
266 | TaskStatus::Failed
267 | TaskStatus::FailedWithTerminalError
268 | TaskStatus::Canceled
269 | TaskStatus::Skipped
270 | TaskStatus::TimedOut
271 )
272 }
273
274 #[must_use]
296 pub fn context(&self) -> crate::worker::TaskContext {
297 crate::worker::TaskContext::from_task(self)
298 }
299
300 #[must_use]
302 pub fn task_id(&self) -> &str {
303 &self.task_id
304 }
305
306 #[must_use]
308 pub fn workflow_instance_id(&self) -> &str {
309 &self.workflow_instance_id
310 }
311
312 #[must_use]
314 pub fn poll_count(&self) -> i32 {
315 self.poll_count
316 }
317
318 #[must_use]
320 pub fn retry_count(&self) -> i32 {
321 self.retry_count
322 }
323
324 #[must_use]
326 pub fn is_first_poll(&self) -> bool {
327 self.poll_count == 0
328 }
329
330 #[must_use]
332 pub fn is_retry(&self) -> bool {
333 self.retry_count > 0
334 }
335}
336
337#[derive(Debug, Clone, Default, Serialize, Deserialize)]
339#[serde(rename_all = "camelCase")]
340pub struct TaskExecLog {
341 pub log: String,
343
344 pub task_id: String,
346
347 pub created_time: i64,
349}
350
351#[cfg(test)]
352mod tests {
353 use super::*;
354
355 #[test]
356 fn test_task_deserialization() {
357 let json = r#"{
358 "taskId": "task-123",
359 "taskType": "simple_task",
360 "status": "IN_PROGRESS",
361 "inputData": {"name": "test"},
362 "workflowInstanceId": "wf-456"
363 }"#;
364
365 let task: Task = serde_json::from_str(json).unwrap();
366 assert_eq!(task.task_id, "task-123");
367 assert_eq!(task.task_type, "simple_task");
368 assert_eq!(task.status, TaskStatus::InProgress);
369 assert_eq!(task.get_input_string("name"), Some("test".to_owned()));
370 }
371
372 #[test]
373 fn test_task_debug_redacts_runtime_metadata_values() {
374 let task = Task {
375 runtime_metadata: HashMap::from([(
376 "GH_TOKEN".to_owned(),
377 "ghp_super_secret".to_owned(),
378 )]),
379 ..Default::default()
380 };
381
382 let debug = format!("{task:?}");
383 assert!(debug.contains("GH_TOKEN"));
384 assert!(!debug.contains("ghp_super_secret"));
385 }
386
387 #[test]
388 fn test_task_is_terminal() {
389 let task = Task {
390 status: TaskStatus::InProgress,
391 ..Default::default()
392 };
393 assert!(!task.is_terminal());
394
395 let task = Task {
396 status: TaskStatus::Completed,
397 ..Default::default()
398 };
399 assert!(task.is_terminal());
400
401 let task = Task {
402 status: TaskStatus::Failed,
403 ..Default::default()
404 };
405 assert!(task.is_terminal());
406 }
407}