fix: send of command and events ---> cannot send Any

Author: Bordi00

src/packet_processor.rs

@@ -1,17 +1,16 @@
-use crate::{network::NetworkError, FragmentAssembler, RoutingHandler};
-use std::any::Any;
+use crate::{network::NetworkError, types::Command, FragmentAssembler, RoutingHandler};
 
 use crossbeam_channel::{select_biased, Receiver};
 use wg_internal::{network::NodeId, packet::{Packet, PacketType}};
 
-pub trait Processor {
-    fn controller_recv(&self) -> &Receiver<Box<dyn Any>>;
+pub trait Processor: Send {
+    fn controller_recv(&self) -> &Receiver<Box<dyn Command>>;
     fn packet_recv(&self) -> &Receiver<Packet>;
     fn assembler(&mut self) -> &mut FragmentAssembler;
     fn routing_handler(&mut self) -> &mut RoutingHandler;
 
     fn handle_msg(&mut self, msg: Vec<u8>, from: NodeId, session_id: u64);
-    fn handle_command(&mut self, cmd: Box<dyn Any>) -> bool;
+    fn handle_command(&mut self, cmd: Box<dyn Command>) -> bool;
 
     /// Handles a packet in a standard way
     /// # Errors

src/routing_handler.rs

@@ -1,12 +1,9 @@
 use crate::{
     network::{Network, NetworkError, Node},
-    types::NodeEvent,
+    types::{Event, NodeEvent},
 };
 use crossbeam_channel::Sender;
-use std::{
-    any::Any,
-    collections::{HashMap, HashSet},
-};
+use std::collections::{HashMap, HashSet};
 use wg_internal::{
     network::{NodeId, SourceRoutingHeader},
     packet::{Ack, FloodRequest, FloodResponse, Fragment, Nack, NackType, NodeType, Packet},
@@ -85,7 +82,7 @@ pub struct RoutingHandler {
     flood_seen: HashSet<(u64, NodeId)>,
     session_counter: u64,
     flood_counter: u64,
-    controller_send: Sender<Box<dyn Any>>,
+    controller_send: Sender<Box<dyn Event>>,
     buffer: Buffer,
 }
 
@@ -95,7 +92,7 @@ impl RoutingHandler {
         id: NodeId,
         node_type: NodeType,
         neighbors: HashMap<NodeId, Sender<Packet>>,
-        controller_send: Sender<Box<dyn Any>>,
+        controller_send: Sender<Box<dyn Event>>,
     ) -> Self {
         Self {
             id,
@@ -506,6 +503,7 @@ mod routing_handler_tests {
         handler.start_flood().unwrap();
 
         let packet = receiver.try_recv().unwrap();
+        let packet = packet.into_any();
         if let Ok(cmd) = packet.downcast::<NodeEvent>() {
             assert!(matches!(*cmd, NodeEvent::FloodStarted(_, _)));
         }
@@ -566,7 +564,7 @@ mod routing_handler_tests {
         handler.handle_ack(&ack, 1, 2);
     }
 
-    fn create_test_routing_handler() -> (RoutingHandler, Receiver<Box<dyn Any>>) {
+    fn create_test_routing_handler() -> (RoutingHandler, Receiver<Box<dyn Event>>) {
         let (controller_send, controller_recv) = unbounded();
         let (neighbor_send, _) = unbounded();
         let mut neighbors = HashMap::new();

src/types.rs

@@ -1,3 +1,4 @@
+use std::any::Any;
 use std::{collections::HashMap, str::FromStr};
 use std::fmt::Display;
 use anyhow::anyhow;
@@ -243,13 +244,44 @@ impl Message {
     }
 }
 
+pub trait Command: Send {
+    fn as_any(&self) -> &dyn Any;
+    fn into_any(self: Box<Self>) -> Box<dyn Any>;
+
+}
+
+impl<T: 'static + Send> Command for T {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn into_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+
+pub trait Event: Send {
+    fn as_any(&self) -> &dyn Any;
+    fn into_any(self: Box<Self>) -> Box<dyn Any>;
+}
+
+impl<T: 'static + Send> Event for T {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn into_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum ChatCommand {
     GetChatsHistory,
     GetRegisteredClients,
     SendMessage(Message)
 }
 
+
 #[derive(Debug, Clone)]
 pub enum ChatEvent {
     ChatHistory(HashMap<NodeId, Vec<Message>>),
@@ -274,6 +306,7 @@ pub enum WebCommand {
     RemoveMediaFile(Uuid),
 }
 
+
 #[derive(Debug, Clone)]
 pub enum WebEvent {
     CachedFiles(Vec<File>),
@@ -305,6 +338,7 @@ pub enum NodeCommand {
     Shutdown,
 }
 
+
 impl NodeCommand {
     #[must_use]
     pub fn as_add_sender(self) -> Option<(NodeId, Sender<Packet>)> {