Struct TaskDefinition 

pub struct TaskDefinition {
    pub id: String,
    pub name: String,
    pub task_type: String,
    pub payload: HashMap<String, Value>,
    pub priority: i32,
    pub max_retries: u32,
    pub timeout_seconds: u64,
    pub dependencies: Vec<String>,
    pub tags: Vec<String>,
    pub created_at: DateTime<Utc>,
    pub scheduled_at: Option<DateTime<Utc>>,
}

Fields

id: String

name: String

task_type: String

payload: HashMap<String, Value>

priority: i32

max_retries: u32

timeout_seconds: u64

dependencies: Vec<String>

tags: Vec<String>

created_at: DateTime<Utc>

scheduled_at: Option<DateTime<Utc>>

Implementations

impl TaskDefinition

pub fn new(name: &str, task_type: &str) -> Self

Examples found in repository

examples/basic_usage.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init();

    let config = TaskFlowConfig::with_in_memory();
    let taskflow = TaskFlow::new(config).await?;

    println!("TaskFlow framework started!");

    let task_id = taskflow
        .submit_http_task("fetch_example", "https://httpbin.org/get", Some("GET"))
        .await?;

    println!("Submitted HTTP task: {}", task_id);

    let shell_task_id = taskflow
        .submit_shell_task("list_files", "ls", vec!["-la"])
        .await?;

    println!("Submitted shell task: {}", shell_task_id);

    let dependent_task = TaskDefinition::new("dependent_task", "shell_command")
        .with_payload("command", serde_json::Value::String("echo".to_string()))
        .with_payload(
            "args",
            serde_json::Value::Array(vec![serde_json::Value::String(
                "This task depends on the shell task".to_string(),
            )]),
        )
        .with_dependencies(vec![shell_task_id.clone()]);

    let dependent_task_id = taskflow.submit_task(dependent_task).await?;
    println!("Submitted dependent task: {}", dependent_task_id);

    let taskflow_clone = std::sync::Arc::new(taskflow);
    let taskflow_for_execution = taskflow_clone.clone();

    let execution_handle = tokio::spawn(async move {
        if let Err(e) = taskflow_for_execution.start().await {
            eprintln!("TaskFlow execution failed: {}", e);
        }
    });

    tokio::time::sleep(Duration::from_secs(2)).await;

    loop {
        let metrics = taskflow_clone.get_task_metrics().await?;
        println!(
            "Task metrics: pending={}, running={}, completed={}, failed={}, total={}",
            metrics.pending, metrics.running, metrics.completed, metrics.failed, metrics.total
        );

        if metrics.pending == 0 && metrics.running == 0 {
            break;
        }

        tokio::time::sleep(Duration::from_secs(1)).await;
    }

    println!("All tasks completed!");

    let tasks = taskflow_clone.list_tasks(None).await?;
    for task in tasks {
        println!("Task: {} - Status: {:?}", task.definition.name, task.status);
        if let Some(result) = &task.result {
            if result.success {
                println!("  Output: {:?}", result.output);
            } else {
                println!("  Error: {:?}", result.error);
            }
        }
    }

    taskflow_clone.shutdown().await?;
    execution_handle.abort();

    Ok(())
}

