rucron 0.1.6

A Rust Job Scheduling Crate.
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

extern crate rucron;

use redis::{Client, Commands};
use rucron::{
    execute, get_metric_with_name, sleep, ArgStorage, EmptyTask, Locker, RucronError, Scheduler,
};
use std::{error::Error, sync::Arc};

/// Distributed locks with redis
#[derive(Clone)]
struct RedisLocker {
    client: Client,
}

impl RedisLocker {
    fn new() -> Self {
        Self {
            client: redis::Client::open("redis://127.0.0.1/").unwrap(),
        }
    }
}

impl Locker for RedisLocker {
    fn lock(&self, key: &str, _storage: Arc<ArgStorage>) -> Result<bool, RucronError> {
        let mut con = self.client.get_connection().unwrap();
        match con.set_nx::<&str, i8, bool>(key, 1) {
            Err(e) => Err(RucronError::LockError(e.to_string())),
            Ok(b) => Ok(b),
        }
    }
    fn unlock(&self, key: &str, _storage: Arc<ArgStorage>) -> Result<bool, RucronError> {
        let mut con = self.client.get_connection().unwrap();
        match con.del::<&str, bool>(key) {
            Err(e) => Err(RucronError::UnLockError(e.to_string())),
            Ok(b) => Ok(b),
        }
    }
}

fn gen_int() -> u64 {
    fastrand::u64(8..14)
}

async fn a_job() -> Result<(), Box<dyn Error>> {
    let sec = gen_int();
    sleep(std::time::Duration::from_secs(sec as u64)).await;
    println!("end job!");
    Ok(())
}

async fn record_metric() -> Result<(), Box<dyn Error>> {
    let m = get_metric_with_name("a_job").unwrap();
    println!("{}", m);
    Ok(())
}

#[tokio::main]
async fn main() {
    let rl = RedisLocker::new();
    let mut sch = Scheduler::<EmptyTask, RedisLocker>::new(1, 10);
    sch.set_locker(rl);
    let sch = sch
        .every(15)
        .second()
        .immediately_run()
        .need_lock()
        .todo(execute(a_job))
        .await
        .every(5)
        .second()
        .todo(execute(record_metric))
        .await;
    sch.start().await;
}