init commit

src/uptime_service.rs

@@ -0,0 +1,232 @@
+use std::collections::HashMap;
+use tokio::time::{sleep};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration};
+use chrono::{Datelike, NaiveDate};
+use std::time::{SystemTime, UNIX_EPOCH};
+use anyhow::Context;
+use anyhow::{anyhow};
+use log::*;
+
+#[macro_use]
+use dotenv::dotenv;
+use std::env;
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum UptimeType {
+    Provider,
+    Service,
+    Datacenter,
+    Unknown
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum UptimeStatus {
+    Up,
+    Down,
+    Maintenance,
+    Unknown
+}
+
+#[derive(Debug, Clone)]
+pub struct Uptime {
+    pub name: String,
+    pub uptime: String,
+    pub response_time: String,
+    pub status: UptimeStatus,
+    pub uptime_type: UptimeType, 
+    pub url: String
+}
+
+#[derive(Debug, Clone)]
+pub struct UptimeServiceState {
+    uptimes: Vec<Uptime>,
+    last_updated: SystemTime
+}
+
+#[derive(Debug, Clone)]
+pub struct UptimeService {
+    state: Arc<Mutex<UptimeServiceState>>
+}
+
+impl UptimeService {
+    const UPDATE_SECONDS: u64 = 300;
+
+    pub fn new() -> Self {
+        let init_state = Arc::new(Mutex::new(
+                UptimeServiceState { uptimes: vec![], last_updated: UNIX_EPOCH }
+        ));
+        Self { state: init_state }
+    }
+
+    pub fn start(&self) {
+        info!("Starting UptimeService");
+        let cloned_state = Arc::clone(&self.state);
+        tokio::spawn(async move {
+                loop {
+                    let clonedx_state = Arc::clone(&cloned_state);
+                    let res = Self::update_data(clonedx_state).await;
+                    match res {
+                        Err(err) => {
+                            error!("{}", err);
+                        },
+                        _ => {}
+                    }
+                    sleep(tokio::time::Duration::from_secs(Self::UPDATE_SECONDS)).await; 
+                }
+            });
+    }
+
+    pub fn get_data(&self) -> Vec<Uptime> {
+        let state = self.state.lock().unwrap();
+        let uptimes = state.uptimes.clone();
+        return uptimes;
+    }
+
+    pub fn get_last_updated(&self) -> SystemTime {
+        let state = self.state.lock().unwrap();
+        let lu = state.last_updated.clone();
+        return lu;
+    }
+
+    async fn update_data(arc_state: Arc<Mutex<UptimeServiceState>>) -> ::anyhow::Result<()> {
+
+        debug!("Starting data update for UptimeService");
+
+        let mut request_vars = HashMap::new();
+        let api_key = env::var("UPTIMEROBOT_API_KEY")?;
+        request_vars.insert("api_key", api_key.as_str());
+        request_vars.insert("all_time_uptime_ratio", "1");
+        let now = SystemTime::now();
+        //let thirty_days_ago = now - Duration::from_secs(30 * 24 * 3600);
+
+        let current_year = chrono::Utc::today().year();
+        let january_1st = NaiveDate::from_ymd(current_year, 1, 1).and_hms(0, 0, 0);
+        let duration = january_1st.signed_duration_since(NaiveDate::from_ymd(1970, 1, 1).and_hms(0, 0, 0));
+        let year_start = UNIX_EPOCH + Duration::from_secs(duration.num_seconds() as u64);
+       
+        //let ranges = &format!(
+        //    "{}_{}-{}_{}",
+        //    thirty_days_ago.duration_since(SystemTime::UNIX_EPOCH)?.as_secs(),
+        //    now.duration_since(SystemTime::UNIX_EPOCH)?.as_secs(),
+        //    year_start.duration_since(SystemTime::UNIX_EPOCH)?.as_secs(),
+        //    now.duration_since(SystemTime::UNIX_EPOCH)?.as_secs(),
+        //);
+        let ranges = &format!(
+            "{}_{}",
+            year_start.duration_since(SystemTime::UNIX_EPOCH)?.as_secs(),
+            now.duration_since(SystemTime::UNIX_EPOCH)?.as_secs(),
+        );
+        request_vars.insert("custom_uptime_ranges", ranges);
+        request_vars.insert("response_times_average", "1440");
+        request_vars.insert("response_times", "1");
+
+        let client = reqwest::Client::new();
+        let res = client.post("https://api.uptimerobot.com/v2/getMonitors")
+            .form(&request_vars)
+            .send()
+            .await?;
+
+        let resp = res.json::<serde_json::Value>()
+        .await?;
+
+        let monitors = resp.get("monitors")
+                            .context("Response did not have a monitors subobject")?
+                            .as_array()
+                            .context("Monitors subobject was not an array")?;
+
+
+        let mut state =  match arc_state.lock(){
+            Ok(val) => val,
+            Err(_) => {return Err(anyhow!("Could not lock shared state"));}
+        };
+        state.uptimes.clear();
+        for monitor in monitors {
+            let monitor_fqn = monitor.get("friendly_name")
+                                    .context("Monitor did not have property 'friendly_name'")?;
+            
+            debug!("Monitor '{}' processing", monitor_fqn);
+
+            let split_str: Vec<&str> = monitor_fqn.as_str()
+                                        .context("Expected 'friendly_name' to be a string")?
+                                        .split(".").collect();
+            if split_str.len() != 2 {
+                debug!("Monitor '{}' excluded due to bad format", monitor_fqn);
+                continue;
+            }
+
+            let monitor_nt = String::from(*split_str.get(0).context("Expected name to have first part")?);
+            let monitor_name = String::from(*split_str.get(1).context("Expected name to have second part")?);
+            let monitor_type = match monitor_nt.as_str() {
+                "datacenter" => UptimeType::Datacenter,
+                "service" => UptimeType::Service,
+                "competitor" => UptimeType::Provider,
+                _ => UptimeType::Unknown
+            };
+
+
+            if monitor_type == UptimeType::Unknown {
+                debug!("Monitor '{}' excluded due to unknown type", monitor_fqn);
+                continue;
+            }
+
+            let monitor_status_num =  monitor.get("status")
+                                    .context("Expected monitor to have 'status' property")?
+                                    .as_u64()
+                                    .context("Expected 'status' property to be u64")?;
+
+            let monitor_status = match monitor_status_num {
+                0 => UptimeStatus::Maintenance,
+                1 | 8 | 9 => UptimeStatus::Down,
+                2 => UptimeStatus::Up,
+                _ => UptimeStatus::Unknown
+            };
+
+            if monitor_status == UptimeStatus::Unknown {
+                debug!("Monitor '{}' excluded due to unknown status (status was {})", monitor_fqn, monitor_status_num);
+                continue;
+            }
+
+            let monitor_rt_val = monitor.get("average_response_time")
+                                        .context("Expected monitor to have property 'average_response_time'")?;
+
+
+            // Because UptimeRobot has the world's worst API ever
+            // and decided that it's okay to return multiple datatypes 
+            // for one property based on how they're feeling
+            let monitor_rt = match monitor_rt_val.as_str() {
+                Some(string) => format!("{}ms", string),
+                _ => format!("N/A")
+            };
+
+            let monitor_uptime = format!("{}%", 
+                                        monitor.get("custom_uptime_ranges")
+                                        .context("Expected monitor to have property 'custom_uptime_ranges'")?
+                                        .as_str()
+                                        .context("Expected 'custom_uptime_ranges' to be String")?
+                                        );
+
+            let monitor_url =  String::from(monitor.get("url")
+                                        .context("Expected monitor to have property 'url'")?
+                                        .as_str()
+                                        .context("Expected 'url' to be String")?);
+
+;
+
+            state.uptimes.push(
+                    Uptime {
+                        name: monitor_name,
+                        uptime: monitor_uptime,
+                        response_time: monitor_rt,
+                        status: monitor_status,
+                        uptime_type: monitor_type,
+                        url: monitor_url
+                    }
+                );
+        }
+
+        state.last_updated = SystemTime::now();
+
+        Ok(())
+    }
+}