periodically 0.2.0

A library for running tasks on a schedule
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

use super::Schedule;
use std::{str::FromStr, time::Duration};

/// Runs jobs periodically based on a [`CronSchedule`] from the [`cron`] crate.
pub struct CronSchedule {
    cron: cron::Schedule,
}

/// Schedule events according to a cron schedule.
impl CronSchedule {
    /// Creates a [`CronSchedule`] that always returns `period`.
    ///
    /// ```
    /// use periodically::{Schedule, CronSchedule};
    /// use std::time::Duration;
    ///
    /// let expression = "0 * * * * *";
    /// let periodic = CronSchedule::from_cron_str(expression).unwrap();
    /// # let periodic = Box::new(periodic) as Box<dyn Schedule<()>>;
    /// assert!(periodic.initial().unwrap() < Duration::from_secs(60));
    /// assert!(periodic.next(()).unwrap() < Duration::from_secs(60));
    /// ```
    pub fn from_cron_str(cron_str: impl AsRef<str>) -> Result<Self, cron::error::Error> {
        let cron = cron::Schedule::from_str(cron_str.as_ref())?;
        Ok(Self { cron })
    }
    /// Creates a [`CronSchedule`] that always returns `period`.
    ///
    /// ```
    /// use periodically::{Schedule, CronSchedule};
    /// use std::str::FromStr;
    /// use std::time::Duration;
    ///
    /// let expression = "0 * * * * *";
    /// let cron_sched = cron::Schedule::from_str(expression).unwrap();
    /// let periodic = CronSchedule::from_cron_schedule(cron_sched);
    /// # let periodic = Box::new(periodic) as Box<dyn Schedule<()>>;
    /// assert!(periodic.initial() < Some(Duration::from_secs(60)));
    /// assert!(periodic.next(()) < Some(Duration::from_secs(60)));
    /// ```

    pub fn from_cron_schedule(cron: cron::Schedule) -> Self {
        Self { cron }
    }

    fn calculate_next(&self) -> Option<Duration> {
        let dt = self.cron.upcoming(chrono::Utc).next()?;
        let now = chrono::Utc::now();
        let delta = dt.signed_duration_since(&now);
        Some(delta.to_std().unwrap_or(Duration::from_secs(0)))
    }
}

impl<T> Schedule<T> for CronSchedule {
    fn initial(&self) -> Option<Duration> {
        self.calculate_next()
    }

    fn next(&self, _: T) -> Option<Duration> {
        self.calculate_next()
    }
}