Rename test module, kinda get connection working.

unshell-test-module/src/server/server_runtime.rs

@@ -0,0 +1,105 @@
+use std::{
+    io::Write,
+    net::{TcpListener, TcpStream},
+    sync::{Arc, Mutex},
+    thread::{self, JoinHandle},
+};
+
+use unshell_modules::ModuleRuntime;
+
+use crate::Announcement;
+
+pub struct ListenerRuntime {
+    thread_handle: JoinHandle<()>,
+    // listener: TcpListener,
+    streams: Arc<Mutex<Vec<TcpStream>>>,
+    // reader: BufReader<TcpListener>,
+    // writer: BufWriter<TcpListener>,
+}
+
+impl ListenerRuntime {
+    pub fn new() -> ListenerRuntime {
+        info!("Starting listener runtime on 127.0.0.1:1234");
+        let listener = TcpListener::bind("127.0.0.1:1234").unwrap();
+        let streams = Arc::new(Mutex::new(Vec::new()));
+
+        let streams_clone = streams.clone();
+
+        let thread_handle = thread::spawn(move || {
+            let streams = streams_clone.clone();
+            for stream in listener.incoming() {
+                let stream = stream.unwrap();
+                println!("New connection from {}", stream.peer_addr().unwrap());
+                streams.lock().unwrap().push(stream);
+
+                // thread::spawn(move || {
+                //     let _ = handle_connection(&mut stream);
+                //     info!("Connection from {} closed", stream.peer_addr().unwrap());
+                // });
+            }
+        });
+
+        // let reader = BufReader::new(stream.try_clone().unwrap());
+        // let writer = BufWriter::new(stream.try_clone().unwrap());
+
+        Self {
+            thread_handle,
+            streams,
+            // stream,
+            // reader,
+            // writer,
+            // thread_handle: thread::spawn(move || {
+
+            //     for stream in listener.incoming() {
+            //         let mut stream = stream.unwrap();
+
+            //         thread::spawn(move || {
+            //             let _ = handle_connection(&mut stream);
+            //             info!("Connection from {} closed", stream.peer_addr().unwrap());
+            //         });
+            //     }
+            //     // thread::sleep(Duration::from_secs(2));
+
+            //     // let manager_lock = manager.lock().unwrap();
+            //     // manager_lock.test1234(111.1111);
+            //     // drop(manager_lock);
+            // }),
+        }
+    }
+
+    pub fn send(&mut self, announcement: &Announcement) -> Result<(), std::io::Error> {
+        let bytes = announcement.encode();
+
+        let mut streams = self.streams.lock().unwrap();
+
+        for stream in streams.iter_mut() {
+            stream.write_all(&u32::to_be_bytes(bytes.len() as u32))?;
+            stream.write_all(&bytes)?;
+            stream.flush()?;
+        }
+
+        println!("Announcement {:?} sent", announcement);
+
+        Ok(())
+
+        // self.stream
+        //     .write_all(&u32::to_be_bytes(bytes.len() as u32))?;
+        // self.stream.write_all(&bytes)?;
+        // self.stream.flush()?;
+    }
+}
+
+impl ModuleRuntime for ListenerRuntime {
+    // fn init(&mut self) {}
+
+    fn is_running(&self) -> bool {
+        true
+    }
+
+    fn kill(self: Box<Self>) {
+        if !self.thread_handle.is_finished() {
+            let _ = self.thread_handle.join();
+        }
+        // drop(self);
+    }
+}