hellcheck 0.1.2

HTTP health checker
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use hyper::rt::{Future, Stream};
use hyper::Client;
use hyper_tls::HttpsConnector;

use std::sync::mpsc;

use crate::config::{BasicAuth, CheckerConfig, FileConfig};
use crate::reactor::{State, StateMessage};

type HttpsClient = hyper::Client<hyper_tls::HttpsConnector<hyper::client::connect::HttpConnector>>;

pub fn run(config: FileConfig, sender: mpsc::Sender<StateMessage>) {
    let check_runner = CheckRunner { config, sender };
    let checkers_futures = check_runner
        .config
        .checkers
        .iter()
        .map(|c| check_runner.build_future(c));
    let f = futures::future::select_all(checkers_futures);

    let mut core = tokio_core::reactor::Core::new().unwrap();

    // Run core forever
    let res = core.run(f);

    match res {
        Ok(_) => {}
        Err(_) => {
            eprintln!("ERROR: looks likes hellcheck crashed");
            std::process::exit(1);
        }
    }
}

struct CheckRunner {
    config: FileConfig,
    sender: mpsc::Sender<StateMessage>,
}

impl CheckRunner {
    fn build_future<'a>(
        &'a self,
        service: &'a CheckerConfig,
    ) -> Box<Future<Item = (), Error = tokio_timer::Error> + 'a> {
        let stream = tokio_timer::Interval::new_interval(service.interval);
        let client = build_client();

        let id = service.id.clone();

        let f = stream.for_each(move |_| {
            let checker_id = id.clone();

            let req = build_request(&service);

            client.request(req).then(move |r| {
                let state = match r {
                    Ok(resp) => {
                        if resp.status() == 200 {
                            State::Up
                        } else {
                            State::Down
                        }
                    }
                    Err(_err) => State::Down,
                };
                let msg = StateMessage {
                    checker_id: checker_id.clone(),
                    state,
                };
                self.sender.send(msg).unwrap();

                Ok(())
            })
        });
        Box::new(f)
    }
}

fn build_request(service: &CheckerConfig) -> hyper::Request<hyper::Body> {
    let mut builder = hyper::Request::get(service.url.clone());

    if let Some(ref basic_auth) = service.basic_auth {
        let authorization_header_value = build_authorization_header_value(basic_auth);
        builder.header(hyper::header::AUTHORIZATION, authorization_header_value);
    }

    builder.body(hyper::Body::empty()).unwrap()
}

fn build_authorization_header_value(auth: &BasicAuth) -> hyper::header::HeaderValue {
    let credentials = format!("{}:{}", auth.username, auth.password);
    let encoded_credentials = base64::encode(&credentials);
    let value = format!("Basic {}", encoded_credentials);
    hyper::header::HeaderValue::from_str(&value).unwrap()
}

fn build_client() -> HttpsClient {
    let https = HttpsConnector::new(1).expect("TLS initialization failed");
    Client::builder().build::<_, hyper::Body>(https)
}