tasklet 0.1.1

A task scheduling library.
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

extern crate chrono;
extern crate cron;
use crate::task::Task;
use chrono::prelude::*;
use chrono::DateTime;
use cron::Schedule;
use log::debug;

/// Task generation structure.
///
/// It is run in the given interval, and if a new task is generated,
/// then it is appended in the list of tasks to be executed.
pub struct TaskGenerator<'a, T>
where
    T: TimeZone,
{
    /// The discovery function, used to retrieve new tasks.
    discovery_function: Box<dyn (FnMut() -> Option<Task<'a, T>>) + 'a>,
    /// The execution schedule.
    schedule: Schedule,
    /// The task generator's timezone.
    timezone: T,
    /// The next execution time.
    pub(crate) next_exec: DateTime<T>,
}

/// Implementation of `TaskGenerator`.
impl<'a, T> TaskGenerator<'a, T>
where
    T: TimeZone + Clone,
{
    /// Create a new `TaskGenerator` instance.
    ///
    /// # Arguments
    ///
    /// * expression    - A valid cron expression.
    /// * function      - The discovery function.
    /// * timezone      - The generator's timezone.
    ///
    /// # Examples
    ///
    /// ```
    /// # use tasklet::{TaskGenerator, Task};
    /// // Create a `TaskGenerator` instance.
    /// // It will be executed at the first second of each minute.
    /// let _task_gen = TaskGenerator::new("1 * * * * * *", chrono::Local, || Some(Task::new("* * * * * * *", None, None, chrono::Local)));
    /// ```
    pub fn new<F>(expression: &str, timezone: T, function: F) -> TaskGenerator<'a, T>
    where
        F: (FnMut() -> Option<Task<'a, T>>) + 'a,
    {
        let schedule: Schedule = expression.parse().unwrap();

        TaskGenerator {
            discovery_function: Box::new(function),
            schedule: expression.parse().unwrap(),
            timezone: timezone.clone(),
            next_exec: schedule.upcoming(timezone).next().unwrap(),
        }
    }

    /// Run the discovery function and reschedule the generation function.
    pub(crate) fn run(&mut self) -> Option<Task<'a, T>> {
        debug!("Executing discovery function.");
        self.next_exec = self
            .schedule
            .upcoming(self.timezone.clone())
            .next()
            .unwrap();
        match (self.discovery_function)() {
            Some(t) => {
                // A task was generated and must be returned.
                debug!("A task was found, adding it to the queue...");
                return Some(t);
            }
            None => {
                debug!("No task was generated.");
                None
            }
        }
    }
}

/// Module tests.
#[cfg(test)]
mod test {
    use super::*;
    use chrono::Local;

    /// Test the normal flow of a task generation instance.
    ///
    /// In this case the function is returning a new `Task`.
    #[test]
    fn test_task_generation_with_result() {
        // Create a task generation instance.
        let mut task_gen = TaskGenerator::new("* * * * * * *", Local, || {
            Some(Task::new("* * * * * * *", None, Some(1), Local))
        });
        assert!(!task_gen.run().is_none());
    }

    /// Test the normal flow of a task generation instance.
    ///
    /// In this case no new `Task` instance is generated.
    #[test]
    fn test_task_generation_without_result() {
        // Create a task generation instance.
        let mut task_gen = TaskGenerator::new("* * * * * * *", Local, || None);
        assert!(task_gen.run().is_none());
    }
}