Implemented client messaging through the server

foundation/src/messages/client.rs

@@ -1,6 +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
@@ -11,8 +10,8 @@ pub enum ClientStreamIn {
 	Connected,
 
 	Update,
-	SendMessage { to_uuid: Uuid, contents: String },
-	SendGlobalMessage { contents: String },
+	SendMessage { to: Uuid, content: String },
+	SendGlobalMessage { content: String },
 
 	Disconnect,
 }
@@ -21,8 +20,8 @@ pub enum ClientStreamIn {
 pub enum ClientStreamOut {
 	Connected,
 
-	UserMessage { from_uuid: String, contents: String },
-	GlobalMessage { contents: String },
+	UserMessage { from: Uuid, content: String },
+	GlobalMessage { content: String },
 
 	Disconnected,
 }

server/src/client.rs

@@ -129,11 +129,11 @@ impl IPreemptive for Client {
 							arc.send_message(Disconnect);
 							break 'main;
 						},
-						Ok(ClientStreamIn::SendMessage{to_uuid, contents}) => {
-							println!("[Client {:?}]: send message to: {:?}",&arc.uuid, &to_uuid);
+						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();
-							sender.send(ServerMessage::ClientSendMessage {from: arc.uuid.clone(), to: to_uuid, contents });
+							let _ = sender.send(ServerMessage::ClientSendMessage {from: arc.uuid, to, content });
 						},
 						_ => println!("[Client {:?}]: command not found", &arc.uuid),
 					}
@@ -164,6 +164,7 @@ impl IPreemptive for Client {
 					println!("[Client {:?}]: thread 2 tick!", &arc.uuid);
 
 					for message in arc.output.iter() {
+            println!("[Client {:?}]: {:?}", &arc.uuid, message);
 						match message {
 							Disconnect => {
 								arc.server_channel
@@ -175,14 +176,18 @@ impl IPreemptive for Client {
 									.unwrap();
 								break 'main;
 							}
-							Message { from, contents } => {
+							Message { from, content } => {
 								writeln!(
 									buffer,
 									"{}",
-									serde_json::to_string(&ClientStreamOut::Connected)
+									serde_json::to_string(&ClientStreamOut::UserMessage {from, content})
 										.unwrap()
 								);
+                let _ = writer.write_all(&buffer);
+                let _ = writer.write_all(b"\n");
+                let _ = writer.flush();
 							}
+              #[allow(unreachable_patterns)]
 							_ => println!(
 								"[Client {:?}]: message not implemented",
 								&arc.uuid

server/src/client_manager.rs

@@ -78,10 +78,10 @@ impl IPreemptive for ClientManager {
 								client.send_message(ClientMessage::Disconnect);
 							}
 						}
-						SendMessage {to, from, contents} => {
+						SendMessage {to, from, content} => {
 							let lock = arc.clients.lock().unwrap();
 							if let Some(client) = lock.get(&to) {
-								client.send_message(ClientMessage::Message { from, contents })
+								client.send_message(ClientMessage::Message { from, content })
 							}
 						}
 						#[allow(unreachable_patterns)]

server/src/messages.rs

@@ -5,7 +5,7 @@ use crate::client::Client;
 
 #[derive(Debug)]
 pub enum ClientMessage {
-	Message { from: Uuid, contents: String },
+	Message { from: Uuid, content: String },
 
 	Disconnect,
 }
@@ -17,7 +17,7 @@ pub enum ClientMgrMessage {
 	SendMessage {
 		from: Uuid,
 		to: Uuid,
-		contents: String,
+		content: String,
 	},
 }
 
@@ -27,7 +27,7 @@ pub enum ServerMessage {
 	ClientSendMessage {
 		from: Uuid,
 		to: Uuid,
-		contents: String,
+		content: String,
 	},
 	ClientDisconnected(Uuid),
 }

server/src/server.rs

@@ -59,9 +59,9 @@ impl ICooperative for Server {
 						println!("disconnecting client {:?}", uuid);
 						self.client_manager.send_message(Remove(uuid));
 					}
-					ServerMessage::ClientSendMessage { from, to, contents } => self
+					ServerMessage::ClientSendMessage { from, to, content } => self
 						.client_manager
-						.send_message(SendMessage { from, to, contents }),
+						.send_message(SendMessage { from, to, content }),
 				}
 			}
 		}