examples/simple_execution.rs (line 15)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Testing handler execution directly...\n");

    // Test Python handler
    println!("=== Testing Python Handler ===");
    let python_handler = PythonTaskHandler::new();
    let python_task = Task::new(
        TaskDefinition::new("test-python", "python_script")
            .with_payload(
                "script",
                json!("print('Hello from direct execution!'); x = 5 + 3; print(f'5 + 3 = {x}')"),
            )
            .with_payload("args", json!([])),
    );

    match python_handler.execute(&python_task).await {
        Ok(result) => {
            println!("Python execution successful: {}", result.success);
            println!("Output: {:?}", result.output);
        }
        Err(e) => println!("Python execution failed: {}", e),
    }

    println!("\n=== Testing File Handler ===");
    // Test File handler
    let file_handler = FileTaskHandler::new();

    // Create a test file
    let create_task = Task::new(
        TaskDefinition::new("test-create", "file_operation")
            .with_payload("operation", json!("write"))
            .with_payload("path", json!("/tmp/test_direct.txt"))
            .with_payload(
                "content",
                json!("This was created by direct handler execution\nTest successful!"),
            ),
    );

    match file_handler.execute(&create_task).await {
        Ok(result) => {
            println!("File creation successful: {}", result.success);
            println!("Output: {:?}", result.output);
        }
        Err(e) => println!("File creation failed: {}", e),
    }

    // Read the file back
    println!("\n=== Testing File Read ===");
    let read_task = Task::new(
        TaskDefinition::new("test-read", "file_operation")
            .with_payload("operation", json!("read"))
            .with_payload("path", json!("/tmp/test_direct.txt")),
    );

    match file_handler.execute(&read_task).await {
        Ok(result) => {
            println!("File read successful: {}", result.success);
            if let Some(content) = result.output {
                println!("File content: {}", content);
            }
        }
        Err(e) => println!("File read failed: {}", e),
    }

    // Cleanup
    println!("\n=== Cleaning Up ===");
    let delete_task = Task::new(
        TaskDefinition::new("test-delete", "file_operation")
            .with_payload("operation", json!("delete"))
            .with_payload("path", json!("/tmp/test_direct.txt")),
    );

    match file_handler.execute(&delete_task).await {
        Ok(result) => println!("File cleanup successful: {}", result.success),
        Err(e) => println!("File cleanup failed: {}", e),
    }

    println!("\nDirect handler execution test completed!");
    Ok(())
}

examples/custom_handler.rs (line 182)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init();

    let config = TaskFlowConfig::with_in_memory();
    let taskflow = TaskFlow::new(config).await?;

    taskflow.register_handler(Arc::new(MathTaskHandler)).await;
    taskflow
        .register_handler(Arc::new(DataProcessingHandler))
        .await;

    println!("TaskFlow with custom handlers started!");

    let add_task = TaskDefinition::new("addition", "math_operation")
        .with_payload("operation", serde_json::Value::String("add".to_string()))
        .with_payload("a", serde_json::Value::Number(serde_json::Number::from(10)))
        .with_payload("b", serde_json::Value::Number(serde_json::Number::from(5)));

    let add_task_id = taskflow.submit_task(add_task).await?;
    println!("Submitted addition task: {}", add_task_id);

    let multiply_task = TaskDefinition::new("multiplication", "math_operation")
        .with_payload(
            "operation",
            serde_json::Value::String("multiply".to_string()),
        )
        .with_payload("a", serde_json::Value::Number(serde_json::Number::from(7)))
        .with_payload("b", serde_json::Value::Number(serde_json::Number::from(3)));

    let multiply_task_id = taskflow.submit_task(multiply_task).await?;
    println!("Submitted multiplication task: {}", multiply_task_id);

    let data_array = vec![
        serde_json::Value::Number(serde_json::Number::from(1)),
        serde_json::Value::Number(serde_json::Number::from(2)),
        serde_json::Value::Number(serde_json::Number::from(3)),
        serde_json::Value::Number(serde_json::Number::from(4)),
        serde_json::Value::Number(serde_json::Number::from(5)),
    ];

    let sum_task = TaskDefinition::new("sum_data", "data_processing")
        .with_payload("operation", serde_json::Value::String("sum".to_string()))
        .with_payload("data", serde_json::Value::Array(data_array.clone()));

    let sum_task_id = taskflow.submit_task(sum_task).await?;
    println!("Submitted sum task: {}", sum_task_id);

    let avg_task = TaskDefinition::new("average_data", "data_processing")
        .with_payload(
            "operation",
            serde_json::Value::String("average".to_string()),
        )
        .with_payload("data", serde_json::Value::Array(data_array))
        .with_dependencies(vec![sum_task_id.clone()]);

    let avg_task_id = taskflow.submit_task(avg_task).await?;
    println!("Submitted average task (depends on sum): {}", avg_task_id);

    let taskflow_clone = std::sync::Arc::new(taskflow);
    let taskflow_for_execution = taskflow_clone.clone();

    let execution_handle = tokio::spawn(async move {
        if let Err(e) = taskflow_for_execution.start().await {
            eprintln!("TaskFlow execution failed: {}", e);
        }
    });

    tokio::time::sleep(std::time::Duration::from_secs(1)).await;

    loop {
        let metrics = taskflow_clone.get_task_metrics().await?;
        println!(
            "Task metrics: pending={}, running={}, completed={}, failed={}",
            metrics.pending, metrics.running, metrics.completed, metrics.failed
        );

        if metrics.pending == 0 && metrics.running == 0 {
            break;
        }

        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }

    println!("\nAll tasks completed! Results:");

    let tasks = taskflow_clone.list_tasks(None).await?;
    for task in tasks {
        println!(
            "\nTask: {} ({})",
            task.definition.name, task.definition.task_type
        );
        println!("  Status: {:?}", task.status);
        if let Some(result) = &task.result {
            if result.success {
                println!(
                    "  Result: {}",
                    result.output.as_ref().unwrap_or(&"No output".to_string())
                );
                println!("  Execution time: {}ms", result.execution_time_ms);
                if !result.metadata.is_empty() {
                    println!("  Metadata: {:?}", result.metadata);
                }
            } else {
                println!(
                    "  Error: {}",
                    result
                        .error
                        .as_ref()
                        .unwrap_or(&"Unknown error".to_string())
                );
            }
        }
    }

    let final_metrics = taskflow_clone.get_task_metrics().await?;
    println!("\nFinal metrics:");
    println!("  Total tasks: {}", final_metrics.total);
    println!(
        "  Success rate: {:.1}%",
        final_metrics.success_rate() * 100.0
    );

    taskflow_clone.shutdown().await?;
    execution_handle.abort();

    Ok(())
}

