fix: added some explaination on the readme

Author: Bordi00

README.md

@@ -1 +1,78 @@
-# common
+# Common
+This library contains all the code that is common between each component (clients and servers).
+
+## How to Instantiate a generic Node (client or server)
+It follows an example implementation of a generic Node (in this case a Server):
+
+```rust
+pub struct Server {
+    routing_handler: RoutingHandler,
+    received_messages: Vec<(String, String)>,
+    communication_server: Vec<NodeId>,
+    controller_recv: Receiver<Box<dyn Any>>,
+    packet_recv: Receiver<Packet>,
+    assembler: FragmentAssembler,
+    ...
+}
+
+impl Server {
+    #[must_use]
+    pub fn new(
+        id: NodeId,
+        neighbors: HashMap<NodeId, Sender<Packet>>,
+        packet_recv: Receiver<Packet>,
+        controller_recv: Receiver<Box<dyn Any>>,
+        controller_send: Sender<Box<dyn Any>>,
+        ...
+    ) -> Self {
+        let routing_handler = RoutingHandler::new(id, NodeType::Client, neighbors, controller_send);
+
+        Self {
+            routing_handler,
+            received_messages: vec![],
+            communication_server: vec![],
+            controller_recv,
+            packet_recv,
+            assembler: FragmentAssembler::default()
+            ...
+        }
+    }
+}
+
+
+impl Processor for Server {
+    fn controller_recv(&self) -> &Receiver<Box<dyn Any>> {
+        &self.controller_recv
+    }
+
+    fn packet_recv(&self) -> &Receiver<Packet> {
+        &self.packet_recv
+    }
+
+    fn handle_command(&mut self, cmd: Box<dyn Any>) {
+        if let Ok(cmd) = cmd.downcast::<ServerCommand>() {
+            match *cmd {
+                // match on server command
+            }
+        }
+
+    }
+
+    fn assembler(&mut self) -> &mut FragmentAssembler {
+        &mut self.assembler
+    }
+
+    fn routing_header(&mut self) -> &mut RoutingHandler {
+        &mut self.routing_handler
+    }
+
+    fn handle_msg(&mut self, msg: Vec<u8>) {
+
+        if let Ok(msg) = serde_json::from_slice::<ClientRequest>(&msg) {
+            match msg {
+                // match on ClientRequest
+            }
+        }
+    }
+}
+```

src/routing_handler.rs

@@ -266,12 +266,7 @@ impl RoutingHandler {
             NackType::UnexpectedRecipient(_) => todo!(),
         }
 
-        if let Some(packet) =
-            self.buffer
-                .get_fragment_by_id(session_id, nack.fragment_index, source_id)
-        {
-            self.try_send(packet)?;
-        }
+        self.retry_send(session_id, nack.fragment_index, source_id)?;
 
         Ok(())
     }
@@ -341,7 +336,6 @@ impl RoutingHandler {
         destination: NodeId,
         session_id: Option<u64>,
     ) -> Result<(), NetworkError> {
-        // devo inviare con lo stesso session_id del packetto o con il mio??????????
         let chunks: Vec<&[u8]> = message.chunks(128).collect();
         let total_n_fragments = chunks.len();
 
@@ -375,7 +369,11 @@ impl RoutingHandler {
 
             self.try_send(packet.clone())?;
             let session_id = packet.session_id;
-            self.buffer.insert(packet, session_id, self.id);
+            self.buffer.insert(
+                packet,
+                session_id,
+                self.id
+            );
         }
 
         Ok(())
@@ -452,25 +450,29 @@ mod tests {
         assert!(!handler.network_view.nodes[0].get_adjacents().contains(&2));
     }
 
-    // #[test]
-    // fn test_start_flood() {
-    //     let (sender, receiver) = unbounded();
-    //     let mut handler = RoutingHandler::new(1, NodeType::Client, HashMap::new(), sender);
-    //
-    //     let (neighbor_sender, neighbor_receiver) = unbounded();
-    //     handler.add_neighbor(2, neighbor_sender);
-    //
-    //     handler.start_flood().unwrap();
-    //
-    //     let packet = receiver.try_recv().unwrap();
-    //     assert!(matches!(packet.try_into().unwrap(), NodeEvent::FloodStarted(_, _)));
-    //
-    //     let neighbor_packet = neighbor_receiver.try_recv().unwrap();
-    //     assert!(matches!(
-    //         neighbor_packet.pack_type,
-    //         PacketType::FloodRequest(_)
-    //     ));
-    // }
+    #[test]
+    fn test_start_flood() {
+        let (sender, receiver) = unbounded();
+        let mut handler = RoutingHandler::new(1, NodeType::Client, HashMap::new(), sender);
+
+        let (neighbor_sender, neighbor_receiver) = unbounded();
+        handler.add_neighbor(2, neighbor_sender);
+
+        handler.start_flood().unwrap();
+
+        let packet = receiver.try_recv().unwrap();
+        if let Ok(cmd) = packet.downcast::<NodeEvent>() {
+
+            assert!(matches!(*cmd, NodeEvent::FloodStarted(_, _)));
+
+        }
+
+        let neighbor_packet = neighbor_receiver.try_recv().unwrap();
+        assert!(matches!(
+            neighbor_packet.pack_type,
+            PacketType::FloodRequest(_)
+        ));
+    }
 
     #[test]
     fn test_handle_flood_response() {
@@ -505,22 +507,22 @@ mod tests {
         assert!(matches!(packet.pack_type, PacketType::MsgFragment(_)));
     }
 
-    // #[test]
-    // fn test_handle_ack() {
-    //     let (sender, _receiver) = unbounded();
-    //     let mut handler = RoutingHandler::new(1, NodeType::Client, HashMap::new(), sender);
-    //
-    //     let (neighbor_sender, _neighbor_receiver) = unbounded();
-    //     handler.add_neighbor(2, neighbor_sender);
-    //
-    //     let message = b"Hello, world!".to_vec();
-    //     handler.send_message(&message, 2).unwrap();
-    //
-    //     let ack = Ack {
-    //         fragment_index: 0,
-    //     };
-    //
-    //     handler.handle_ack(&ack, 1, 2);
-    //
-    // }
+    #[test]
+    fn test_handle_ack() {
+        let (sender, _receiver) = unbounded();
+        let mut handler = RoutingHandler::new(1, NodeType::Client, HashMap::new(), sender);
+
+        let (neighbor_sender, _neighbor_receiver) = unbounded();
+        handler.add_neighbor(2, neighbor_sender);
+
+        let message = b"Hello, world!".to_vec();
+        handler.send_message(&message, 2, None).unwrap();
+
+        let ack = Ack {
+            fragment_index: 0,
+        };
+
+        handler.handle_ack(&ack, 1, 2);
+
+    }
 }

src/types.rs

@@ -85,5 +85,5 @@ pub enum ClientType {
 #[derive(Debug, Clone, PartialEq)]
 pub enum ServerType {
     ChatServer,
-    WebServer,
+    MediaServer,
 }