config/endstat_conf.example.ron

@@ -35,8 +35,7 @@
       endpoints:[
         (label: "The code doesn't match!", endpoint: "http://example.com/", code: 204),
         (label: "The body doesn't match!", endpoint: "http://example.com/", body: "asdf"),
-        (label: "Slow reponse time", endpoint: "http://slowwly.robertomurray.co.uk/delay/2000/url/", max_rtt: 1337),
+        (label: "Slow reponse time", endpoint: "http://slowwly.robertomurray.co.uk/delay/2000/url/"),
-        (label: "Plethora of issues!", endpoint: "http://slowwly.robertomurray.co.uk/delay/1000/url/", body: "asdf", code: 418, max_rtt: 50),
         (label: "Here's an error:", endpoint: "https://some-invalid-website.arpa")
       ]
     ),

src/config.rs

@@ -9,7 +9,6 @@ pub struct EndpointConfig {
     pub body: Option<String>,
     pub body_hash: Option<String>,
     pub follow_redirects: Option<bool>,
-    pub max_rtt: Option<i64>,
     pub should_err: Option<bool>,
 }
 

src/handlers.rs

@@ -1,4 +1,4 @@
-use crate::{config::*, updater::update_status, State};
+use crate::{config::*, State};
 use actix_web::{
     error::ErrorInternalServerError, web::Data, Error as WebError, HttpResponse,
     Result as WebResult,
@@ -63,34 +63,6 @@ pub struct QueryResults {
     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();

src/main.rs

@@ -19,6 +19,7 @@ mod updater;
 use self::{config::*, handlers::*, updater::*};
 use actix::System;
 use actix_web::{middleware::Logger, web::resource, App, HttpServer};
+use chrono::prelude::*;
 use ron::de::from_str;
 use std::{
     env::var,
@@ -34,18 +35,24 @@ use tokio::{
 pub type State = Arc<RwLock<QueryResults>>;
 
 fn main() {
-    System::run(|| {
+    System::run(move || {
         let conf_file_loc =
             var("ENDSTAT_CONF").unwrap_or_else(|_| String::from("./config/endstat_conf.ron"));
         let config = from_str::<Config>(
             &read_to_string(&conf_file_loc).expect(&format!("finding {}", conf_file_loc)),
         )
         .unwrap();
-        let bind_addr = &config.bind_address;
+        let bind_addr = config.bind_address.clone();
         std::env::set_var("RUST_LOG", "actix_web=info");
         env_logger::init();
 
-        let state = Arc::new(RwLock::new(QueryResults::new(config.clone())));
+        let state: State = Arc::new(RwLock::new(QueryResults {
+            timestamp: Utc::now(),
+            timestamp_str: Utc::now().format("%Y-%m-%d %H:%M:%S").to_string(),
+            refresh_time: config.refresh_time.clone(),
+            config: config.clone(),
+            groups: update_status(&config),
+        }));
 
         let clone_state = Arc::clone(&state);
 

src/updater.rs

@@ -13,8 +13,10 @@ use std::time::Duration;
 
 pub fn update_state(state: State) {
     let new_statuses = { Some(update_status(&state.read().unwrap().config)) };
-    let mut state = state.try_write().expect("Could not unlock");
+    let mut write_state = state.try_write().expect("Could not unlock");
-    state.update(new_statuses.unwrap());
+    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> {
@@ -68,7 +70,7 @@ fn get_result(
                 error = append_err_msg(
                     error,
                     format!(
-                        "Status code mismatch: {} != {}",
+                        "Status code mismatch: {} != {}.",
                         res.status().as_u16(),
                         code
                     ),
@@ -84,17 +86,12 @@ fn get_result(
             } else if !body.is_empty() && res_body != body {
                 error = append_err_msg(
                     error,
-                    format!("Body mismatch: {} != {}", res_body.len(), body.len()),
+                    format!("Body mismatch: {} != {}.", res_body.len(), body.len()),
                 );
             }
 
-            if let Some(max_rtt) = endpoint.max_rtt {
+            if rtt.num_seconds() >= 2 {
-                if rtt.num_milliseconds() > max_rtt {
+                error = append_err_msg(error, format!("RTT too long: {}", rtt_string));
-                    error = append_err_msg(
-                        error,
-                        format!("RTT too long: {} > {}s", rtt_string, max_rtt as f64 / 1000.),
-                    );
-                }
             }
 
             if error.is_some() {
@@ -126,8 +123,12 @@ fn get_url(base: &Option<String>, path: &String, port: Option<u16>) -> Result<St
 }
 
 fn append_err_msg(optional: Option<String>, to_append: String) -> Option<String> {
+    // Turns out Rust doesn't recognize that only one of the FnOnce occurs, so
+    // as a result both closures want ownership of to_append
+    // Some(optional.map_or_else(|| to_append, |msg| format!("{} {}", msg, to_append)))
+
     Some(match optional {
-        Some(e) => format!("{}\n{}", e, to_append),
+        Some(e) => format!("{} {}", e, to_append),
         None => to_append,
     })
 }