pub fn with_payload(self, key: &str, value: Value) -> Self

Examples found in repository

examples/basic_usage.rs (line 27)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init();

    let config = TaskFlowConfig::with_in_memory();
    let taskflow = TaskFlow::new(config).await?;

    println!("TaskFlow framework started!");

    let task_id = taskflow
        .submit_http_task("fetch_example", "https://httpbin.org/get", Some("GET"))
        .await?;

    println!("Submitted HTTP task: {}", task_id);

    let shell_task_id = taskflow
        .submit_shell_task("list_files", "ls", vec!["-la"])
        .await?;

    println!("Submitted shell task: {}", shell_task_id);

    let dependent_task = TaskDefinition::new("dependent_task", "shell_command")
        .with_payload("command", serde_json::Value::String("echo".to_string()))
        .with_payload(
            "args",
            serde_json::Value::Array(vec![serde_json::Value::String(
                "This task depends on the shell task".to_string(),
            )]),
        )
        .with_dependencies(vec![shell_task_id.clone()]);

    let dependent_task_id = taskflow.submit_task(dependent_task).await?;
    println!("Submitted dependent task: {}", dependent_task_id);

    let taskflow_clone = std::sync::Arc::new(taskflow);
    let taskflow_for_execution = taskflow_clone.clone();

    let execution_handle = tokio::spawn(async move {
        if let Err(e) = taskflow_for_execution.start().await {
            eprintln!("TaskFlow execution failed: {}", e);
        }
    });

    tokio::time::sleep(Duration::from_secs(2)).await;

    loop {
        let metrics = taskflow_clone.get_task_metrics().await?;
        println!(
            "Task metrics: pending={}, running={}, completed={}, failed={}, total={}",
            metrics.pending, metrics.running, metrics.completed, metrics.failed, metrics.total
        );

        if metrics.pending == 0 && metrics.running == 0 {
            break;
        }

        tokio::time::sleep(Duration::from_secs(1)).await;
    }

    println!("All tasks completed!");

    let tasks = taskflow_clone.list_tasks(None).await?;
    for task in tasks {
        println!("Task: {} - Status: {:?}", task.definition.name, task.status);
        if let Some(result) = &task.result {
            if result.success {
                println!("  Output: {:?}", result.output);
            } else {
                println!("  Error: {:?}", result.error);
            }
        }
    }

    taskflow_clone.shutdown().await?;
    execution_handle.abort();

    Ok(())
}

