endstat/src/updater.rs

use crate::{
    config::*,
    handlers::{EndpointStatus, StatusGroup},
    State,
};
use chrono::prelude::Utc;
use reqwest::{Client, RedirectPolicy, Url, UrlError};
use std::time::Duration;

pub fn update_state(state: State) {
    let new_statuses = { Some(update_status(&state.read().unwrap().config)) };
    let mut write_state = state.try_write().expect("Could not unlock");
    write_state.timestamp = Utc::now();
    write_state.timestamp_str = Utc::now().format("%Y-%m-%d %H:%M:%S").to_string();
    write_state.groups = new_statuses.unwrap();
}

pub fn update_status(config: &Config) -> Vec<StatusGroup> {
    let mut results: Vec<StatusGroup> = Vec::with_capacity(config.websites.len());

    for website_conf in &config.websites {
        let mut group = Vec::with_capacity(website_conf.endpoints.len());
        for endpoint in &website_conf.endpoints {
            let mut client_builder = Client::builder().timeout(Some(Duration::from_secs(5)));

            if let Some(false) = endpoint.follow_redirects {
                client_builder = client_builder.redirect(RedirectPolicy::none());
            }

            let client = client_builder.build().unwrap();
            group.push(get_result(website_conf, &client, endpoint));
        }

        results.push(StatusGroup {
            label: website_conf.label.clone(),
            endpoints: group,
        });
    }

    results
}

fn get_result(
    website_conf: &WebsiteConfig,
    client: &Client,
    endpoint: &EndpointConfig,
) -> EndpointStatus {
    let (label, path, port, code, body) = get_endpoint_info(endpoint.clone());
    let url = get_url(&website_conf.base, &path, port).expect("reading config");
    let ping_result = client.get(&url).send();

    match ping_result {
        Ok(mut res) => {
            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;
            let mut error = None;

            if !does_code_match {
                error = Some(format!(
                    "Status code mismatch: {} != {}.",
                    res.status().as_u16(),
                    code
                ));
            }

            if !does_body_match {
                error = Some(if let Some(msg) = error {
                    format!(
                        "{} Body mismatch: {} != {}.",
                        msg,
                        res_body.len(),
                        body.len()
                    )
                } else {
                    format!("Body mismatch: {} != {}.", res_body.len(), body.len())
                });
            }

            EndpointStatus {
                status: if error.is_some() { 1 } else { 0 },
                location: url,
                endpoint: label,
                error,
            }
        }
        Err(e) => {
            if let Some(true) = endpoint.should_err {
                EndpointStatus {
                    status: 0,
                    location: url,
                    endpoint: label,
                    error: None,
                }
            } else {
                EndpointStatus {
                    status: 2,
                    location: url,
                    endpoint: label,
                    error: Some(format!("{}", e)),
                }
            }
        }
    }
}

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