fix: deadlock issue with sending messages

intoduced a channel and used stream.try_clone

src/message/handlers/excluded_search_phrases.rs

@@ -1,8 +1,10 @@
-use crate::{dispatcher::MessageHandler, message::Message};
+use std::sync::{Arc, Mutex};
+
+use crate::{dispatcher::MessageHandler, message::Message, server::Context};
 pub struct ExcludedSearchPhrasesHandler;
 
 impl MessageHandler for ExcludedSearchPhrasesHandler {
-    fn handle(&self, message: &mut Message, _context: crate::server::Context) {
+    fn handle(&self, message: &mut Message, _context: Arc<Mutex<Context>>) {
         let item_count = message.read_int32();
 
         let mut exluded_phrases: Vec<String> = Vec::new();

src/message/handlers/login.rs

@@ -1,19 +1,22 @@
+use std::sync::{Arc, Mutex};
+
 use crate::{
     dispatcher::MessageHandler,
     message::{factory::build_shared_folders_message, Message},
+    server::Context,
 };
 pub struct LoginHandler;
 
 impl MessageHandler for LoginHandler {
-    fn handle(&self, message: &mut Message, context: crate::server::Context) {
+    fn handle(&self, message: &mut Message, context: Arc<Mutex<Context>>) {
         let response = message.read_int8();
         if response == 1 {
             println!("Login successful");
             let greeting = message.read_string();
             println!("Server geeting: {:?}", greeting);
             // Build the shared folders message and queue it
-            let shared_message = build_shared_folders_message(1, 1).get_data();
-            context.queue_message(shared_message);
+            let shared_message = build_shared_folders_message(1, 1);
+            context.lock().unwrap().queue_message(shared_message);
         } else {
             println!("Login failed");
         }

src/message/handlers/privileged_users.rs

@@ -1,8 +1,10 @@
-use crate::{dispatcher::MessageHandler, message::Message};
+use std::sync::{Arc, Mutex};
+
+use crate::{dispatcher::MessageHandler, message::Message, server::Context};
 pub struct PrivilegedUsersHandler;
 
 impl MessageHandler for PrivilegedUsersHandler {
-    fn handle(&self, message: &mut Message, _context: crate::server::Context) {
+    fn handle(&self, message: &mut Message, _context: Arc<Mutex<Context>>) {
         let number = message.read_int32();
         println!("Number of privilaged users: {}", number);
     }

src/message/handlers/room_list.rs

@@ -1,65 +1,60 @@
-use crate::{dispatcher::MessageHandler, message::Message, server::Room};
+use crate::{
+    dispatcher::MessageHandler,
+    message::Message,
+    server::{Context, Room},
+};
+use std::sync::{Arc, Mutex};
 pub struct RoomListHandler;
 
 impl MessageHandler for RoomListHandler {
-    fn handle(&self, message: &mut Message, mut context: crate::server::Context) {
-        let mut rooms: Vec<Room> = Vec::new();
-        let mut owned_private_rooms: Vec<Room> = Vec::new();
-        let mut private_rooms: Vec<Room> = Vec::new();
-        let mut operated_private_rooms: Vec<Room> = Vec::new();
+    fn handle(&self, message: &mut Message, context: Arc<Mutex<Context>>) {
+        let mut binding = context.lock().unwrap();
+        let rooms = binding.get_rooms();
 
-        // Number of rooms
-        let num_rooms = message.read_int32();
-        for _ in 0..num_rooms {
-            rooms.push(Room::new(message.read_string(), 0));
+        let num_public_rooms = message.read_int32();
+        for _ in 0..num_public_rooms {
+            rooms.public_rooms.push(Room::new(message.read_string(), 0));
         }
 
-        // Number of rooms
-        let num_rooms = message.read_int32();
-        // get the number of users in each room
-        for i in 0..num_rooms {
-            rooms[i as usize].set_number_of_users(message.read_int32());
+        let num_public_rooms = message.read_int32();
+        for i in 0..num_public_rooms {
+            rooms.public_rooms[i as usize].set_number_of_users(message.read_int32());
         }
 
-        // Number of owned private rooms
         let num_owned_private_rooms = message.read_int32();
         for _ in 0..num_owned_private_rooms {
-            owned_private_rooms.push(Room::new(message.read_string(), 0));
+            rooms
+                .owned_private_rooms
+                .push(Room::new(message.read_string(), 0));
         }
 
-        // Number of owned private rooms
         let num_owned_private_rooms = message.read_int32();
         for i in 0..num_owned_private_rooms {
-            owned_private_rooms[i as usize].set_number_of_users(message.read_int32());
+            rooms.owned_private_rooms[i as usize].set_number_of_users(message.read_int32());
         }
 
-        // Number of private rooms (except owned)
         let num_private_rooms = message.read_int32();
         for _ in 0..num_private_rooms {
-            private_rooms.push(Room::new(message.read_string(), 0));
+            rooms
+                .private_rooms
+                .push(Room::new(message.read_string(), 0));
         }
 
-        // Number of private rooms (except owned)
         let num_private_rooms = message.read_int32();
         for i in 0..num_private_rooms {
-            // Number of users in private rooms (except owned)
-            private_rooms[i as usize].set_number_of_users(message.read_int32());
+            rooms.private_rooms[i as usize].set_number_of_users(message.read_int32());
         }
 
-        // Number of operated private rooms
         let num_operated_private_rooms = message.read_int32();
         for _ in 0..num_operated_private_rooms {
-            operated_private_rooms.push(Room::new(message.read_string(), 0));
+            rooms
+                .operated_private_rooms
+                .push(Room::new(message.read_string(), 0));
         }
         let num_operated_private_rooms = message.read_int32();
         for i in 0..num_operated_private_rooms {
-            // Number of users in private rooms (except owned)
-            operated_private_rooms[i as usize].set_number_of_users(message.read_int32());
+            rooms.operated_private_rooms[i as usize].set_number_of_users(message.read_int32());
         }
-        println!("Rooms: {:?}", rooms.len());
-        println!("Owned private rooms: {:?}", owned_private_rooms.len());
-        println!("Private rooms: {:?}", private_rooms.len());
-        println!("Operated private rooms: {:?}", operated_private_rooms.len());
-        context.set_rooms(rooms);
+        rooms.print();
     }
 }