chore: rename ServerOperation to ServerMessage

src/actor/server_actor.rs

@@ -177,7 +177,7 @@ impl Room {
 }
 
 #[derive(Debug, Clone)]
-pub enum ServerOperation {
+pub enum ServerMessage {
     ProcessRead,
     LoginStatus(bool),
     SendMessage(Message),
@@ -212,11 +212,11 @@ pub struct ServerActor {
     connection_state: ConnectionState,
     reader: MessageReader,
     client_channel: Sender<ClientOperation>,
-    self_handle: Option<ActorHandle<ServerOperation>>,
-    dispatcher: Option<MessageDispatcher<ServerOperation>>,
-    dispatcher_receiver: Option<Receiver<ServerOperation>>,
-    dispatcher_sender: Option<Sender<ServerOperation>>,
-    queued_messages: Vec<ServerOperation>,
+    self_handle: Option<ActorHandle<ServerMessage>>,
+    dispatcher: Option<MessageDispatcher<ServerMessage>>,
+    dispatcher_receiver: Option<Receiver<ServerMessage>>,
+    dispatcher_sender: Option<Sender<ServerMessage>>,
+    queued_messages: Vec<ServerMessage>,
 }
 
 impl ServerActor {
@@ -247,7 +247,7 @@ impl ServerActor {
         &self.address
     }
 
-    pub fn get_sender(&self) -> Option<&Sender<ServerOperation>> {
+    pub fn get_sender(&self) -> Option<&Sender<ServerMessage>> {
         self.dispatcher_sender.as_ref()
     }
 
@@ -327,13 +327,13 @@ impl ServerActor {
         }
     }
 
-    pub fn set_self_handle(&mut self, handle: ActorHandle<ServerOperation>) {
+    pub fn set_self_handle(&mut self, handle: ActorHandle<ServerMessage>) {
         self.self_handle = Some(handle);
     }
 
     fn initialize_dispatcher(&mut self) {
         let (dispatcher_sender, dispatcher_receiver) =
-            std::sync::mpsc::channel::<ServerOperation>();
+            std::sync::mpsc::channel::<ServerMessage>();
 
         self.dispatcher_receiver = Some(dispatcher_receiver);
         self.dispatcher_sender = Some(dispatcher_sender.clone());
@@ -365,7 +365,7 @@ impl ServerActor {
     }
 
     fn process_dispatcher_messages(&mut self) {
-        let messages: Vec<ServerOperation> = self
+        let messages: Vec<ServerMessage> = self
             .dispatcher_receiver
             .as_ref()
             .map_or_else(Vec::new, |receiver| {
@@ -434,10 +434,10 @@ impl ServerActor {
         ));
     }
 
-    fn handle_message(&mut self, msg: ServerOperation) {
+    fn handle_message(&mut self, msg: ServerMessage) {
         if !matches!(self.connection_state, ConnectionState::Connected) {
             match &msg {
-                ServerOperation::ProcessRead => {
+                ServerMessage::ProcessRead => {
                     // Always process read operations
                 }
                 _ => {
@@ -449,7 +449,7 @@ impl ServerActor {
         }
 
         match msg {
-            ServerOperation::ConnectToPeer(peer) => {
+            ServerMessage::ConnectToPeer(peer) => {
                 if let Some(op) = match peer.connection_type {
                     ConnectionType::P | ConnectionType::F => {
                         Some(ClientOperation::ConnectToPeer(peer.clone()))
@@ -459,23 +459,23 @@ impl ServerActor {
                     self.client_channel.send(op).unwrap();
                 }
             }
-            ServerOperation::LoginStatus(message) => {
+            ServerMessage::LoginStatus(message) => {
                 self.context.write().unwrap().logged_in = Some(message);
             }
-            ServerOperation::PierceFirewall(token) => {
+            ServerMessage::PierceFirewall(token) => {
                 self.send_message(
                     MessageFactory::build_pierce_firewall_message(token),
                 );
             }
-            ServerOperation::SendMessage(message) => {
+            ServerMessage::SendMessage(message) => {
                 self.send_message(message);
             }
-            ServerOperation::GetPeerAddress(username) => {
+            ServerMessage::GetPeerAddress(username) => {
                 self.send_message(MessageFactory::build_get_peer_address(
                     &username,
                 ));
             }
-            ServerOperation::GetPeerAddressResponse {
+            ServerMessage::GetPeerAddressResponse {
                 username,
                 host,
                 port,
@@ -499,10 +499,10 @@ impl ServerActor {
                     error!("[server] Error forwarding GetPeerAddress response to client: {}", e);
                 }
             }
-            ServerOperation::ProcessRead => {
+            ServerMessage::ProcessRead => {
                 self.process_read();
             }
-            ServerOperation::Login {
+            ServerMessage::Login {
                 username,
                 password,
                 response,
@@ -534,7 +534,7 @@ impl ServerActor {
                     std::thread::sleep(Duration::from_millis(100));
                 });
             }
-            ServerOperation::FileSearch { token, query } => {
+            ServerMessage::FileSearch { token, query } => {
                 self.file_search(token, &query);
             }
         }
@@ -611,13 +611,13 @@ impl ServerActor {
 
     fn queue_message(&mut self, message: Message) {
         if let Some(sender) = &self.dispatcher_sender {
-            match sender.send(ServerOperation::SendMessage(message)) {
+            match sender.send(ServerMessage::SendMessage(message)) {
                 Ok(_) => {}
                 Err(e) => error!("Failed to send: {}", e),
             }
         } else {
             self.queued_messages
-                .push(ServerOperation::SendMessage(message));
+                .push(ServerMessage::SendMessage(message));
         }
     }
 
@@ -711,7 +711,7 @@ impl ServerActor {
         }
 
         if let Some(ref handle) = self.self_handle {
-            handle.send(ServerOperation::ProcessRead).ok();
+            handle.send(ServerMessage::ProcessRead).ok();
         }
 
         self.process_read();
@@ -719,7 +719,7 @@ impl ServerActor {
 }
 
 impl Actor for ServerActor {
-    type Message = ServerOperation;
+    type Message = ServerMessage;
 
     fn handle(&mut self, msg: Self::Message) {
         self.handle_message(msg);

src/client.rs

@@ -1,4 +1,4 @@
-use crate::actor::server_actor::{PeerAddress, ServerActor, ServerOperation};
+use crate::actor::server_actor::{PeerAddress, ServerActor, ServerMessage};
 use crate::actor::ActorHandle;
 use crate::types::{DownloadResult, DownloadStatus};
 use crate::{
@@ -44,12 +44,12 @@ pub enum ClientOperation {
         obfuscated_port: u16,
     },
     UploadFailed(String, String),
-    SetServerSender(Sender<ServerOperation>),
+    SetServerSender(Sender<ServerMessage>),
 }
 pub struct ClientContext {
     pub peer_registry: Option<PeerRegistry>,
     sender: Option<Sender<ClientOperation>>,
-    server_sender: Option<Sender<ServerOperation>>,
+    server_sender: Option<Sender<ServerMessage>>,
     search_results: Vec<FileSearchResult>,
     pub download_tokens: HashMap<u32, Download>,
     actor_system: Arc<ActorSystem>,
@@ -86,7 +86,7 @@ pub struct Client {
     address: PeerAddress,
     username: String,
     password: String,
-    server_handle: Option<ActorHandle<ServerOperation>>,
+    server_handle: Option<ActorHandle<ServerMessage>>,
     context: Arc<RwLock<ClientContext>>,
 }
 
@@ -154,7 +154,7 @@ impl Client {
         info!("Logging in as {}", self.username);
         if let Some(handle) = &self.server_handle {
             let (tx, rx) = std::sync::mpsc::channel();
-            let _ = handle.send(ServerOperation::Login {
+            let _ = handle.send(ServerMessage::Login {
                 username: self.username.clone(),
                 password: self.password.clone(),
                 response: tx,
@@ -188,7 +188,7 @@ impl Client {
         if let Some(handle) = &self.server_handle {
             let hash = md5::md5(query);
             let token = u32::from_str_radix(&hash[0..5], 16)?;
-            let _ = handle.send(ServerOperation::FileSearch {
+            let _ = handle.send(ServerMessage::FileSearch {
                 token,
                 query: query.to_string(),
             });
@@ -438,7 +438,7 @@ impl Client {
                                 &client_context.read().unwrap().server_sender
                             {
                                 server_sender
-                                    .send(ServerOperation::GetPeerAddress(
+                                    .send(ServerMessage::GetPeerAddress(
                                         new_peer.username.clone(),
                                     ))
                                     .unwrap();
@@ -671,8 +671,7 @@ impl Client {
         let context = client_context.read().unwrap();
         if let Some(server_sender) = &context.server_sender {
             if let Some(token) = peer.token {
-                match server_sender.send(ServerOperation::PierceFirewall(token))
-                {
+                match server_sender.send(ServerMessage::PierceFirewall(token)) {
                     Ok(_) => (),
                     Err(e) => {
                         error!("Failed to send PierceFirewall message: {}", e)

src/message/server/connect_to_peer.rs

@@ -1,15 +1,15 @@
-use crate::actor::server_actor::ServerOperation;
+use crate::actor::server_actor::ServerMessage;
 use crate::message::{Message, MessageHandler};
 use crate::peer::Peer;
 use std::sync::mpsc::Sender;
 pub struct ConnectToPeerHandler;
 
-impl MessageHandler<ServerOperation> for ConnectToPeerHandler {
+impl MessageHandler<ServerMessage> for ConnectToPeerHandler {
     fn get_code(&self) -> u8 {
         18
     }
-    fn handle(&self, message: &mut Message, sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<ServerMessage>) {
         let peer = Peer::new_from_message(message);
-        sender.send(ServerOperation::ConnectToPeer(peer)).unwrap();
+        sender.send(ServerMessage::ConnectToPeer(peer)).unwrap();
     }
 }

src/message/server/excluded_search_phrases.rs

@@ -1,18 +1,18 @@
 use crate::debug;
 use crate::{
-    actor::server_actor::ServerOperation,
+    actor::server_actor::ServerMessage,
     message::{Message, MessageHandler},
 };
 use std::sync::mpsc::Sender;
 
 pub struct ExcludedSearchPhrasesHandler;
 
-impl MessageHandler<ServerOperation> for ExcludedSearchPhrasesHandler {
+impl MessageHandler<ServerMessage> for ExcludedSearchPhrasesHandler {
     fn get_code(&self) -> u8 {
         160
     }
 
-    fn handle(&self, message: &mut Message, _sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
         let item_count = message.read_int32();
 
         let mut exluded_phrases: Vec<String> = Vec::new();

src/message/server/file_search.rs

@@ -2,17 +2,17 @@ use crate::{debug, info};
 use std::sync::mpsc::Sender;
 
 use crate::{
-    actor::server_actor::ServerOperation, message::handlers::MessageHandler,
+    actor::server_actor::ServerMessage, message::handlers::MessageHandler,
     message::Message,
 };
 
 pub struct FileSearchHandler;
 
-impl MessageHandler<ServerOperation> for FileSearchHandler {
+impl MessageHandler<ServerMessage> for FileSearchHandler {
     fn get_code(&self) -> u8 {
         26
     }
-    fn handle(&self, message: &mut Message, _sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
         debug!("Handling file search message");
         let username = message.read_string();
         let token = message.read_int32();

src/message/server/get_peer_address.rs

@@ -1,15 +1,15 @@
-use crate::actor::server_actor::ServerOperation;
+use crate::actor::server_actor::ServerMessage;
 use crate::message::{Message, MessageHandler};
 use std::sync::mpsc::Sender;
 
 pub struct GetPeerAddressHandler;
 
-impl MessageHandler<ServerOperation> for GetPeerAddressHandler {
+impl MessageHandler<ServerMessage> for GetPeerAddressHandler {
     fn get_code(&self) -> u8 {
         3
     }
 
-    fn handle(&self, message: &mut Message, sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<ServerMessage>) {
         let username = message.read_string();
 
         // Read IP address as 4 bytes
@@ -25,7 +25,7 @@ impl MessageHandler<ServerOperation> for GetPeerAddressHandler {
         println!("GetPeerAddressHandler: {:?}", username); // Debug print
 
         sender
-            .send(ServerOperation::GetPeerAddressResponse {
+            .send(ServerMessage::GetPeerAddressResponse {
                 username,
                 host,
                 port,

src/message/server/login.rs

@@ -1,5 +1,5 @@
 use crate::{
-    actor::server_actor::ServerOperation, debug, info, message::Message,
+    actor::server_actor::ServerMessage, debug, info, message::Message,
 };
 use std::sync::mpsc::Sender;
 
@@ -7,23 +7,23 @@ use crate::message::MessageHandler;
 
 pub struct LoginHandler;
 
-impl MessageHandler<ServerOperation> for LoginHandler {
+impl MessageHandler<ServerMessage> for LoginHandler {
     fn get_code(&self) -> u8 {
         1
     }
 
-    fn handle(&self, message: &mut Message, sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<ServerMessage>) {
         let response = message.read_int8();
 
         if response != 1 {
-            return sender.send(ServerOperation::LoginStatus(false)).unwrap();
+            return sender.send(ServerMessage::LoginStatus(false)).unwrap();
         }
 
         info!("Login successful");
         let greeting = message.read_string();
         debug!("Server greeting: {:?}", greeting);
 
-        sender.send(ServerOperation::LoginStatus(true)).unwrap();
+        sender.send(ServerMessage::LoginStatus(true)).unwrap();
     }
 }
 

src/message/server/message_user.rs

@@ -1,4 +1,4 @@
-use crate::actor::server_actor::{ServerOperation, UserMessage};
+use crate::actor::server_actor::{ServerMessage, UserMessage};
 use crate::info;
 use crate::message::{Message, MessageHandler};
 
@@ -6,12 +6,12 @@ use std::sync::mpsc::Sender;
 
 pub struct MessageUser;
 
-impl MessageHandler<ServerOperation> for MessageUser {
+impl MessageHandler<ServerMessage> for MessageUser {
     fn get_code(&self) -> u8 {
         22
     }
 
-    fn handle(&self, message: &mut Message, _sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
         let id = message.read_int32();
         let timestamp = message.read_int32();
         let username = message.read_string();

src/message/server/parent_min_speed.rs

@@ -2,18 +2,18 @@ use crate::debug;
 use std::sync::mpsc::Sender;
 
 use crate::{
-    actor::server_actor::ServerOperation,
+    actor::server_actor::ServerMessage,
     message::{Message, MessageHandler},
 };
 
 pub struct ParentMinSpeedHandler;
 
-impl MessageHandler<ServerOperation> for ParentMinSpeedHandler {
+impl MessageHandler<ServerMessage> for ParentMinSpeedHandler {
     fn get_code(&self) -> u8 {
         83
     }
 
-    fn handle(&self, message: &mut Message, sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<ServerMessage>) {
         let _ = sender;
         let number = message.read_int32();
         debug!("Parent min speed: {}", number);

src/message/server/parent_speed_ratio.rs

@@ -2,19 +2,19 @@ use crate::debug;
 use std::sync::mpsc::Sender;
 
 use crate::{
-    actor::server_actor::ServerOperation,
+    actor::server_actor::ServerMessage,
     message::{Message, MessageHandler},
 };
 
 pub struct ParentSpeedRatioHandler;
 
 // The server sends us a speed ratio determining the number of children we can have in the distributed network. The maximum number of children is our upload speed divided by the speed ratio.
-impl MessageHandler<ServerOperation> for ParentSpeedRatioHandler {
+impl MessageHandler<ServerMessage> for ParentSpeedRatioHandler {
     fn get_code(&self) -> u8 {
         84
     }
 
-    fn handle(&self, message: &mut Message, _sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
         let number = message.read_int32();
         debug!("Parent speed ratio: {}", number);
     }

src/message/server/privileged_users.rs

@@ -2,18 +2,18 @@ use crate::debug;
 use std::sync::mpsc::Sender;
 
 use crate::{
-    actor::server_actor::ServerOperation,
+    actor::server_actor::ServerMessage,
     message::{Message, MessageHandler},
 };
 
 pub struct PrivilegedUsersHandler;
 
-impl MessageHandler<ServerOperation> for PrivilegedUsersHandler {
+impl MessageHandler<ServerMessage> for PrivilegedUsersHandler {
     fn get_code(&self) -> u8 {
         69
     }
 
-    fn handle(&self, message: &mut Message, _sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
         let number = message.read_int32();
         debug!("Number of privileged users: {}", number);
     }

src/message/server/room_list.rs

@@ -1,17 +1,17 @@
 use crate::{
-    actor::server_actor::ServerOperation,
+    actor::server_actor::ServerMessage,
     message::{Message, MessageHandler},
 };
 use std::sync::mpsc::Sender;
 
 pub struct RoomListHandler;
 
-impl MessageHandler<ServerOperation> for RoomListHandler {
+impl MessageHandler<ServerMessage> for RoomListHandler {
     fn get_code(&self) -> u8 {
         64
     }
 
-    fn handle(&self, _message: &mut Message, _sender: Sender<ServerOperation>) {
+    fn handle(&self, _message: &mut Message, _sender: Sender<ServerMessage>) {
         // let num_public_rooms = message.read_int32();
         // for _ in 0..num_public_rooms {
         //     rooms.public_rooms.push(Room::new(message.read_string(), 0));

src/message/server/wish_list_interval.rs

@@ -2,7 +2,7 @@ use crate::debug;
 use std::sync::mpsc::Sender;
 
 use crate::{
-    actor::server_actor::ServerOperation,
+    actor::server_actor::ServerMessage,
     message::{Message, MessageHandler},
 };
 
@@ -10,12 +10,12 @@ pub struct WishListIntervalHandler;
 
 // The server tells us the wishlist search interval.
 // This interval is almost always 12 minutes, or 2 minutes for privileged users.
-impl MessageHandler<ServerOperation> for WishListIntervalHandler {
+impl MessageHandler<ServerMessage> for WishListIntervalHandler {
     fn get_code(&self) -> u8 {
         104
     }
 
-    fn handle(&self, message: &mut Message, _sender: Sender<ServerOperation>) {
+    fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
         let number = message.read_int32();
         debug!("Wishlist search interval: {} in seconds", number);
     }