examples/simple_execution.rs (lines 16-19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Testing handler execution directly...\n");

    // Test Python handler
    println!("=== Testing Python Handler ===");
    let python_handler = PythonTaskHandler::new();
    let python_task = Task::new(
        TaskDefinition::new("test-python", "python_script")
            .with_payload(
                "script",
                json!("print('Hello from direct execution!'); x = 5 + 3; print(f'5 + 3 = {x}')"),
            )
            .with_payload("args", json!([])),
    );

    match python_handler.execute(&python_task).await {
        Ok(result) => {
            println!("Python execution successful: {}", result.success);
            println!("Output: {:?}", result.output);
        }
        Err(e) => println!("Python execution failed: {}", e),
    }

    println!("\n=== Testing File Handler ===");
    // Test File handler
    let file_handler = FileTaskHandler::new();

    // Create a test file
    let create_task = Task::new(
        TaskDefinition::new("test-create", "file_operation")
            .with_payload("operation", json!("write"))
            .with_payload("path", json!("/tmp/test_direct.txt"))
            .with_payload(
                "content",
                json!("This was created by direct handler execution\nTest successful!"),
            ),
    );

    match file_handler.execute(&create_task).await {
        Ok(result) => {
            println!("File creation successful: {}", result.success);
            println!("Output: {:?}", result.output);
        }
        Err(e) => println!("File creation failed: {}", e),
    }

    // Read the file back
    println!("\n=== Testing File Read ===");
    let read_task = Task::new(
        TaskDefinition::new("test-read", "file_operation")
            .with_payload("operation", json!("read"))
            .with_payload("path", json!("/tmp/test_direct.txt")),
    );

    match file_handler.execute(&read_task).await {
        Ok(result) => {
            println!("File read successful: {}", result.success);
            if let Some(content) = result.output {
                println!("File content: {}", content);
            }
        }
        Err(e) => println!("File read failed: {}", e),
    }

    // Cleanup
    println!("\n=== Cleaning Up ===");
    let delete_task = Task::new(
        TaskDefinition::new("test-delete", "file_operation")
            .with_payload("operation", json!("delete"))
            .with_payload("path", json!("/tmp/test_direct.txt")),
    );

    match file_handler.execute(&delete_task).await {
        Ok(result) => println!("File cleanup successful: {}", result.success),
        Err(e) => println!("File cleanup failed: {}", e),
    }

    println!("\nDirect handler execution test completed!");
    Ok(())
}

examples/custom_handler.rs (line 183)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init();

    let config = TaskFlowConfig::with_in_memory();
    let taskflow = TaskFlow::new(config).await?;

    taskflow.register_handler(Arc::new(MathTaskHandler)).await;
    taskflow
        .register_handler(Arc::new(DataProcessingHandler))
        .await;

    println!("TaskFlow with custom handlers started!");

    let add_task = TaskDefinition::new("addition", "math_operation")
        .with_payload("operation", serde_json::Value::String("add".to_string()))
        .with_payload("a", serde_json::Value::Number(serde_json::Number::from(10)))
        .with_payload("b", serde_json::Value::Number(serde_json::Number::from(5)));

    let add_task_id = taskflow.submit_task(add_task).await?;
    println!("Submitted addition task: {}", add_task_id);

    let multiply_task = TaskDefinition::new("multiplication", "math_operation")
        .with_payload(
            "operation",
            serde_json::Value::String("multiply".to_string()),
        )
        .with_payload("a", serde_json::Value::Number(serde_json::Number::from(7)))
        .with_payload("b", serde_json::Value::Number(serde_json::Number::from(3)));

    let multiply_task_id = taskflow.submit_task(multiply_task).await?;
    println!("Submitted multiplication task: {}", multiply_task_id);

    let data_array = vec![
        serde_json::Value::Number(serde_json::Number::from(1)),
        serde_json::Value::Number(serde_json::Number::from(2)),
        serde_json::Value::Number(serde_json::Number::from(3)),
        serde_json::Value::Number(serde_json::Number::from(4)),
        serde_json::Value::Number(serde_json::Number::from(5)),
    ];

    let sum_task = TaskDefinition::new("sum_data", "data_processing")
        .with_payload("operation", serde_json::Value::String("sum".to_string()))
        .with_payload("data", serde_json::Value::Array(data_array.clone()));

    let sum_task_id = taskflow.submit_task(sum_task).await?;
    println!("Submitted sum task: {}", sum_task_id);

    let avg_task = TaskDefinition::new("average_data", "data_processing")
        .with_payload(
            "operation",
            serde_json::Value::String("average".to_string()),
        )
        .with_payload("data", serde_json::Value::Array(data_array))
        .with_dependencies(vec![sum_task_id.clone()]);

    let avg_task_id = taskflow.submit_task(avg_task).await?;
    println!("Submitted average task (depends on sum): {}", avg_task_id);

    let taskflow_clone = std::sync::Arc::new(taskflow);
    let taskflow_for_execution = taskflow_clone.clone();

    let execution_handle = tokio::spawn(async move {
        if let Err(e) = taskflow_for_execution.start().await {
            eprintln!("TaskFlow execution failed: {}", e);
        }
    });

    tokio::time::sleep(std::time::Duration::from_secs(1)).await;

    loop {
        let metrics = taskflow_clone.get_task_metrics().await?;
        println!(
            "Task metrics: pending={}, running={}, completed={}, failed={}",
            metrics.pending, metrics.running, metrics.completed, metrics.failed
        );

        if metrics.pending == 0 && metrics.running == 0 {
            break;
        }

        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }

    println!("\nAll tasks completed! Results:");

    let tasks = taskflow_clone.list_tasks(None).await?;
    for task in tasks {
        println!(
            "\nTask: {} ({})",
            task.definition.name, task.definition.task_type
        );
        println!("  Status: {:?}", task.status);
        if let Some(result) = &task.result {
            if result.success {
                println!(
                    "  Result: {}",
                    result.output.as_ref().unwrap_or(&"No output".to_string())
                );
                println!("  Execution time: {}ms", result.execution_time_ms);
                if !result.metadata.is_empty() {
                    println!("  Metadata: {:?}", result.metadata);
                }
            } else {
                println!(
                    "  Error: {}",
                    result
                        .error
                        .as_ref()
                        .unwrap_or(&"Unknown error".to_string())
                );
            }
        }
    }

    let final_metrics = taskflow_clone.get_task_metrics().await?;
    println!("\nFinal metrics:");
    println!("  Total tasks: {}", final_metrics.total);
    println!(
        "  Success rate: {:.1}%",
        final_metrics.success_rate() * 100.0
    );

    taskflow_clone.shutdown().await?;
    execution_handle.abort();

    Ok(())
}

