use serde::{Deserialize, Serialize};
use std::collections::HashMap;
mod timestamp_deserializer {
use chrono::{DateTime, Utc};
use serde::{self, Deserialize, Deserializer};
pub fn deserialize<'de, D>(deserializer: D) -> Result<i64, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum TimestampOrString {
Timestamp(i64),
String(String),
}
match TimestampOrString::deserialize(deserializer)? {
TimestampOrString::Timestamp(ts) => Ok(ts),
TimestampOrString::String(s) => {
DateTime::parse_from_rfc3339(&s)
.map(|dt| dt.with_timezone(&Utc).timestamp_millis())
.or_else(|_| {
s.parse::<i64>()
})
.map_err(serde::de::Error::custom)
}
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TaskStatus {
#[default]
Scheduled,
InProgress,
Completed,
Failed,
FailedWithTerminalError,
Canceled,
Skipped,
TimedOut,
}
#[derive(Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Task {
#[serde(default)]
pub task_id: String,
#[serde(default)]
pub task_type: String,
#[serde(default)]
pub reference_task_name: String,
#[serde(default)]
pub status: TaskStatus,
#[serde(default)]
pub input_data: HashMap<String, serde_json::Value>,
#[serde(default)]
pub output_data: HashMap<String, serde_json::Value>,
#[serde(default)]
pub workflow_instance_id: String,
#[serde(default)]
pub workflow_type: String,
#[serde(default)]
pub task_def_name: String,
#[serde(default)]
pub retry_count: i32,
#[serde(default)]
pub poll_count: i32,
#[serde(default)]
pub worker_id: Option<String>,
#[serde(default)]
pub domain: Option<String>,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub scheduled_time: i64,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub start_time: i64,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub end_time: i64,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub update_time: i64,
#[serde(default)]
pub queue_wait_time: i64,
#[serde(default)]
pub callback_after_seconds: i64,
#[serde(default)]
pub response_timeout_seconds: i64,
#[serde(default)]
pub execution_name_space: Option<String>,
#[serde(default)]
pub isolation_group_id: Option<String>,
#[serde(default)]
pub correlation_id: Option<String>,
#[serde(default)]
pub reason_for_incompletion: Option<String>,
#[serde(default)]
pub external_input_payload_storage_path: Option<String>,
#[serde(default)]
pub external_output_payload_storage_path: Option<String>,
#[serde(default)]
pub logs: Vec<TaskExecLog>,
#[serde(default)]
pub sub_workflow_id: Option<String>,
#[serde(default)]
pub iteration: i32,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub runtime_metadata: HashMap<String, String>,
}
impl std::fmt::Debug for Task {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut runtime_metadata_keys: Vec<&str> =
self.runtime_metadata.keys().map(String::as_str).collect();
runtime_metadata_keys.sort_unstable();
f.debug_struct("Task")
.field("task_id", &self.task_id)
.field("task_type", &self.task_type)
.field("reference_task_name", &self.reference_task_name)
.field("status", &self.status)
.field("input_data", &self.input_data)
.field("output_data", &self.output_data)
.field("workflow_instance_id", &self.workflow_instance_id)
.field("workflow_type", &self.workflow_type)
.field("task_def_name", &self.task_def_name)
.field("retry_count", &self.retry_count)
.field("poll_count", &self.poll_count)
.field("worker_id", &self.worker_id)
.field("domain", &self.domain)
.field("scheduled_time", &self.scheduled_time)
.field("start_time", &self.start_time)
.field("end_time", &self.end_time)
.field("update_time", &self.update_time)
.field("queue_wait_time", &self.queue_wait_time)
.field("callback_after_seconds", &self.callback_after_seconds)
.field("response_timeout_seconds", &self.response_timeout_seconds)
.field("execution_name_space", &self.execution_name_space)
.field("isolation_group_id", &self.isolation_group_id)
.field("correlation_id", &self.correlation_id)
.field("reason_for_incompletion", &self.reason_for_incompletion)
.field(
"external_input_payload_storage_path",
&self.external_input_payload_storage_path,
)
.field(
"external_output_payload_storage_path",
&self.external_output_payload_storage_path,
)
.field("logs", &self.logs)
.field("sub_workflow_id", &self.sub_workflow_id)
.field("iteration", &self.iteration)
.field("runtime_metadata_keys", &runtime_metadata_keys)
.finish()
}
}
impl Task {
#[must_use]
pub fn get_input<T>(&self, key: &str) -> Option<T>
where
T: serde::de::DeserializeOwned,
{
let v = self.input_data.get(key)?;
serde_json::from_value(v.clone()).ok()
}
#[must_use]
pub fn get_input_string(&self, key: &str) -> Option<String> {
self.input_data.get(key).map(|v| {
if let serde_json::Value::String(s) = v {
s.clone()
} else {
v.to_string()
}
})
}
#[must_use]
pub fn is_terminal(&self) -> bool {
matches!(
self.status,
TaskStatus::Completed
| TaskStatus::Failed
| TaskStatus::FailedWithTerminalError
| TaskStatus::Canceled
| TaskStatus::Skipped
| TaskStatus::TimedOut
)
}
#[must_use]
pub fn context(&self) -> crate::worker::TaskContext {
crate::worker::TaskContext::from_task(self)
}
#[must_use]
pub fn task_id(&self) -> &str {
&self.task_id
}
#[must_use]
pub fn workflow_instance_id(&self) -> &str {
&self.workflow_instance_id
}
#[must_use]
pub fn poll_count(&self) -> i32 {
self.poll_count
}
#[must_use]
pub fn retry_count(&self) -> i32 {
self.retry_count
}
#[must_use]
pub fn is_first_poll(&self) -> bool {
self.poll_count == 0
}
#[must_use]
pub fn is_retry(&self) -> bool {
self.retry_count > 0
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TaskExecLog {
pub log: String,
pub task_id: String,
pub created_time: i64,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_task_deserialization() {
let json = r#"{
"taskId": "task-123",
"taskType": "simple_task",
"status": "IN_PROGRESS",
"inputData": {"name": "test"},
"workflowInstanceId": "wf-456"
}"#;
let task: Task = serde_json::from_str(json).unwrap();
assert_eq!(task.task_id, "task-123");
assert_eq!(task.task_type, "simple_task");
assert_eq!(task.status, TaskStatus::InProgress);
assert_eq!(task.get_input_string("name"), Some("test".to_owned()));
}
#[test]
fn test_task_debug_redacts_runtime_metadata_values() {
let task = Task {
runtime_metadata: HashMap::from([(
"GH_TOKEN".to_owned(),
"ghp_super_secret".to_owned(),
)]),
..Default::default()
};
let debug = format!("{task:?}");
assert!(debug.contains("GH_TOKEN"));
assert!(!debug.contains("ghp_super_secret"));
}
#[test]
fn test_task_is_terminal() {
let task = Task {
status: TaskStatus::InProgress,
..Default::default()
};
assert!(!task.is_terminal());
let task = Task {
status: TaskStatus::Completed,
..Default::default()
};
assert!(task.is_terminal());
let task = Task {
status: TaskStatus::Failed,
..Default::default()
};
assert!(task.is_terminal());
}
}