config/endstat_conf.example.ron

@@ -35,7 +35,6 @@
       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/"),
         (label: "Here's an error:", endpoint: "https://some-invalid-website.arpa")
       ]
     ),

config/templates/index.html

@@ -68,11 +68,10 @@
           <div class="info">
             <h3>{{ status.endpoint }}</h3>
             <div class="spacer"></div>
-            {% if status.status != 2 %}<p>{{ status.rtt }}</p>{% endif %}
+            <a href="{{ status.location }}" target="_blank">{{ status.location }}</a>
           </div>
-          <a href="{{ status.location }}" target="_blank">{{ status.location }}</a>
           {% if status.error %}<p class="error-msg">{{ status.error }}</p>{% endif %}
-          </main>
+        </main>
       </section>
       {% endfor -%}
       {% endfor -%}

src/handlers.rs

@@ -12,27 +12,24 @@ 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 {
+    pub fn ok(location: String, endpoint: 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 {
+    pub fn warn(location: String, endpoint: String, error: Option<String>) -> Self {
         EndpointStatus {
             status: 1,
             location,
             endpoint,
-            rtt: Some(rtt),
             error,
         }
     }
@@ -42,7 +39,6 @@ impl EndpointStatus {
             status: 2,
             location,
             endpoint,
-            rtt: None,
             error,
         }
     }

src/main.rs

@@ -1,5 +1,3 @@
-#![forbid(unsafe_code)]
-
 extern crate actix;
 extern crate actix_web;
 extern crate chrono;

src/updater.rs

@@ -3,7 +3,7 @@ use crate::{
     handlers::{EndpointStatus, StatusGroup},
     State,
 };
-use chrono::Utc;
+use chrono::prelude::Utc;
 use reqwest::{Client, RedirectPolicy, Url, UrlError};
 use ring::{
     digest::{digest, SHA256},
@@ -51,15 +51,7 @@ fn get_result(
 ) -> 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_start = Utc::now();
     let ping_result = client.get(&url).send();
-    let rtt = Utc::now() - ping_start;
-    let rtt_string = if rtt.num_seconds() > 0 {
-        format!("{}s", rtt.num_milliseconds() as f64 / 1000.)
-    } else {
-        format!("{}ms", rtt.num_milliseconds())
-    };
 
     match ping_result {
         Ok(mut res) => {
@@ -67,42 +59,45 @@ fn get_result(
             let mut error = None;
 
             if res.status() != code {
-                error = append_err_msg(
+                error = Some(format!(
-                    error,
+                    "Status code mismatch: {} != {}.",
-                    format!(
+                    res.status().as_u16(),
-                        "Status code mismatch: {} != {}.",
+                    code
-                        res.status().as_u16(),
+                ));
-                        code
-                    ),
-                );
             }
 
             if let Some(expected_hash) = &endpoint.body_hash {
                 let expected = from_hex(expected_hash).unwrap();
                 let actual = digest(&SHA256, String::from(res_body).as_bytes());
                 if &expected != &actual.as_ref() {
-                    error = append_err_msg(error, String::from("Body hash mismatch."));
+                    error = Some(if let Some(msg) = error {
+                        format!("{} Body hash mismatch.", msg)
+                    } else {
+                        String::from("Body hash mismatch.")
+                    });
                 }
             } else if !body.is_empty() && res_body != body {
-                error = append_err_msg(
+                error = Some(if let Some(msg) = error {
-                    error,
+                    format!(
-                    format!("Body mismatch: {} != {}.", res_body.len(), body.len()),
+                        "{} Body mismatch: {} != {}.",
-                );
+                        msg,
-            }
+                        res_body.len(),
-
+                        body.len()
-            if rtt.num_seconds() >= 2 {
+                    )
-                error = append_err_msg(error, format!("RTT too long: {}", rtt_string));
+                } else {
+                    format!("Body mismatch: {} != {}.", res_body.len(), body.len())
+                });
             }
 
             if error.is_some() {
-                EndpointStatus::warn(url, label, rtt_string, error)
+                EndpointStatus::warn(url, label, error)
             } else {
-                EndpointStatus::ok(url, label, rtt_string)
+                EndpointStatus::ok(url, label)
             }
         }
         Err(e) => {
             if let Some(true) = endpoint.should_err {
-                EndpointStatus::ok(url, label, rtt_string)
+                EndpointStatus::ok(url, label)
             } else {
                 EndpointStatus::error(url, label, Some(format!("{}", e)))
             }
@@ -121,14 +116,3 @@ fn get_url(base: &Option<String>, path: &String, port: Option<u16>) -> Result<St
     }
     Ok(url.into_string())
 }
-
-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!("{} {}", e, to_append),
-        None => to_append,
-    })
-}