pub fn with_priority(self, priority: i32) -> Self

pub fn with_timeout(self, timeout_seconds: u64) -> Self

pub fn with_dependencies(self, dependencies: Vec<String>) -> Self

Examples found in repository

examples/basic_usage.rs (line 34)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init();

    let config = TaskFlowConfig::with_in_memory();
    let taskflow = TaskFlow::new(config).await?;

    println!("TaskFlow framework started!");

    let task_id = taskflow
        .submit_http_task("fetch_example", "https://httpbin.org/get", Some("GET"))
        .await?;

    println!("Submitted HTTP task: {}", task_id);

    let shell_task_id = taskflow
        .submit_shell_task("list_files", "ls", vec!["-la"])
        .await?;

    println!("Submitted shell task: {}", shell_task_id);

    let dependent_task = TaskDefinition::new("dependent_task", "shell_command")
        .with_payload("command", serde_json::Value::String("echo".to_string()))
        .with_payload(
            "args",
            serde_json::Value::Array(vec![serde_json::Value::String(
                "This task depends on the shell task".to_string(),
            )]),
        )
        .with_dependencies(vec![shell_task_id.clone()]);

    let dependent_task_id = taskflow.submit_task(dependent_task).await?;
    println!("Submitted dependent task: {}", dependent_task_id);

    let taskflow_clone = std::sync::Arc::new(taskflow);
    let taskflow_for_execution = taskflow_clone.clone();

    let execution_handle = tokio::spawn(async move {
        if let Err(e) = taskflow_for_execution.start().await {
            eprintln!("TaskFlow execution failed: {}", e);
        }
    });

    tokio::time::sleep(Duration::from_secs(2)).await;

    loop {
        let metrics = taskflow_clone.get_task_metrics().await?;
        println!(
            "Task metrics: pending={}, running={}, completed={}, failed={}, total={}",
            metrics.pending, metrics.running, metrics.completed, metrics.failed, metrics.total
        );

        if metrics.pending == 0 && metrics.running == 0 {
            break;
        }

        tokio::time::sleep(Duration::from_secs(1)).await;
    }

    println!("All tasks completed!");

    let tasks = taskflow_clone.list_tasks(None).await?;
    for task in tasks {
        println!("Task: {} - Status: {:?}", task.definition.name, task.status);
        if let Some(result) = &task.result {
            if result.success {
                println!("  Output: {:?}", result.output);
            } else {
                println!("  Error: {:?}", result.error);
            }
        }
    }

    taskflow_clone.shutdown().await?;
    execution_handle.abort();

    Ok(())
}

