errors are a vector instead of a single string

config/templates/index.html

@@ -71,7 +71,9 @@
               {% if status.status != 2 %}<p>{{ status.rtt }}</p>{% endif %}
             </div>
             <a href="{{ status.location }}" target="_blank">{{ status.location }}</a>
-          {% if status.error %}<p class="error-msg">{{ status.error }}</p>{% endif %}
+            {% for msg in status.errors -%}
+            <p class="error-msg">{{ msg }}</p>
+            {% endfor -%}
             </main>
         </section>
         {% endfor -%}

src/results.rs

@@ -8,7 +8,7 @@ pub struct EndpointStatus {
     pub location: String,
     pub endpoint: String,
     pub rtt: Option<String>,
-    pub error: Option<String>,
+    pub errors: Vec<String>,
 }
 
 impl EndpointStatus {
@@ -18,27 +18,27 @@ impl EndpointStatus {
             location,
             endpoint,
             rtt: Some(rtt),
-            error: None,
+            errors: vec![],
         }
     }
 
-    pub fn warn(location: String, endpoint: String, rtt: String, error: Option<String>) -> Self {
+    pub fn warn(location: String, endpoint: String, rtt: String, errors: Vec<String>) -> Self {
         EndpointStatus {
             status: 1,
             location,
             endpoint,
             rtt: Some(rtt),
-            error,
+            errors,
         }
     }
 
-    pub fn error(location: String, endpoint: String, error: Option<String>) -> Self {
+    pub fn error(location: String, endpoint: String, errors: Vec<String>) -> Self {
         EndpointStatus {
             status: 2,
             location,
             endpoint,
             rtt: None,
-            error,
+            errors,
         }
     }
 }

src/updater.rs

@@ -62,43 +62,42 @@ fn get_result(
     match ping_result {
         Ok(mut res) => {
             let res_body = res.text().expect("could not get body of request");
-            let mut error = None;
+            let mut errors = vec![];
 
             if res.status() != code {
-                error = append_err_msg(
+                errors.push(format!(
-                    error,
-                    format!(
                     "Status code mismatch: {} != {}",
                     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."));
+                    errors.push(String::from("Body hash mismatch."));
                 }
             } else if !body.is_empty() && res_body != body {
-                error = append_err_msg(
+                errors.push(format!(
-                    error,
+                    "Body mismatch: {} != {}",
-                    format!("Body mismatch: {} != {}", res_body.len(), body.len()),
+                    res_body.len(),
-                );
+                    body.len()
+                ));
             }
 
             if let Some(max_rtt) = endpoint.max_rtt {
                 if rtt.num_milliseconds() > max_rtt {
-                    error = append_err_msg(
+                    errors.push(format!(
-                        error,
+                        "RTT too long: {} > {}s",
-                        format!("RTT too long: {} > {}s", rtt_string, max_rtt as f64 / 1000.),
+                        rtt_string,
-                    );
+                        max_rtt as f64 / 1000.
+                    ));
                 }
             }
 
-            if error.is_some() {
+            if !errors.is_empty() {
-                EndpointStatus::warn(url, label, rtt_string, error)
+                EndpointStatus::warn(url, label, rtt_string, errors)
             } else {
                 EndpointStatus::ok(url, label, rtt_string)
             }
@@ -107,7 +106,7 @@ fn get_result(
             if let Some(true) = endpoint.should_err {
                 EndpointStatus::ok(url, label, rtt_string)
             } else {
-                EndpointStatus::error(url, label, Some(format!("{}", e)))
+                EndpointStatus::error(url, label, vec![format!("{}", e)])
             }
         }
     }
@@ -124,10 +123,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> {
-    Some(match optional {
-        Some(e) => format!("{}\n{}", e, to_append),
-        None => to_append,
-    })
-}