ocron 0.2.0

Cron implementation with an obvious configuration format
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

use crate::config::Task;
use chrono::prelude::*;
use std::cmp::Ordering;
use std::collections::BinaryHeap;
use std::sync::{Arc, Condvar, Mutex};

pub struct Queue {
    queue: Mutex<BinaryHeap<QueuedTask>>,
    condvar: Condvar,
}

#[derive(Clone)]
pub struct QueuedTask {
    pub time: NaiveDateTime,
    pub task: Arc<Task>,
}

impl PartialEq for QueuedTask {
    fn eq(&self, other: &Self) -> bool {
        NaiveDateTime::eq(&self.time, &other.time)
    }
}

impl Eq for QueuedTask {}

impl PartialOrd for QueuedTask {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(QueuedTask::cmp(self, other))
    }
}

impl Ord for QueuedTask {
    fn cmp(&self, other: &Self) -> Ordering {
        NaiveDateTime::cmp(&self.time, &other.time).reverse()
    }
}

impl Queue {
    pub fn new() -> Arc<Queue> {
        Arc::new(Queue {
            queue: Mutex::default(),
            condvar: Condvar::default(),
        })
    }

    pub fn notify_push(self: &Arc<Self>, time: NaiveDateTime, task: Arc<Task>) {
        eprintln!("[{}] next run {:}", &task.name, time.format("%Y-%m-%d %H:%M:%S"));
        self.queue.lock().unwrap().push(QueuedTask { time, task });
        self.condvar.notify_all();
    }

    pub fn wait_peek_time(self: &Arc<Self>) -> NaiveDateTime {
        let mut queue_lock = self.queue.lock().unwrap();
        while queue_lock.is_empty() {
            queue_lock = self.condvar.wait(queue_lock).unwrap();
        }
        queue_lock.peek().unwrap().time
    }

    pub fn try_pop(&self) -> Option<Arc<Task>> {
        self.queue
            .lock().unwrap()
            .pop()
            .map(|qt| qt.task.clone())
    }
}