examples/custom_handler.rs (line 222)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init();

    let config = TaskFlowConfig::with_in_memory();
    let taskflow = TaskFlow::new(config).await?;

    taskflow.register_handler(Arc::new(MathTaskHandler)).await;
    taskflow
        .register_handler(Arc::new(DataProcessingHandler))
        .await;

    println!("TaskFlow with custom handlers started!");

    let add_task = TaskDefinition::new("addition", "math_operation")
        .with_payload("operation", serde_json::Value::String("add".to_string()))
        .with_payload("a", serde_json::Value::Number(serde_json::Number::from(10)))
        .with_payload("b", serde_json::Value::Number(serde_json::Number::from(5)));

    let add_task_id = taskflow.submit_task(add_task).await?;
    println!("Submitted addition task: {}", add_task_id);

    let multiply_task = TaskDefinition::new("multiplication", "math_operation")
        .with_payload(
            "operation",
            serde_json::Value::String("multiply".to_string()),
        )
        .with_payload("a", serde_json::Value::Number(serde_json::Number::from(7)))
        .with_payload("b", serde_json::Value::Number(serde_json::Number::from(3)));

    let multiply_task_id = taskflow.submit_task(multiply_task).await?;
    println!("Submitted multiplication task: {}", multiply_task_id);

    let data_array = vec![
        serde_json::Value::Number(serde_json::Number::from(1)),
        serde_json::Value::Number(serde_json::Number::from(2)),
        serde_json::Value::Number(serde_json::Number::from(3)),
        serde_json::Value::Number(serde_json::Number::from(4)),
        serde_json::Value::Number(serde_json::Number::from(5)),
    ];

    let sum_task = TaskDefinition::new("sum_data", "data_processing")
        .with_payload("operation", serde_json::Value::String("sum".to_string()))
        .with_payload("data", serde_json::Value::Array(data_array.clone()));

    let sum_task_id = taskflow.submit_task(sum_task).await?;
    println!("Submitted sum task: {}", sum_task_id);

    let avg_task = TaskDefinition::new("average_data", "data_processing")
        .with_payload(
            "operation",
            serde_json::Value::String("average".to_string()),
        )
        .with_payload("data", serde_json::Value::Array(data_array))
        .with_dependencies(vec![sum_task_id.clone()]);

    let avg_task_id = taskflow.submit_task(avg_task).await?;
    println!("Submitted average task (depends on sum): {}", avg_task_id);

    let taskflow_clone = std::sync::Arc::new(taskflow);
    let taskflow_for_execution = taskflow_clone.clone();

    let execution_handle = tokio::spawn(async move {
        if let Err(e) = taskflow_for_execution.start().await {
            eprintln!("TaskFlow execution failed: {}", e);
        }
    });

    tokio::time::sleep(std::time::Duration::from_secs(1)).await;

    loop {
        let metrics = taskflow_clone.get_task_metrics().await?;
        println!(
            "Task metrics: pending={}, running={}, completed={}, failed={}",
            metrics.pending, metrics.running, metrics.completed, metrics.failed
        );

        if metrics.pending == 0 && metrics.running == 0 {
            break;
        }

        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }

    println!("\nAll tasks completed! Results:");

    let tasks = taskflow_clone.list_tasks(None).await?;
    for task in tasks {
        println!(
            "\nTask: {} ({})",
            task.definition.name, task.definition.task_type
        );
        println!("  Status: {:?}", task.status);
        if let Some(result) = &task.result {
            if result.success {
                println!(
                    "  Result: {}",
                    result.output.as_ref().unwrap_or(&"No output".to_string())
                );
                println!("  Execution time: {}ms", result.execution_time_ms);
                if !result.metadata.is_empty() {
                    println!("  Metadata: {:?}", result.metadata);
                }
            } else {
                println!(
                    "  Error: {}",
                    result
                        .error
                        .as_ref()
                        .unwrap_or(&"Unknown error".to_string())
                );
            }
        }
    }

    let final_metrics = taskflow_clone.get_task_metrics().await?;
    println!("\nFinal metrics:");
    println!("  Total tasks: {}", final_metrics.total);
    println!(
        "  Success rate: {:.1}%",
        final_metrics.success_rate() * 100.0
    );

    taskflow_clone.shutdown().await?;
    execution_handle.abort();

    Ok(())
}

pub fn with_tags(self, tags: Vec<String>) -> Self

pub fn schedule_at(self, scheduled_at: DateTime<Utc>) -> Self

Trait Implementations

impl Clone for TaskDefinition

fn clone(&self) -> TaskDefinition

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TaskDefinition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskDefinition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TaskDefinition

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.