Implemented IMessageable for client, client manager as well as basic commands in netmgr

server/src/client.rs

@@ -1,3 +1,4 @@
+use std::mem::replace;
 use crate::messages::ClientMessage;
 use crate::messages::ServerMessage;
 use std::cmp::Ordering;
@@ -34,7 +35,7 @@ pub struct Client {
 
 	// non serializable
 	#[serde(skip)]
-  server_channel: Option<Sender<ServerMessage>>,
+  server_channel: Mutex<Option<Sender<ServerMessage>>>,
 
   #[serde(skip)]
   input: Sender<ClientMessage>,
@@ -72,7 +73,7 @@ impl Client {
       uuid: Uuid::parse_str(&uuid).expect("invalid id"),
       address,
 
-      server_channel: Some(server_channel),
+      server_channel: Mutex::new(Some(server_channel)),
 
       input: sender,
       output: receiver,
@@ -95,7 +96,8 @@ impl IMessagable<ClientMessage, Sender<ServerMessage>> for Client{
 		self.input.send(msg).expect("failed to send message to client.");
 	}
   fn set_sender(&self, sender: Sender<ServerMessage>) {
-
+    let mut server_lock = self.server_channel.lock().unwrap();
+    let _ = replace(&mut *server_lock, Some(sender));
   }
 }
 
@@ -141,7 +143,7 @@ impl Default for Client {
 		  output: reciever,
 			input: sender,
 
-      server_channel: None,
+      server_channel: Mutex::new(None),
 
       stream: Mutex::new(None),
 

server/src/client_manager.rs

@@ -1,33 +1,29 @@
 // use crate::lib::server::ServerMessages;
-use crate::messages::ServerMessage;
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::collections::HashMap;
+use std::mem::replace;
 
 use crossbeam_channel::{unbounded, Receiver, Sender};
 use uuid::Uuid;
 
 use crate::client::Client;
+use crate::messages::ClientMgrMessage;
+use crate::messages::ServerMessage;
+use crate::messages::ClientMessage;
 use foundation::prelude::IMessagable;
 use foundation::prelude::ICooperative;
 
-enum ClientManagerMessage {
-  #[allow(dead_code)]
-  DropAll,
-  #[allow(dead_code)]
-  MessageClient,
-}
-
 /// # ClientManager
 /// This struct manages all connected users
 #[derive(Debug)]
 pub struct ClientManager {
   clients: Mutex<HashMap<Uuid, Arc<Client>>>,
 
-	server_channel: Sender<ServerMessage>,
+	server_channel: Mutex<Sender<ServerMessage>>,
 
-  sender: Sender<ClientManagerMessage>,
-  receiver: Receiver<ClientManagerMessage>,
+  sender: Sender<ClientMgrMessage>,
+  receiver: Receiver<ClientMgrMessage>,
 }
 
 impl ClientManager {
@@ -38,7 +34,7 @@ impl ClientManager {
     Arc::new(ClientManager {
       clients: Mutex::default(),
 
-			server_channel,
+			server_channel: Mutex::new(server_channel),
 
       sender,
       receiver,
@@ -46,28 +42,13 @@ impl ClientManager {
   }
 }
 
-// impl TClientManager<Client, ClientMessage> for ClientManager {
-//   fn add_client(&self, client: std::sync::Arc<Client>) {
-//     self.clients.lock().unwrap().insert(client.uuid, client);
-//   }
-
-//   fn remove_client(&self, uuid: Uuid) {
-//     let _ = self.clients.lock().unwrap().remove(&uuid);
-//   }
-
-//   fn send_message_to_client(&self, uuid: Uuid, msg: ClientMessage) {
-//     let clients = self.clients.lock().unwrap();
-//     let client = clients.get(&uuid).unwrap();
-//     client.send_message(msg);
-//   }
-// }
-
-impl IMessagable<ClientManagerMessage, Sender<ServerMessage>> for ClientManager {
-	fn send_message(&self, msg: ClientManagerMessage) {
-
+impl IMessagable<ClientMgrMessage, Sender<ServerMessage>> for ClientManager {
+	fn send_message(&self, msg: ClientMgrMessage) {
+    self.sender.send(msg).unwrap();
   }
   fn set_sender(&self, sender: Sender<ServerMessage>) {
-
+    let mut server_lock = self.server_channel.lock().unwrap();
+    let _ = replace(&mut *server_lock, sender);
   }
 }
 
@@ -75,11 +56,23 @@ impl ICooperative for ClientManager {
   fn tick(&self) {
 
     for message in self.receiver.iter() {
+      use ClientMgrMessage::{Add, Remove, SendMessage};
+
       match message {
-        ClientManagerMessage::DropAll => {
-          println!("cannot drop all clients yet")
-        }
-        _ => println!("[Client Manager]: method not implemented")
+        Add(client) => {
+          self.clients.lock().unwrap().insert(client.uuid, client).unwrap();
+        },
+        Remove(uuid) => {
+          let _ = self.clients.lock().unwrap().remove(&uuid);
+        },
+        SendMessage(to_uuid, from_uuid, content) => {
+          let lock = self.clients.lock().unwrap();
+          if let Some(client) = lock.get(&to_uuid) {
+            client.send_message(ClientMessage::Message(from_uuid, content))
+          }
+        },
+        #[allow(unreachable_patterns)]
+        _ => println!("[Client manager]: not implemented")
       }
     }
 
@@ -87,34 +80,4 @@ impl ICooperative for ClientManager {
     let clients = self.clients.lock().unwrap();
     let _ = clients.iter().map(|(_uuid, client)| client.tick());
   }
-}
-
-
-#[cfg(test)]
-mod test {
-  // use super::ClientManager;
-  // use std::sync::Arc;
-	// use crate::lib::Foundation::{IOwner};
-
-  #[test]
-  fn test_get_ref() {
-    // let client_manager = ClientManager::new();
-    // let _cm_ref = client_manager.get_ref();
-    // assert_eq!(Arc::weak_count(&client_manager), 2);
-  }
-
-  #[test]
-  fn test_add_client() {
-    todo!()
-  }
-
-  #[test]
-  fn test_remove_client() {
-    todo!()
-  }
-
-  #[test]
-  fn test_remove_all_clients() {
-    todo!()
-  }
-}
+}

server/src/messages.rs

@@ -4,13 +4,15 @@ use std::sync::Arc;
 use crate::client::Client;
 
 pub enum ClientMessage {
-  Disconnect
+  Message(Uuid, String),
+
+  Disconnect,
 }
 
 pub enum ClientMgrMessage {
   Remove(Uuid),
   Add(Arc<Client>),
-  SendMessage(Uuid, String),
+  SendMessage(Uuid, Uuid, String),
 }
 
 pub enum ServerMessage {

server/src/server.rs

@@ -32,7 +32,7 @@ impl Server {
 		Arc::new(Server {
 			client_manager: ClientManager::new(sender.clone()),
 
-      network_manager: NetworkManager::new("5600".to_string(), sender.clone()),
+      network_manager: NetworkManager::new("5600".to_string(), sender),
 			receiver,
 		})
 	}
@@ -44,9 +44,9 @@ impl ICooperative for Server{
 		// handle new messages loop
 		for message in self.receiver.try_iter() {
 			match message {
-				ServerMessage::ClientConnected(client) => {
+				ServerMessage::ClientConnected(_client) => {
 				},
-				ServerMessage::ClientDisconnected(uuid) => {
+				ServerMessage::ClientDisconnected(_uuid) => {
 				}
 			}
 		}