background updating works

src/handlers.rs

@@ -7,10 +7,10 @@ use actix_web::{
 use reqwest::{Client, Url, UrlError};
 
 use serde::Serialize;
-use std::sync::{Arc, Mutex, MutexGuard};
+use std::sync::{Arc, RwLock};
 use tera::{Context, Tera};
 
-#[derive(Clone, Serialize, Default)]
+#[derive(Clone, Serialize, Default, Debug)]
 pub struct Status {
     status: u8,
     location: String,
@@ -19,7 +19,7 @@ pub struct Status {
     error: Option<String>,
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, Debug)]
 pub struct QueryResults {
     pub last_update: EpochTimestamp,
     pub refresh_time: u64,
@@ -27,25 +27,10 @@ pub struct QueryResults {
     pub statuses: Vec<Status>,
 }
 
-type State = Arc<Mutex<QueryResults>>;
+type State = Arc<RwLock<QueryResults>>;
-
-// impl State {
-//     pub fn new(config: &Config) -> Self {
-//         State(Arc::from(Mutex::from(QueryResults {
-//             last_update: EpochTimestamp::now(),
-//             refresh_time: config.refresh_time.clone(),
-//             config: config.clone(),
-//             statuses: vec![],
-//         })))
-//     }
-
-//     fn lock(&self) -> MutexGuard<QueryResults> {
-//         self.0.lock().unwrap()
-//     }
-// }
 
 pub fn index(tmpl: Data<Tera>, state: Data<State>) -> WebResult<HttpResponse, WebError> {
-    let state = update_state(state.lock().unwrap());
+    let state = state.read().unwrap();
     let mut ctx = Context::new();
     ctx.insert("results", &*state);
     let s = tmpl.render("index.html", &ctx).map_err(|e| {
@@ -56,17 +41,25 @@ pub fn index(tmpl: Data<Tera>, state: Data<State>) -> WebResult<HttpResponse, We
 }
 
 pub fn json_endpoint(state: Data<State>) -> HttpResponse {
-    let state = update_state(state.lock().unwrap());
+    let state = state.read().unwrap();
     HttpResponse::Ok().json(&state.statuses)
 }
 
-fn update_state(mut state: MutexGuard<QueryResults>) -> MutexGuard<QueryResults> {
+pub fn update_state(state: State) {
-    if EpochTimestamp::now() - state.last_update >= state.refresh_time {
+    let mut new_timestamp = None;
-        state.last_update = EpochTimestamp::now();
+    let mut new_statuses = None;
-        state.statuses = update_status(&state.config);
+    {
+        let read_state = state.read().unwrap();
+        if EpochTimestamp::now() - read_state.last_update >= read_state.refresh_time {
+            new_timestamp = Some(EpochTimestamp::now());
+            new_statuses = Some(update_status(&read_state.config));
+        }
+    }
+    if new_timestamp.is_some() {
+        let mut write_state = state.try_write().expect("Could not unlock");
+        write_state.last_update = new_timestamp.unwrap();
+        write_state.statuses = new_statuses.unwrap();
     }
-
-    state
 }
 
 fn update_status(config: &Config) -> Vec<Status> {

src/main.rs

@@ -19,9 +19,8 @@ use actix::System;
 use actix_web::{middleware::Logger, web::resource, App, HttpServer};
 use ron::de::from_str;
 use std::{
-    error::Error,
     fs::read_to_string,
-    sync::{Arc, Mutex},
+    sync::{Arc, RwLock},
     time::Duration,
 };
 use tokio::prelude::{Future, Stream};
@@ -29,25 +28,28 @@ use tokio::timer::Interval;
 
 fn main() {
     System::run(move || {
-        let config = from_str::<Config>(&read_to_string("./endstat_conf.ron").expect("Could not find config file")).unwrap();
+        let config = from_str::<Config>(
+            &read_to_string("./endstat_conf.ron").expect("Could not find config file"),
+        )
+        .unwrap();
         let bind_addr = config.bind_address.clone();
         std::env::set_var("RUST_LOG", "actix_web=info");
         env_logger::init();
 
-        let state = Arc::from(Mutex::from(QueryResults {
+        let state = Arc::new(RwLock::new(QueryResults {
             last_update: EpochTimestamp::now(),
             refresh_time: config.refresh_time.clone(),
             config: config.clone(),
             statuses: vec![],
         }));
-        let state1 = state.clone();
+        let clone_state = Arc::clone(&state);
-        let state2 = state.clone();
 
         HttpServer::new(move || {
             let tera = compile_templates!(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/**/*"));
+            let state = Arc::clone(&state);
 
             App::new()
-                .data(state1)
+                .data(state)
                 .data(tera)
                 .wrap(Logger::default())
                 .service(resource("/").to(index))
@@ -59,11 +61,13 @@ fn main() {
 
         tokio::spawn(
             Interval::new_interval(Duration::from_millis(5000))
-                .for_each(|_| {
+                .for_each(move |_| {
-                    println!("Every 5 seconds");
+                    let state = Arc::clone(&clone_state);
+                    update_state(state);
                     Ok(())
                 })
                 .map_err(|_| ()),
         );
-    }).expect("Could not run system!");
+    })
+    .expect("Could not run system!");
 }

src/utils.rs

@@ -5,7 +5,7 @@ use std::{
     time::{SystemTime, UNIX_EPOCH},
 };
 
-#[derive(PartialEq, PartialOrd, Copy, Clone)]
+#[derive(PartialEq, PartialOrd, Copy, Clone, Debug)]
 pub struct EpochTimestamp(SystemTime);
 
 impl EpochTimestamp {