Moved TcpListender form Server To NetworkManage.

src/lib/server/mod.rs

@@ -27,7 +27,6 @@ pub enum ServerMessages {
 }
 
 pub struct Server {
-	server_socket: TcpListener,
 	client_manager: Arc<ClientManager>,
   network_manager: Arc<NetworkManager>,
 
@@ -37,11 +36,9 @@ pub struct Server {
 
 impl Server {
 	pub fn new() -> Arc<Server> {
-		let listener = TcpListener::bind("0.0.0.0:5600").expect("Could not bind to address");
 		let (sender, receiver) = unbounded();
 
 		Arc::new(Server {
-			server_socket: listener,
 			client_manager: ClientManager::new(sender.clone()),
 
       network_manager: NetworkManager::new("5600".to_string(), sender.clone()),
@@ -59,36 +56,7 @@ impl Server {
 impl ICooperative for Server{
 	fn tick(&self) {
 
-    let mut buffer = vec![0; 64];
-
-    // handle new connections 
-    for connection in self.server_socket.incoming() {
-      match connection {
-        Ok(mut stream) => {
-          stream.write_all(Commands::Request(None).to_string().as_bytes()).expect("error writing socket");
-          stream.read_to_end(&mut buffer).expect("error reading sokcet");
-          
-          println!("buffer: {:?}", &buffer);
-
-          let command = Commands::from(&mut buffer);
-
-          match command {
-            Commands::Info(None) => {
-              let server_config = vec![
-                ("name".to_string(), "Test server".to_string())
-              ];
-              let map: HashMap<String, String> = server_config.into_iter().collect();
-              stream.write_all(Commands::Success(Some(map)).to_string().as_bytes())
-                .expect("error sending response");
-            }
-            Commands::Connect(Some(map)) => println!("connect command: {:?}", &map),
-
-            _ => {let _ = stream.write("not implemented!".as_bytes());}
-          }
-        },
-        _ => println!("!connection error occured!"),
-      }
-    }
+		self.network_manager.tick();
 
     // handle new messages loop
     for message in self.receiver.iter() {

src/lib/server/network_manager/mod.rs

@@ -1,26 +1,41 @@
 
-use std::sync::Arc;
-use crate::lib::server::ServerMessages;
 use std::net::TcpListener;
+use std::sync::Arc;
+use std::io::BufReader;
+use std::io::BufWriter;
+use std::io::Write;
+use std::io::BufRead;
 
 use serde::{Deserialize, Serialize};
 use crossbeam_channel::Sender;
 
+use crate::lib::server::ServerMessages;
 use crate::lib::Foundation::ICooperative;
 
+
+/// # NetworkSockIn
+/// these messages can be sent by a client on connecting
 #[derive(Serialize, Deserialize)]
-enum NetworkSocketMesssages {
-  Info {id: String},
-  Connect {id: String, uuid: String, username: String, address: String},
+enum NetworkSockIn {
+  Info,
+  Connect {uuid: String, username: String, address: String},
 }
 
+/// # NetworkSockOut
+/// these messages are sent by the network manager on connecting and requesting
+#[derive(Serialize, Deserialize)]
+enum NetworkSockOut<'a> {
+	Request,
+	GotInfo {server_name: &'a str, server_owner: &'a str}
+}
+
+// these are control signals from the server.
 pub enum NetworkMessages {
 
 }
 
 pub struct NetworkManager {
   listener: TcpListener,
-
   server_channel: Sender<ServerMessages>,
 }
 
@@ -41,6 +56,44 @@ impl NetworkManager {
 
 impl ICooperative for NetworkManager {
   fn tick(&self) {
-    println!("network manager tick")
+    // get all new connections
+		// handle each request
+		for connection in self.listener.incoming() {
+			if let Ok(stream) = connection {
+
+				// create buffered writers
+				let mut reader = BufReader::new(stream.try_clone().unwrap());
+				let mut writer = BufWriter::new(stream.try_clone().unwrap());
+
+				let mut buffer = String::new();
+
+				// request is always sent on new connection
+				writer.write_all(serde_json::to_string(&NetworkSockOut::Request).unwrap().as_bytes()).unwrap_or_default();
+				writer.write_all(b"\n").unwrap_or_default();
+				writer.flush().unwrap_or_default();
+
+				// read the new request into a buffer
+				let res = reader.read_line(&mut buffer);
+				if res.is_err() {continue;}
+
+				// turn into enum for pattern matching
+				if let Ok(request) = serde_json::from_str::<NetworkSockIn>(&buffer) {
+					// perform action based on the enum
+					match request {
+						NetworkSockIn::Info => {
+							writer.write_all(
+								serde_json::to_string(
+									&NetworkSockOut::GotInfo {server_name: "oof", server_owner: "michael"}
+								).unwrap().as_bytes()
+							).unwrap();
+							writer.flush().unwrap();
+						}
+						NetworkSockIn::Connect { uuid, username, address } => {
+							println!("Connection requested")
+						}
+					}
+				}
+			}
+		}
   }
 }