cron_rs 0.1.6

A Cron Parser Library And Job Scheduler Written In Rust
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

use std::sync::mpsc::{self, Sender, Receiver};
use std::thread;

use error::Error;
use server::Server;
use output_chunk::Message;

pub trait OutputHandler {
    type Err;
    fn push(&self, Message) -> Result<(), Self::Err>;
}

pub struct OutputKeeper<'a> {
    server: &'a Server,

    pub tx: Sender<Message>,
    rx: Option<Receiver<Message>>,
}

impl<'a> OutputKeeper<'a> {
    pub fn new(srv: &'a Server) -> OutputKeeper {
        let (tx, rx) = mpsc::channel();

        let mut keeper = OutputKeeper {
            server: srv,
            rx: Some(rx),
            tx: tx,
        };

        keeper.start();
        keeper
    }

    fn start(&mut self) {
        let rx = self.rx.take().unwrap();

        thread::spawn(move || loop {
            match rx.recv() {
                Ok(msg) => {
                    println!("received message: {:?}", msg.body);
                    //TODO
                    //push message
                }
                Err(e) => {
                    println!("message keeper recv error: {:?}", e);
                }
            }
        });

        // do not join it
    }
}

impl<'a> OutputHandler for OutputKeeper<'a> {
    type Err = Error;

    fn push(&self, msg: Message) -> Result<(), Error> {
        //TODO
        Ok(())
    }
}