use std::time::Duration;
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct TaskExecutionOptions {
pub timeout: Option<Duration>,
pub heartbeat_timeout: Option<Duration>,
pub retry_initial_interval: Option<Duration>,
pub retry_max_interval: Option<Duration>,
pub retry_backoff_coefficient: Option<f64>,
}
impl TaskExecutionOptions {
pub fn with_timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
pub fn with_heartbeat_timeout(mut self, timeout: Duration) -> Self {
self.heartbeat_timeout = Some(timeout);
self
}
pub fn with_retry_initial_interval(mut self, interval: Duration) -> Self {
self.retry_initial_interval = Some(interval);
self
}
pub fn with_retry_max_interval(mut self, interval: Duration) -> Self {
self.retry_max_interval = Some(interval);
self
}
pub fn with_retry_backoff_coefficient(mut self, coefficient: f64) -> Self {
self.retry_backoff_coefficient = Some(coefficient);
self
}
}
#[derive(Debug, Clone)]
pub struct TaskInfo {
pub task_type: String,
pub workflow_id: String,
pub run_id: String,
pub task_id: String,
pub attempt: i32,
pub task_queue: String,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_task_execution_options_defaults() {
let options = TaskExecutionOptions::default();
assert!(options.timeout.is_none());
assert!(options.heartbeat_timeout.is_none());
assert!(options.retry_initial_interval.is_none());
assert!(options.retry_max_interval.is_none());
assert!(options.retry_backoff_coefficient.is_none());
}
#[test]
fn test_task_info() {
let info = TaskInfo {
task_type: "ProcessPayment".to_string(),
workflow_id: "wf-123".to_string(),
run_id: "run-456".to_string(),
task_id: "task-789".to_string(),
attempt: 1,
task_queue: "payments".to_string(),
};
assert_eq!(info.task_type, "ProcessPayment");
assert_eq!(info.workflow_id, "wf-123");
assert_eq!(info.task_id, "task-789");
}
}