endstat/src/handlers.rs

use crate::{config::*, updater::update_status, State};
use actix_web::{
    error::ErrorInternalServerError, web::Data, Error as WebError, HttpResponse,
    Result as WebResult,
};
use chrono::prelude::*;
use serde::Serialize;
use tera::{Context, Tera};

#[derive(Clone, Serialize, Default, Debug)]
pub struct EndpointStatus {
    pub status: u8,
    pub location: String,
    pub endpoint: String,
    pub rtt: Option<String>,
    pub error: Option<String>,
}

impl EndpointStatus {
    pub fn ok(location: String, endpoint: String, rtt: String) -> Self {
        EndpointStatus {
            status: 0,
            location,
            endpoint,
            rtt: Some(rtt),
            error: None,
        }
    }

    pub fn warn(location: String, endpoint: String, rtt: String, error: Option<String>) -> Self {
        EndpointStatus {
            status: 1,
            location,
            endpoint,
            rtt: Some(rtt),
            error,
        }
    }

    pub fn error(location: String, endpoint: String, error: Option<String>) -> Self {
        EndpointStatus {
            status: 2,
            location,
            endpoint,
            rtt: None,
            error,
        }
    }
}

#[derive(Serialize, Debug)]
pub struct StatusGroup {
    pub label: String,
    pub endpoints: Vec<EndpointStatus>,
}

#[derive(Serialize, Debug)]
pub struct QueryResults {
    pub timestamp: DateTime<Utc>,
    pub timestamp_str: String,
    pub refresh_time: u64,
    pub config: Config,
    pub groups: Vec<StatusGroup>,
}

impl QueryResults {
    pub fn new(config: Config) -> Self {
        let time = Utc::now();
        QueryResults {
            timestamp: time,
            timestamp_str: Self::format_timestamp(time),
            refresh_time: config.refresh_time,
            config: config.clone(),
            groups: update_status(&config),
        }
    }

    pub fn update(&mut self, updated_groups: Vec<StatusGroup>) {
        self.update_timestamp();
        self.groups = updated_groups;
    }

    fn update_timestamp(&mut self) {
        let current_time = Utc::now();
        self.timestamp = current_time;
        self.timestamp_str = Self::format_timestamp(current_time);
    }

    fn format_timestamp(timestamp: DateTime<Utc>) -> String {
        timestamp.format("%Y-%m-%d %H:%M:%S").to_string()
    }
}

pub fn index(tmpl: Data<Tera>, state: Data<State>) -> WebResult<HttpResponse, WebError> {
    let state = state.read().unwrap();
    let mut ctx = Context::new();
    ctx.insert("results", &*state);
    let s = tmpl.render("index.html", &ctx).map_err(|e| {
        println!("{:?}", e);
        ErrorInternalServerError("Template error")
    })?;
    Ok(HttpResponse::Ok().content_type("text/html").body(s))
}

pub fn json_endpoint(state: Data<State>) -> HttpResponse {
    let state = state.read().unwrap();
    HttpResponse::Ok().json(&*state.groups)
}