2 files changed, 61 insertions, 27 deletions
diff --git a/src/forecast.rs b/src/forecast.rs
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/forecast.rs
diff --git a/src/main.rs b/src/main.rs
index 0848754..fbb23e2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,9 +22,7 @@
  *
  * Remove socket file when daemon exits.
  *
- * Accept command-line arguments to query only part of JSON
- *
- * Fix delay
+ * Accept command-line arguments to query only part of JSON. (Maybe also a formatting string?)
  *
  */
 
@@ -76,8 +74,8 @@ struct Cli {
     daemon: bool,
     #[arg(short='v', long)]
     verbose: bool,
-    #[arg(short='D', long, default_value="100")]
-    delay: u64,
+    #[arg(short='D', long, default_value="2.0")]
+    delay: f64,
     #[arg(short='s', long, default_value="varanus.sock")]
     socket: String,
 }
@@ -107,13 +105,22 @@ struct ProcFS {
 impl ProcFS {
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 struct Memory {
+    total: u64,
+    free: u64,
 }
 
 impl Memory {
     fn new(si: Sysinfo) -> Self {
-        return Memory{}
+        let mut mem = Memory::default();
+        mem.update(si);
+        return mem;
+    }
+
+    fn update(&mut self, si: Sysinfo) {
+        self.total = si.totalram;
+        self.free = si.freeram;
     }
 }
 
@@ -138,7 +145,10 @@ impl State {
     }
 
     fn update(&mut self) {
+        let si = Sysinfo::new();
         self.asof = SystemTime::now();
+        self.uptime = si.uptime;
+        self.memory.update(si);
     }
 }
 
@@ -155,32 +165,56 @@ fn get_state(sockfile: String) -> Result<State> {
     Ok(serde_json::from_str::<State>(str::from_utf8(&buf)?)?)
 }
 
+struct Listener {
+    file: String,
+    state: Arc<Mutex<State>>,
+}
+
+impl Listener {
+    fn new(socket: String, state_mutex: &Arc<Mutex<State>>) -> Self {
+        return Listener {
+            file: socket,
+            state: Arc::clone(state_mutex),
+        }
+    }
+
+    fn listen(&self) {
+        let state_mutex = Arc::clone(&self.state);
+        let sfn = self.file.clone();
+        spawn(move || {
+            let _ = remove_file(&sfn);
+            let listener = UnixListener::bind(sfn).unwrap();
+            loop {
+                match listener.accept() {
+                    Ok((mut socket,accept)) => {
+                        let json = {
+                            let state = state_mutex.lock().unwrap();
+                            serde_json::to_string(&*state).unwrap()
+                        };
+                        socket.write_all(json.as_bytes()).unwrap();
+                    },
+                    Err(e) => println!("error: {:?}", e)
+                }
+            }
+        });
+    }
+}
+
+impl Drop for Listener {
+    fn drop(&mut self) {
+        let _ = remove_file(&self.file);
+    }
+}
+
 fn main() {
     let args = Cli::parse();
     if args.daemon {
         let start = Instant::now();
-        let delay_ms: u64 = args.delay * 1000; // TODO not right
+        let delay_ms: u64 = (args.delay * 1000.0) as u64;
         let mut cycle: u64 = 0;
         let state_mutex = Arc::new(Mutex::new(State::new()));
-        let listen_thread = {
-            let state_mutex = Arc::clone(&state_mutex);
-            spawn(move || {
-                let _ = remove_file(&args.socket);
-                let listener = UnixListener::bind(args.socket).unwrap();
-                loop {
-                    match listener.accept() {
-                        Ok((mut socket,accept)) => {
-                            let json = {
-                                let state = state_mutex.lock().unwrap();
-                                serde_json::to_string(&*state).unwrap()
-                            };
-                            socket.write_all(json.as_bytes()).unwrap();
-                        },
-                        Err(e) => println!("error: {:?}", e)
-                    }
-                }
-            });
-        };
+        let listener = Listener::new(args.socket, &state_mutex);
+        listener.listen();
         loop {
             if args.verbose {
                 println!("{:?} elapsed; updating state...", start.elapsed());