Add Ctl Socket, iterate on Idling daemon, update sysinfo crate, start on run menu

src/backend/commands.rs

@@ -0,0 +1,62 @@
+use crate::LOGGER;
+use crate::backend::{BackendThread, SimpleBackendThread};
+use crate::ctl::{ControlCommand, SOCKET_PATH};
+use crossbeam_channel::{Receiver, Sender};
+use jmb_logger_rs::*;
+use std::io::Read;
+use std::net::Shutdown;
+use std::os::unix::net::UnixListener;
+use std::sync::{Arc, Mutex};
+
+pub struct ControlSocket {
+    subscribers: Vec<Sender<ControlCommand>>,
+}
+
+impl SimpleBackendThread<ControlCommand> for ControlSocket {
+    fn subscribers(&self) -> &Vec<Sender<ControlCommand>> {
+        &self.subscribers
+    }
+
+    fn init(registration_rx: Receiver<Sender<ControlCommand>>) {
+        let instance = Arc::new(Mutex::new(Self {
+            subscribers: Vec::new(),
+        }));
+        let instance_clone = instance.clone();
+        std::thread::spawn(move || {
+            while let Ok(sender) = registration_rx.recv() {
+                instance_clone.lock().unwrap().subscribers.push(sender);
+            }
+        });
+        std::thread::spawn(move || {
+            if std::fs::metadata(SOCKET_PATH).is_ok() {
+                if let Err(e) = std::fs::remove_file(SOCKET_PATH) {
+                    error!(&LOGGER, "Error deleting old socket file: {e}");
+                    return;
+                }
+            }
+            let socket = UnixListener::bind(SOCKET_PATH);
+            let Ok(socket) = socket else {
+                error!(&LOGGER, "Error creating socket {}", socket.err().unwrap());
+                return;
+            };
+
+            info!(&LOGGER, "Successfully started control socket");
+
+            loop {
+                if let Ok((mut stream, _addr)) = socket.accept() {
+                    info!(&LOGGER, "Socket accepted connection");
+                    let mut read = String::new();
+                    let res = stream.read_to_string(&mut read);
+                    if let Err(e) = res {
+                        error!(&LOGGER, "Error reading: {e}");
+                        let _ = stream.shutdown(Shutdown::Both);
+                        continue;
+                    }
+                    if let Some(command) = ControlCommand::from_str(&read) {
+                        instance.lock().unwrap().publish(command);
+                    }
+                }
+            }
+        });
+    }
+}