cano 0.13.2

High-performance orchestration engine for building resilient, self-healing systems in Rust. Uses Finite State Machines (FSM) for strict, type-safe transitions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#![cfg(feature = "scheduler")]
//! # Duration-based Scheduling Example
//!
//! This example demonstrates how to use the Scheduler with custom Duration intervals:
//! 1. **Short Task**: Runs every 2 seconds with a quick execution
//! 2. **Medium Task**: Runs every 5 seconds with moderate processing
//! 3. **Long Task**: Runs every 10 seconds with extended execution time
//!
//! The example showcases:
//! - Duration-based scheduling using `scheduler.every()`
//! - Multiple workflows with different intervals
//! - Concurrent execution of scheduled tasks
//! - Precise timing control with std::time::Duration
//!
//! Run with:
//! ```bash
//! cargo run --example scheduler_duration_scheduling
//! ```

use cano::prelude::*;
use tokio::time::Duration;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum TaskState {
    Start,
    Complete,
}

#[derive(Clone)]
struct DailyTask;

#[task(state = TaskState)]
impl DailyTask {
    async fn run_bare(&self) -> Result<TaskResult<TaskState>, CanoError> {
        println!(
            "Daily task executed at {}",
            chrono::Utc::now().format("%H:%M:%S")
        );
        Ok(TaskResult::Single(TaskState::Complete))
    }
}

#[derive(Clone)]
struct HourlyTask;

#[task(state = TaskState)]
impl HourlyTask {
    async fn run_bare(&self) -> Result<TaskResult<TaskState>, CanoError> {
        println!(
            "Hourly task executed at {}",
            chrono::Utc::now().format("%H:%M:%S")
        );
        Ok(TaskResult::Single(TaskState::Complete))
    }
}

#[derive(Clone)]
struct FrequentTask;

#[task(state = TaskState)]
impl FrequentTask {
    async fn run_bare(&self) -> Result<TaskResult<TaskState>, CanoError> {
        println!(
            "Frequent task executed at {}",
            chrono::Utc::now().format("%H:%M:%S")
        );
        Ok(TaskResult::Single(TaskState::Complete))
    }
}

#[tokio::main]
async fn main() -> CanoResult<()> {
    println!("Duration-Based Scheduling Example");
    println!("====================================");

    let mut scheduler = Scheduler::new();
    let store = MemoryStore::new();

    // Create workflows with different durations
    let daily_flow = Workflow::new(Resources::new().insert("store", store.clone()))
        .register(TaskState::Start, DailyTask)
        .add_exit_state(TaskState::Complete);

    let hourly_flow = Workflow::new(Resources::new().insert("store", store.clone()))
        .register(TaskState::Start, HourlyTask)
        .add_exit_state(TaskState::Complete);

    let frequent_flow = Workflow::new(Resources::new().insert("store", store.clone()))
        .register(TaskState::Start, FrequentTask)
        .add_exit_state(TaskState::Complete);

    // Schedule workflows with different durations
    scheduler.every(
        "daily_task",
        daily_flow,
        TaskState::Start,
        Duration::from_secs(4),
    )?; // Simulated daily (every 4s)
    scheduler.every(
        "hourly_task",
        hourly_flow,
        TaskState::Start,
        Duration::from_secs(2),
    )?; // Simulated hourly (every 2s)
    scheduler.every(
        "frequent_task",
        frequent_flow,
        TaskState::Start,
        Duration::from_secs(1),
    )?; // Frequent (every 1s)

    println!("Scheduled workflows:");
    println!("  Daily task: Every 4 seconds (simulated)");
    println!("  Hourly task: Every 2 seconds (simulated)");
    println!("  Frequent task: Every 1 second");
    println!();

    // Start consumes the builder and returns a live handle.
    let running = scheduler.start().await?;

    println!("Scheduler started! Running for 10 seconds...");
    tokio::time::sleep(Duration::from_secs(10)).await;

    running.stop().await?;
    println!("Scheduler stopped gracefully");

    Ok(())
}