nasu 0.1.0

Command-line utility which poll on remote addresses in order to perform status checks periodically
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 anyhow::Result;
use chrono::{DateTime, Utc};
use cron::Schedule;
use std::str::FromStr;
use tokio::sync::RwLock;

use crate::providers::http;
use crate::report::Report;
use crate::tasks::{Task, TaskType};

use super::perform::Perform;

pub struct Worker {
    perform: Box<dyn Perform + Sync + Send>,
    interval: Schedule,
    last_run_at: RwLock<Option<DateTime<Utc>>>,
}

impl Worker {
    /// Performs this Worker's task
    pub async fn perform_task(&self) -> Result<Report> {
        let report = self.perform.perform().await?;
        *self.last_run_at.write().await = Some(Utc::now());

        Ok(report)
    }

    /// Checks if the Worker must be executed or not based
    /// on the defined interval
    pub async fn must_run(&self) -> bool {
        if let Some(last_run_at) = *self.last_run_at.read().await {
            let now = Utc::now();
            let next_run_at = self.interval.after(&last_run_at).next().unwrap();

            if now > next_run_at {
                return true;
            }

            return false;
        }

        true
    }
}

impl From<Task> for Worker {
    fn from(t: Task) -> Self {
        match t.task_type {
            TaskType::Http => {
                let interval = Schedule::from_str(&t.task.interval)
                    .expect(&format!("Invalid chron expression: {}", t.task.interval));
                let http_provider = http::Provider::new(t).unwrap();

                Self {
                    perform: Box::new(http_provider),
                    interval,
                    last_run_at: RwLock::new(None),
                }
            }
        }
    }
}