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

use std::sync::Arc;
use std::time::Duration;
use tokio::sync::mpsc::Sender;
use tokio::time::interval;

use super::worker::Worker;
use crate::report::Report;

pub struct Squad {
    tx: Sender<Report>,
    workers: Vec<Worker>,
}

impl Squad {
    pub fn new(workers: Vec<Worker>, tx: Sender<Report>) -> Self {
        Self { tx, workers }
    }

    pub async fn start(self) {
        let workers = Arc::new(
            self.workers
                .into_iter()
                .map(|w| Arc::new(w))
                .collect::<Vec<Arc<Worker>>>(),
        );
        let tx = Arc::new(self.tx);
        let mut interval = interval(Duration::from_secs(5));

        loop {
            interval.tick().await;
            let workers = Arc::clone(&workers);
            let tx = Arc::clone(&tx);

            for worker in workers.iter() {
                if worker.must_run().await {
                    let worker = Arc::clone(worker);
                    let tx = Arc::clone(&tx);

                    tokio::spawn(async move {
                        match worker.perform_task().await {
                            Ok(report) => {
                                // worker.tick();
                                tx.send(report).await.unwrap();
                            }
                            Err(e) => eprintln!("{:?}", e),
                        }
                    });
                }
            }
        }
    }
}