feat: implement default peer message processing

src/message/handlers.rs

@@ -9,48 +9,46 @@ use super::server::{
     WishListIntervalHandler,
 };
 
-pub trait MessageHandler {
+pub trait MessageHandler<Op> {
     fn get_code(&self) -> u8;
-    fn handle(&self, message: &mut Message, sender: Sender<ServerOperation>);
+    fn handle(&self, message: &mut Message, sender: Sender<Op>);
 }
-pub struct Handlers {
-    handlers: HashMap<u8, Box<dyn MessageHandler>>,
+pub struct Handlers<Op> {
+    handlers: HashMap<u8, Box<dyn MessageHandler<Op>>>,
 }
 
-impl Handlers {
+impl<Op> Handlers<Op> {
     pub fn new() -> Self {
         Self {
             handlers: HashMap::new(),
         }
     }
+
     pub fn new_with_server_handlers() -> Self {
         let mut handlers = Self::new();
-        handlers.add_server_handlers();
+        handlers.register_handler(LoginHandler);
+        handlers.register_handler(RoomListHandler);
+        handlers.register_handler(ExcludedSearchPhrasesHandler);
+        handlers.register_handler(PrivilegedUsersHandler);
+        handlers.register_handler(MessageUser);
+        handlers.register_handler(WishListIntervalHandler);
+        handlers.register_handler(ParentMinSpeedHandler);
+        handlers.register_handler(ParentSpeedRatioHandler);
+        handlers.register_handler(PrivilegedUsersHandler);
+        handlers.register_handler(FileSearch);
+        handlers.register_handler(ConnectToPeerHandler);
         handlers
     }
 
-    fn add_server_handlers(&mut self) {
-        self.register_handler(LoginHandler);
-        self.register_handler(RoomListHandler);
-        self.register_handler(ExcludedSearchPhrasesHandler);
-        self.register_handler(PrivilegedUsersHandler);
-        self.register_handler(MessageUser);
-        self.register_handler(WishListIntervalHandler);
-        self.register_handler(ParentMinSpeedHandler);
-        self.register_handler(ParentSpeedRatioHandler);
-        self.register_handler(PrivilegedUsersHandler);
-        self.register_handler(FileSearch);
-        self.register_handler(ConnectToPeerHandler);
-    }
-
-    pub fn register_handler<H: 'static + MessageHandler + Send + Sync>(
-        &mut self,
-        handler: H,
-    ) -> &mut Self {
+    /// Register a handler for this particular `Op`.
+    pub fn register_handler<H>(&mut self, handler: H) -> &mut Self
+    where
+        H: 'static + MessageHandler<Op> + Send + Sync,
+    {
         self.handlers.insert(handler.get_code(), Box::new(handler));
         self
     }
-    pub fn get_handler(&self, code: u8) -> Option<&Box<dyn MessageHandler>> {
+    pub fn get_handler(&self, code: u8) -> Option<&Box<dyn MessageHandler<Op>>> {
         self.handlers.get(&code)
     }
 }

src/message/server/connect_to_peer.rs

@@ -1,4 +1,5 @@
 use crate::message::{Message, MessageHandler};
+use crate::peer::Peer;
 use crate::server::ServerOperation;
 use std::sync::mpsc::Sender;
 pub struct ConnectToPeerHandler;
@@ -6,35 +7,8 @@ impl MessageHandler for ConnectToPeerHandler {
     fn get_code(&self) -> u8 {
         18
     }
-    fn handle(&self, _message: &mut Message, _sender: Sender<ServerOperation>) {
-        println!("Handling ConnectToPeer message");
-        // let username = message.read_string();
-        // let connection_type = message.read_string();
-        // let mut ip: Vec<i8> = vec![];
-        // for _ in 0..4 {
-        //     ip.push(message.read_int8());
-        // }
-        // let host: String = format!("{}.{}.{}.{}", ip[3], ip[2], ip[1], ip[0]);
-        //
-        // let (port, token, privileged, unknown, obfuscated_port) = (
-        //     message.read_int32(),
-        //     message.read_int32(),
-        //     message.read_int8(),
-        //     message.read_int8(),
-        //     message.read_int8(),
-        // );
-        //
-        // let peer = Peer::new(
-        //     username,
-        //     connection_type,
-        //     host,
-        //     port,
-        //     token,
-        //     privileged,
-        //     unknown,
-        //     obfuscated_port,
-        // );
-        //
-        // sender.send(ServerOperation::ConnectToPeer(peer)).unwrap();
+    fn handle(&self, message: &mut Message, sender: Sender<ServerOperation>) {
+        let peer = Peer::new_from_message(message);
+        sender.send(ServerOperation::ConnectToPeer(peer)).unwrap();
     }
 }

src/message/server/login.rs

@@ -1,13 +1,14 @@
 use std::sync::mpsc::Sender;
 
-use crate::{
-    message::{Message, MessageHandler},
-    server::ServerOperation,
-};
+use crate::{message::Message, server::ServerOperation};
+
+// IMPORTANT: note the generic trait is now `MessageHandler<ServerOperation>`
+use crate::message::MessageHandler;
 
 pub struct LoginHandler;
 
-impl MessageHandler for LoginHandler {
+// Implement `MessageHandler` specifically for `ServerOperation`.
+impl MessageHandler<ServerOperation> for LoginHandler {
     fn get_code(&self) -> u8 {
         1
     }
@@ -21,7 +22,7 @@ impl MessageHandler for LoginHandler {
 
         println!("Login successful");
         let greeting = message.read_string();
-        println!("Server geeting: {:?}", greeting);
+        println!("Server greeting: {:?}", greeting);
 
         sender.send(ServerOperation::LoginStatus(true)).unwrap();
     }