From 00046f2d59c03895fc679807f09d68641d56f626 Mon Sep 17 00:00:00 2001 From: Michel de Graaf Date: Tue, 11 Nov 2025 21:16:39 +0100 Subject: [PATCH] chore: rename ServerOperation to ServerMessage --- src/actor/server_actor.rs | 50 +++++++++---------- src/client.rs | 17 +++---- src/message/server/connect_to_peer.rs | 8 +-- src/message/server/excluded_search_phrases.rs | 6 +-- src/message/server/file_search.rs | 6 +-- src/message/server/get_peer_address.rs | 8 +-- src/message/server/login.rs | 10 ++-- src/message/server/message_user.rs | 6 +-- src/message/server/parent_min_speed.rs | 6 +-- src/message/server/parent_speed_ratio.rs | 6 +-- src/message/server/privileged_users.rs | 6 +-- src/message/server/room_list.rs | 6 +-- src/message/server/wish_list_interval.rs | 6 +-- 13 files changed, 70 insertions(+), 71 deletions(-) diff --git a/src/actor/server_actor.rs b/src/actor/server_actor.rs index 886e4c0..fc76e12 100644 --- a/src/actor/server_actor.rs +++ b/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, - self_handle: Option>, - dispatcher: Option>, - dispatcher_receiver: Option>, - dispatcher_sender: Option>, - queued_messages: Vec, + self_handle: Option>, + dispatcher: Option>, + dispatcher_receiver: Option>, + dispatcher_sender: Option>, + queued_messages: Vec, } impl ServerActor { @@ -247,7 +247,7 @@ impl ServerActor { &self.address } - pub fn get_sender(&self) -> Option<&Sender> { + pub fn get_sender(&self) -> Option<&Sender> { self.dispatcher_sender.as_ref() } @@ -327,13 +327,13 @@ impl ServerActor { } } - pub fn set_self_handle(&mut self, handle: ActorHandle) { + pub fn set_self_handle(&mut self, handle: ActorHandle) { self.self_handle = Some(handle); } fn initialize_dispatcher(&mut self) { let (dispatcher_sender, dispatcher_receiver) = - std::sync::mpsc::channel::(); + std::sync::mpsc::channel::(); 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 = self + let messages: Vec = 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); diff --git a/src/client.rs b/src/client.rs index aa5cbcd..7563c8d 100644 --- a/src/client.rs +++ b/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), + SetServerSender(Sender), } pub struct ClientContext { pub peer_registry: Option, sender: Option>, - server_sender: Option>, + server_sender: Option>, search_results: Vec, pub download_tokens: HashMap, actor_system: Arc, @@ -86,7 +86,7 @@ pub struct Client { address: PeerAddress, username: String, password: String, - server_handle: Option>, + server_handle: Option>, context: Arc>, } @@ -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) diff --git a/src/message/server/connect_to_peer.rs b/src/message/server/connect_to_peer.rs index c4499a7..c7a903a 100644 --- a/src/message/server/connect_to_peer.rs +++ b/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 for ConnectToPeerHandler { +impl MessageHandler for ConnectToPeerHandler { fn get_code(&self) -> u8 { 18 } - fn handle(&self, message: &mut Message, sender: Sender) { + fn handle(&self, message: &mut Message, sender: Sender) { let peer = Peer::new_from_message(message); - sender.send(ServerOperation::ConnectToPeer(peer)).unwrap(); + sender.send(ServerMessage::ConnectToPeer(peer)).unwrap(); } } diff --git a/src/message/server/excluded_search_phrases.rs b/src/message/server/excluded_search_phrases.rs index 23f03cc..c2f3328 100644 --- a/src/message/server/excluded_search_phrases.rs +++ b/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 for ExcludedSearchPhrasesHandler { +impl MessageHandler for ExcludedSearchPhrasesHandler { fn get_code(&self) -> u8 { 160 } - fn handle(&self, message: &mut Message, _sender: Sender) { + fn handle(&self, message: &mut Message, _sender: Sender) { let item_count = message.read_int32(); let mut exluded_phrases: Vec = Vec::new(); diff --git a/src/message/server/file_search.rs b/src/message/server/file_search.rs index d6fd12a..d64b922 100644 --- a/src/message/server/file_search.rs +++ b/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 for FileSearchHandler { +impl MessageHandler for FileSearchHandler { fn get_code(&self) -> u8 { 26 } - fn handle(&self, message: &mut Message, _sender: Sender) { + fn handle(&self, message: &mut Message, _sender: Sender) { debug!("Handling file search message"); let username = message.read_string(); let token = message.read_int32(); diff --git a/src/message/server/get_peer_address.rs b/src/message/server/get_peer_address.rs index 9d873e6..d20a41a 100644 --- a/src/message/server/get_peer_address.rs +++ b/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 for GetPeerAddressHandler { +impl MessageHandler for GetPeerAddressHandler { fn get_code(&self) -> u8 { 3 } - fn handle(&self, message: &mut Message, sender: Sender) { + fn handle(&self, message: &mut Message, sender: Sender) { let username = message.read_string(); // Read IP address as 4 bytes @@ -25,7 +25,7 @@ impl MessageHandler for GetPeerAddressHandler { println!("GetPeerAddressHandler: {:?}", username); // Debug print sender - .send(ServerOperation::GetPeerAddressResponse { + .send(ServerMessage::GetPeerAddressResponse { username, host, port, diff --git a/src/message/server/login.rs b/src/message/server/login.rs index ef8b544..32d7524 100644 --- a/src/message/server/login.rs +++ b/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 for LoginHandler { +impl MessageHandler for LoginHandler { fn get_code(&self) -> u8 { 1 } - fn handle(&self, message: &mut Message, sender: Sender) { + fn handle(&self, message: &mut Message, sender: Sender) { 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(); } } diff --git a/src/message/server/message_user.rs b/src/message/server/message_user.rs index 189fbbc..1e2bce7 100644 --- a/src/message/server/message_user.rs +++ b/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 for MessageUser { +impl MessageHandler for MessageUser { fn get_code(&self) -> u8 { 22 } - fn handle(&self, message: &mut Message, _sender: Sender) { + fn handle(&self, message: &mut Message, _sender: Sender) { let id = message.read_int32(); let timestamp = message.read_int32(); let username = message.read_string(); diff --git a/src/message/server/parent_min_speed.rs b/src/message/server/parent_min_speed.rs index f03fd69..e0aa010 100644 --- a/src/message/server/parent_min_speed.rs +++ b/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 for ParentMinSpeedHandler { +impl MessageHandler for ParentMinSpeedHandler { fn get_code(&self) -> u8 { 83 } - fn handle(&self, message: &mut Message, sender: Sender) { + fn handle(&self, message: &mut Message, sender: Sender) { let _ = sender; let number = message.read_int32(); debug!("Parent min speed: {}", number); diff --git a/src/message/server/parent_speed_ratio.rs b/src/message/server/parent_speed_ratio.rs index a2b5719..1888f61 100644 --- a/src/message/server/parent_speed_ratio.rs +++ b/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 for ParentSpeedRatioHandler { +impl MessageHandler for ParentSpeedRatioHandler { fn get_code(&self) -> u8 { 84 } - fn handle(&self, message: &mut Message, _sender: Sender) { + fn handle(&self, message: &mut Message, _sender: Sender) { let number = message.read_int32(); debug!("Parent speed ratio: {}", number); } diff --git a/src/message/server/privileged_users.rs b/src/message/server/privileged_users.rs index 3c7fa3b..9805388 100644 --- a/src/message/server/privileged_users.rs +++ b/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 for PrivilegedUsersHandler { +impl MessageHandler for PrivilegedUsersHandler { fn get_code(&self) -> u8 { 69 } - fn handle(&self, message: &mut Message, _sender: Sender) { + fn handle(&self, message: &mut Message, _sender: Sender) { let number = message.read_int32(); debug!("Number of privileged users: {}", number); } diff --git a/src/message/server/room_list.rs b/src/message/server/room_list.rs index 784dffb..b34cd94 100644 --- a/src/message/server/room_list.rs +++ b/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 for RoomListHandler { +impl MessageHandler for RoomListHandler { fn get_code(&self) -> u8 { 64 } - fn handle(&self, _message: &mut Message, _sender: Sender) { + fn handle(&self, _message: &mut Message, _sender: Sender) { // let num_public_rooms = message.read_int32(); // for _ in 0..num_public_rooms { // rooms.public_rooms.push(Room::new(message.read_string(), 0)); diff --git a/src/message/server/wish_list_interval.rs b/src/message/server/wish_list_interval.rs index 43a3b8c..b763149 100644 --- a/src/message/server/wish_list_interval.rs +++ b/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 for WishListIntervalHandler { +impl MessageHandler for WishListIntervalHandler { fn get_code(&self) -> u8 { 104 } - fn handle(&self, message: &mut Message, _sender: Sender) { + fn handle(&self, message: &mut Message, _sender: Sender) { let number = message.read_int32(); debug!("Wishlist search interval: {} in seconds", number); }