move

4 files changed, 149 insertions, 150 deletions

diff --git a/src/server/main.rs b/src/server/main.rs
index 74e88c2..91a69b8 100644
--- a/src/server/main.rs
+++ b/src/server/main.rs
@@ -1,4 +1,5 @@
 pub(crate) mod servers;
+pub(crate) mod tasks;
 
 #[tokio::main]
 async fn main() {
diff --git a/src/server/servers/tcpserver.rs b/src/server/servers/tcpserver.rs
index 1af118c..4dcf25c 100644
--- a/src/server/servers/tcpserver.rs
+++ b/src/server/servers/tcpserver.rs
@@ -1,2 +1,148 @@
-pub mod server;
-pub mod tasks;
+use std::{
+    cell::RefCell,
+    net::SocketAddr,
+    sync::{Arc, Weak},
+};
+
+use remote_control_rs::{client, tasks::server::Task};
+use tokio::{
+    io::{self, AsyncReadExt},
+    net::{TcpListener, TcpStream},
+};
+
+use crate::{
+    servers::Server,
+    tasks::{Request, RequestType},
+};
+
+use bincode::serde;
+
+struct TCPServer<'a> {
+    this: RefCell<Weak<Self>>,
+    task: Option<Task>,
+    listener: TcpListener,
+    clients: RefCell<Vec<Client<'a>>>,
+}
+
+impl<'a> TCPServer<'a> {
+    fn new(listener: TcpListener) -> Arc<Self> {
+        let s = Arc::new(Self { this: RefCell::new(Weak::new()), listener, task: None, clients: RefCell::new(Vec::new()) });
+        *s.this.borrow_mut() = Arc::downgrade(&s);
+        s
+    }
+
+    fn remove(&self, client: &Client<'a>) {
+        self.clients.borrow_mut().retain(|c| c != client);
+    }
+}
+
+impl<'a> Server<'a> for TCPServer<'a> {
+    fn update(&mut self, task: Task) {
+        self.task = Some(task);
+    }
+
+    async fn listen(&mut self) -> ! {
+        loop {
+            match self.listener.accept().await {
+                Ok((socket, addr)) => self.clients.borrow_mut().push(Client::new(self.this.borrow().upgrade().unwrap(), socket, addr)), // the unwrap shouldn't panics, self has to be alive
+                Err(e) => eprintln!("Failed to accept connection: {e}"),
+            };
+        }
+    }
+}
+
+pub struct Client<'a> {
+    server: Arc<TCPServer<'a>>,
+    stream: TcpStream,
+    addr: SocketAddr,
+    data: Option<client::Client<'a>>,
+}
+
+impl<'a> Client<'a> {
+    fn new(server: Arc<TCPServer<'a>>, stream: TcpStream, addr: SocketAddr) -> Self {
+        Self { server, stream, addr, data: None }
+    }
+
+    fn handle_read(&mut self, buf: io::Result<usize>) -> bool {
+        match buf {
+            Ok(0) => self.server.remove(self),
+            Ok(_) => {}
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return false,
+            Err(e) => {
+                eprintln!("Failed to read from client: {e}");
+                return false;
+            }
+        }
+        true
+    }
+
+    // TODO: use framed
+    async fn read(&mut self) -> Option<(Vec<u8>, usize)> {
+        const usize: usize = std::mem::size_of::<usize>();
+        let mut len = vec![0; usize]; // vec! only take usize
+        if !self.handle_read(self.stream.try_read(&mut len)) {
+            return None;
+        }
+        let len = usize::from_be_bytes(match len.try_into() {
+            Ok(n) => n,
+            Err(e) => {
+                eprintln!("Failed to convert length bytes to length usize: {:?}", e);
+                return None;
+            }
+        }); // TODO: move to a shared fn with client to ensure we use same endian
+        let mut buf = vec![0; len];
+        let read = self.stream.read_exact(&mut buf).await;
+        if !self.handle_read(read) {
+            return None;
+        }
+        Some((buf, len))
+    }
+
+    async fn poll(&mut self) -> ! {
+        loop {
+            if let Err(e) = self.stream.readable().await {
+                eprintln!("Failed waiting for client to be readable: {e}");
+                continue;
+            }
+            if let Some((buf, len)) = self.read().await {
+                let req: RequestType = match serde::decode_from_slice(buf.as_slice(), bincode::config::standard()) {
+                    Ok((decoded, size)) => {
+                        if size != len {
+                            eprintln!("Decoded size {size} does not match expected size {len}, decode succeeded anyways?");
+                        }
+                        decoded
+                    }
+                    Err(e) => {
+                        eprintln!("Failed to decode request from client {}: {e}", self.addr);
+                        continue;
+                    }
+                };
+                match req {
+                    // TODO: seperate send and respond
+                    RequestType::Send(req) => match req {
+                        Request::Get(req) => {
+                            todo!()
+                        }
+                        Request::Post(req) => {
+                            todo!()
+                        }
+                    },
+                    RequestType::Respond(res) => match res {
+                        Request::Get(req) => {
+                            todo!()
+                        }
+                        Request::Post(req) => {
+                            todo!()
+                        }
+                    },
+                }
+            }
+        }
+    }
+}
+
+impl<'a> PartialEq for Client<'a> {
+    fn eq(&self, other: &Self) -> bool {
+        self.data == other.data
+    }
+}
diff --git a/src/server/servers/tcpserver/server.rs b/src/server/servers/tcpserver/server.rs
deleted file mode 100644
index 0b9b9b7..0000000
--- a/src/server/servers/tcpserver/server.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-use std::{
-    cell::RefCell,
-    net::SocketAddr,
-    sync::{Arc, Weak},
-};
-
-use remote_control_rs::{client, tasks::server::Task};
-use tokio::{
-    io::{self, AsyncReadExt},
-    net::{TcpListener, TcpStream},
-};
-
-use crate::servers::{
-    Server,
-    tcpserver::tasks::{Request, RequestType},
-};
-
-use bincode::serde;
-
-struct TCPServer<'a> {
-    this: RefCell<Weak<Self>>,
-    task: Option<Task>,
-    listener: TcpListener,
-    clients: RefCell<Vec<Client<'a>>>,
-}
-
-impl<'a> TCPServer<'a> {
-    fn new(listener: TcpListener) -> Arc<Self> {
-        let s = Arc::new(Self { this: RefCell::new(Weak::new()), listener, task: None, clients: RefCell::new(Vec::new()) });
-        *s.this.borrow_mut() = Arc::downgrade(&s);
-        s
-    }
-
-    fn remove(&self, client: &Client<'a>) {
-        self.clients.borrow_mut().retain(|c| c != client);
-    }
-}
-
-impl<'a> Server<'a> for TCPServer<'a> {
-    fn update(&mut self, task: Task) {
-        self.task = Some(task);
-    }
-
-    async fn listen(&mut self) -> ! {
-        loop {
-            match self.listener.accept().await {
-                Ok((socket, addr)) => self.clients.borrow_mut().push(Client::new(self.this.borrow().upgrade().unwrap(), socket, addr)), // the unwrap shouldn't panics, self has to be alive
-                Err(e) => eprintln!("Failed to accept connection: {e}"),
-            };
-        }
-    }
-}
-
-pub struct Client<'a> {
-    server: Arc<TCPServer<'a>>,
-    stream: TcpStream,
-    addr: SocketAddr,
-    data: Option<client::Client<'a>>,
-}
-
-impl<'a> Client<'a> {
-    fn new(server: Arc<TCPServer<'a>>, stream: TcpStream, addr: SocketAddr) -> Self {
-        Self { server, stream, addr, data: None }
-    }
-
-    fn handle_read(&mut self, buf: io::Result<usize>) -> bool {
-        match buf {
-            Ok(0) => self.server.remove(self),
-            Ok(_) => {}
-            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return false,
-            Err(e) => {
-                eprintln!("Failed to read from client: {e}");
-                return false;
-            }
-        }
-        true
-    }
-
-    // TODO: use framed
-    async fn read(&mut self) -> Option<(Vec<u8>, usize)> {
-        const usize: usize = std::mem::size_of::<usize>();
-        let mut len = vec![0; usize]; // vec! only take usize
-        if !self.handle_read(self.stream.try_read(&mut len)) {
-            return None;
-        }
-        let len = usize::from_be_bytes(match len.try_into() {
-            Ok(n) => n,
-            Err(e) => {
-                eprintln!("Failed to convert length bytes to length usize: {:?}", e);
-                return None;
-            }
-        }); // TODO: move to a shared fn with client to ensure we use same endian
-        let mut buf = vec![0; len];
-        let read = self.stream.read_exact(&mut buf).await;
-        if !self.handle_read(read) {
-            return None;
-        }
-        Some((buf, len))
-    }
-
-    async fn poll(&mut self) -> ! {
-        loop {
-            if let Err(e) = self.stream.readable().await {
-                eprintln!("Failed waiting for client to be readable: {e}");
-                continue;
-            }
-            if let Some((buf, len)) = self.read().await {
-                let req: RequestType = match serde::decode_from_slice(buf.as_slice(), bincode::config::standard()) {
-                    Ok((decoded, size)) => {
-                        if size != len {
-                            eprintln!("Decoded size {size} does not match expected size {len}, decode succeeded anyways?");
-                        }
-                        decoded
-                    }
-                    Err(e) => {
-                        eprintln!("Failed to decode request from client {}: {e}", self.addr);
-                        continue;
-                    }
-                };
-                match req {
-                    // TODO: seperate send and respond
-                    RequestType::Send(req) => match req {
-                        Request::Get(req) => {
-                            todo!()
-                        }
-                        Request::Post(req) => {
-                            todo!()
-                        }
-                    },
-                    RequestType::Respond(res) => match res {
-                        Request::Get(req) => {
-                            todo!()
-                        }
-                        Request::Post(req) => {
-                            todo!()
-                        }
-                    },
-                }
-            }
-        }
-    }
-}
-
-impl<'a> PartialEq for Client<'a> {
-    fn eq(&self, other: &Self) -> bool {
-        self.data == other.data
-    }
-}
diff --git a/src/server/servers/tcpserver/tasks.rs b/src/server/tasks.rs
index 5052dfe..5052dfe 100644
--- a/src/server/servers/tcpserver/tasks.rs
+++ b/src/server/tasks.rs