removing unnecessary prints and thread delays

foundation/src/messages/client.rs

@@ -1,5 +1,5 @@
-use uuid::Uuid;
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
 /// # ClientMessage
 /// This enum defined the message that a client can receive from the server

server/Cargo.toml

@@ -13,7 +13,6 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 crossbeam = "0.8.0"
 crossbeam-channel = "0.5.0"
-crossbeam-queue = "0.3.1"
 
 [dependencies.foundation]
 path = '../foundation'

server/src/client.rs

@@ -128,13 +128,20 @@ impl IPreemptive for Client {
 							println!("[Client {:?}]: Disconnect recieved", &arc.uuid);
 							arc.send_message(Disconnect);
 							break 'main;
-						},
-						Ok(ClientStreamIn::SendMessage{to, content}) => {
-							println!("[Client {:?}]: send message to: {:?}",&arc.uuid, &to);
+						}
+						Ok(ClientStreamIn::SendMessage { to, content }) => {
+							println!(
+								"[Client {:?}]: send message to: {:?}",
+								&arc.uuid, &to
+							);
 							let lock = arc.server_channel.lock().unwrap();
 							let sender = lock.as_ref().unwrap();
-							let _ = sender.send(ServerMessage::ClientSendMessage {from: arc.uuid, to, content });
-						},
+							let _ = sender.send(ServerMessage::ClientSendMessage {
+								from: arc.uuid,
+								to,
+								content,
+							});
+						}
 						_ => println!("[Client {:?}]: command not found", &arc.uuid),
 					}
 				}
@@ -148,10 +155,9 @@ impl IPreemptive for Client {
 				let arc = arc2;
 				let mut writer_lock = arc.stream_writer.lock().unwrap();
 				let writer = writer_lock.as_mut().unwrap();
-
 				let mut buffer: Vec<u8> = Vec::new();
 
-				writeln!(
+				let _ = writeln!(
 					buffer,
 					"{}",
 					serde_json::to_string(&ClientStreamOut::Connected).unwrap()
@@ -160,11 +166,8 @@ impl IPreemptive for Client {
 				let _ = writer.flush();
 
 				'main: loop {
-					std::thread::sleep(std::time::Duration::from_secs(1));
-					println!("[Client {:?}]: thread 2 tick!", &arc.uuid);
-
 					for message in arc.output.iter() {
-            println!("[Client {:?}]: {:?}", &arc.uuid, message);
+						println!("[Client {:?}]: {:?}", &arc.uuid, message);
 						match message {
 							Disconnect => {
 								arc.server_channel
@@ -177,21 +180,17 @@ impl IPreemptive for Client {
 								break 'main;
 							}
 							Message { from, content } => {
-								writeln!(
+								let _ = writeln!(
 									buffer,
 									"{}",
-									serde_json::to_string(&ClientStreamOut::UserMessage {from, content})
-										.unwrap()
+									serde_json::to_string(
+										&ClientStreamOut::UserMessage { from, content }
+									)
+									.unwrap()
 								);
-                let _ = writer.write_all(&buffer);
-                let _ = writer.write_all(b"\n");
-                let _ = writer.flush();
+								let _ = writer.write_all(&buffer);
+								let _ = writer.flush();
 							}
-              #[allow(unreachable_patterns)]
-							_ => println!(
-								"[Client {:?}]: message not implemented",
-								&arc.uuid
-							),
 						}
 					}
 				}

server/src/client_manager.rs

@@ -78,10 +78,13 @@ impl IPreemptive for ClientManager {
 								client.send_message(ClientMessage::Disconnect);
 							}
 						}
-						SendMessage {to, from, content} => {
+						SendMessage { to, from, content } => {
 							let lock = arc.clients.lock().unwrap();
 							if let Some(client) = lock.get(&to) {
-								client.send_message(ClientMessage::Message { from, content })
+								client.send_message(ClientMessage::Message {
+									from,
+									content,
+								})
 							}
 						}
 						#[allow(unreachable_patterns)]
@@ -90,7 +93,6 @@ impl IPreemptive for ClientManager {
 				}
 			}
 		}
-		println!("client manager exited");
 	}
 
 	fn start(arc: &Arc<Self>) {

server/src/network_manager.rs

@@ -55,28 +55,30 @@ impl IPreemptive for NetworkManager {
 						let _handle = thread::Builder::new()
 							.name("NetworkJoinThread".to_string())
 							.spawn(move || {
-								let mut buffer = String::new();
+								let mut out_buffer: Vec<u8> = Vec::new();
+								let mut in_buffer: String = String::new();
 
 								// send request message to 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();
+
+								let _ = writeln!(
+									out_buffer,
+									"{}",
+									serde_json::to_string(&NetworkSockOut::Request)
+										.unwrap()
+								);
+
+								let _ = writer.write_all(&out_buffer);
+								let _ = writer.flush();
 
 								// try get response
-								let res = reader.read_line(&mut buffer);
+								let res = reader.read_line(&mut in_buffer);
 								if res.is_err() {
 									return;
 								}
 
 								//match the response
 								if let Ok(request) =
-									serde_json::from_str::<NetworkSockIn>(&buffer)
+									serde_json::from_str::<NetworkSockIn>(&in_buffer)
 								{
 									match request {
 										NetworkSockIn::Info => {

server/src/server.rs

@@ -1,5 +1,4 @@
 use std::sync::Arc;
-use std::thread;
 
 use crossbeam_channel::{unbounded, Receiver};
 use uuid::Uuid;
@@ -13,12 +12,10 @@ use foundation::prelude::IMessagable;
 use foundation::prelude::IPreemptive;
 
 /// # ServerMessages
-/// This is used internally
+/// This is used internally to send messages to the server to be dispatched
 #[derive(Debug)]
 pub enum ServerMessages<TClient> {
 	ClientConnected(Arc<TClient>),
-
-	#[allow(dead_code)]
 	ClientDisconnected(Uuid),
 }
 
@@ -48,7 +45,6 @@ impl ICooperative for Server {
 
 		// handle new messages loop
 		if !self.receiver.is_empty() {
-			println!("[server]: entering loop!");
 			for message in self.receiver.try_iter() {
 				println!("[server]: received message {:?}", &message);
 				match message {
@@ -74,7 +70,6 @@ impl IPreemptive for Server {
 		NetworkManager::start(&arc.network_manager);
 		ClientManager::start(&arc.client_manager);
 		loop {
-			thread::sleep(std::time::Duration::from_secs(1));
 			arc.tick();
 		}
 	}