cloudiful-scheduler 0.4.1

Single-job async scheduling library for background work with optional Valkey-backed state.
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

use crate::model::RunSkipReason;
use chrono::{DateTime, Utc};
#[cfg(feature = "valkey-store")]
use serde::{Deserialize, Serialize};
use std::collections::VecDeque;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RunStatus {
    Success,
    Failed,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RunRecord {
    pub scheduled_at: DateTime<Utc>,
    pub started_at: DateTime<Utc>,
    pub finished_at: DateTime<Utc>,
    pub catch_up: bool,
    pub status: RunStatus,
    pub error: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "valkey-store", derive(Serialize, Deserialize))]
pub struct JobState {
    pub job_id: String,
    pub trigger_count: u32,
    pub last_run_at: Option<DateTime<Utc>>,
    pub last_success_at: Option<DateTime<Utc>>,
    pub next_run_at: Option<DateTime<Utc>>,
    pub last_error: Option<String>,
}

impl JobState {
    pub fn new(job_id: impl Into<String>, next_run_at: Option<DateTime<Utc>>) -> Self {
        Self {
            job_id: job_id.into(),
            trigger_count: 0,
            last_run_at: None,
            last_success_at: None,
            next_run_at,
            last_error: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SchedulerReport {
    pub job_id: String,
    pub state: JobState,
    pub history: Vec<RunRecord>,
    pub last_skip_reason: Option<RunSkipReason>,
}

pub(crate) fn push_history(
    history: &mut VecDeque<RunRecord>,
    record: RunRecord,
    history_limit: usize,
) {
    if history_limit == 0 {
        return;
    }

    history.push_back(record);
    while history.len() > history_limit {
        history.pop_front();
    }
}

#[cfg(test)]
mod tests {
    use super::{RunRecord, RunStatus, push_history};
    use chrono::Utc;
    use std::collections::VecDeque;

    fn record(second: i64) -> RunRecord {
        let instant = Utc::now() + chrono::TimeDelta::seconds(second);
        RunRecord {
            scheduled_at: instant,
            started_at: instant,
            finished_at: instant,
            catch_up: false,
            status: RunStatus::Success,
            error: None,
        }
    }

    #[test]
    fn push_history_keeps_latest_records_within_limit() {
        let base = Utc::now();
        let mut history = VecDeque::new();
        push_history(&mut history, record_at(base, 1), 2);
        push_history(&mut history, record_at(base, 2), 2);
        push_history(&mut history, record_at(base, 3), 2);

        assert_eq!(history.len(), 2);
        assert_eq!(
            history.front().unwrap().scheduled_at,
            record_at(base, 2).scheduled_at
        );
        assert_eq!(
            history.back().unwrap().scheduled_at,
            record_at(base, 3).scheduled_at
        );
    }

    #[test]
    fn push_history_ignores_records_when_limit_is_zero() {
        let mut history = VecDeque::new();
        push_history(&mut history, record(1), 0);

        assert!(history.is_empty());
    }

    fn record_at(base: chrono::DateTime<Utc>, second: i64) -> RunRecord {
        let instant = base + chrono::TimeDelta::seconds(second);
        RunRecord {
            scheduled_at: instant,
            started_at: instant,
            finished_at: instant,
            catch_up: false,
            status: RunStatus::Success,
            error: None,
        }
    }
}