endstat/src/main.rs

extern crate actix;
extern crate actix_web;
extern crate reqwest;
extern crate ron;
extern crate serde;

use actix::System;
use actix_web::{
    http::{Method, StatusCode},
    server, App, HttpResponse, State,
};
use reqwest::{Client, Url, UrlError};
use ron::de::from_str;
use serde::Deserialize;
use std::{
    error::Error,
    fs::read_to_string,
    sync::{Arc, Mutex},
    time::{Duration, Instant},
};

#[derive(Deserialize, Debug, Clone)]
struct EndpointConf {
    label: Option<String>,
    endpoint: Option<String>,
    port: Option<u16>,
    code: Option<u16>,
    body: Option<String>,
}

#[derive(Deserialize, Debug, Clone)]
struct WebsiteConf {
    label: String,
    base: String,
    endpoints: Vec<EndpointConf>,
}

#[derive(Deserialize, Debug, Clone)]
struct Config {
    refresh_time: u64,
    websites: Vec<WebsiteConf>,
}

#[derive(Debug)]
struct Status {
    status: u8,
    location: String,
    domain: String,
    endpoint: String,
    error: Option<String>,
}

struct FetchResults {
    last_update: Instant,
    refresh_time: u64,
    config: Config,
    statuses: Vec<Status>,
}

type StatusState = Arc<Mutex<FetchResults>>;

fn index(state: State<StatusState>) -> HttpResponse {
    let mut state = state.lock().unwrap();
    let mut result = String::new();
    if Instant::now().duration_since(state.last_update) > Duration::from_secs(state.refresh_time) {
        result = format!(
            "it has been {:} seconds since last update, updating",
            Instant::now().duration_since(state.last_update).as_secs()
        );
        state.last_update = Instant::now();
        state.statuses = update_status(&state.config);
    }

    let result = format!("{}\n{:?}", result, state.statuses);
    HttpResponse::with_body(StatusCode::OK, result)
}

fn main() -> Result<(), Box<Error>> {
    let config = from_str::<Config>(&read_to_string("./endstat_conf.ron")?)?;

    println!("running server");
    let sys = System::new("status");

    let a: Arc<Mutex<FetchResults>> = Arc::from(Mutex::from(FetchResults {
        last_update: Instant::now(),
        refresh_time: config.refresh_time,
        config: config.clone(),
        statuses: update_status(&config),
    }));

    server::new(move || {
        App::with_state(a.clone()).resource("/", |r| r.method(Method::GET).with(index))
    })
    .bind("0.0.0.0:8080")?
    .start();

    sys.run();
    Ok(())
}

fn update_status(config: &Config) -> Vec<Status> {
    let client = Client::new();
    let mut results: Vec<Status> = vec![];

    for website_conf in &config.websites {
        for endpoint in &website_conf.endpoints {
            let (label, path, port, code, body) = get_endpoint_info(endpoint.clone());
            let url = get_url(&website_conf.base, &path, port).expect("reading config");
            if let Ok(mut res) = client.get(&url).send() {
                let res_body = res.text().expect("could not get body of request");
                let does_code_match = res.status() == code;
                let does_body_match = body.is_empty() || res_body == body;

                results.push(if !does_code_match {
                    Status {
                        status: 1,
                        location: url,
                        domain: website_conf.label.clone(),
                        endpoint: label,
                        error: Some(format!(
                            "Status code mismatch! {} != {}",
                            res.status().as_u16(),
                            code
                        )),
                    }
                } else if !does_body_match {
                    Status {
                        status: 2,
                        location: url,
                        domain: website_conf.label.clone(),
                        endpoint: label,
                        error: Some(format!("Body mismatch! {} != {}", res_body, body)),
                    }
                } else {
                    Status {
                        status: 0,
                        location: url,
                        domain: website_conf.label.clone(),
                        endpoint: label,
                        error: None,
                    }
                });
            }
        }
    }

    results
}

fn get_url(base: &String, path: &String, port: Option<u16>) -> Result<String, UrlError> {
    let mut url = Url::parse(base)?.join(path)?;
    if let Err(e) = url.set_port(port) {
        println!("{:?}", e);
    }
    Ok(url.into_string())
}

fn get_endpoint_info(endpoint: EndpointConf) -> (String, String, Option<u16>, u16, String) {
    let path = endpoint.endpoint.unwrap_or_default();
    let label = endpoint.label.unwrap_or_else(|| path.clone());
    let code = endpoint.code.unwrap_or_else(|| 200);
    let body = endpoint.body.unwrap_or_default();

    (label, path, endpoint.port, code, body)
}