From 638061b8a8901e28ce5b2a5b1e0e30e241570a69 Mon Sep 17 00:00:00 2001 From: Linus Gasser Date: Mon, 14 Oct 2024 20:28:10 +0200 Subject: [PATCH] Renaming messages - The wrapper of module messages gets renamed from NodeMessage to NetworkWrapper - The messages between the same modules of two different nodes gets renamed from MessageNode and others to ModuleMessage - Renamed some of the NetworkIn and NetworkOut messages --- CHANGELOG.md | 1 + examples/ping-pong/shared/src/event_loop.rs | 10 +++--- examples/ping-pong/shared/src/handler.rs | 18 +++++----- examples/ping/src/main.rs | 6 ++-- flmodules/src/gossip_events/broker.rs | 18 +++++----- flmodules/src/gossip_events/messages.rs | 36 ++++++++++---------- flmodules/src/network/messages.rs | 36 ++++++++++---------- flmodules/src/network/mod.rs | 2 +- flmodules/src/network/testing.rs | 8 ++--- flmodules/src/overlay/broker.rs | 10 +++--- flmodules/src/ping/broker.rs | 8 ++--- flmodules/src/ping/messages.rs | 18 +++++----- flmodules/src/random_connections/broker.rs | 14 ++++---- flmodules/src/random_connections/messages.rs | 26 +++++++------- flmodules/src/template/broker.rs | 12 +++---- flmodules/src/template/messages.rs | 22 ++++++------ flmodules/src/web_proxy/broker.rs | 4 +-- flmodules/src/web_proxy/messages.rs | 36 ++++++++++---------- flmodules/tests/load.rs | 6 ++-- flnode/src/node.rs | 2 +- flnode/tests/helpers/mod.rs | 6 ++-- test/webrtc-libc-wasm/libc/src/main.rs | 6 ++-- test/webrtc-libc-wasm/wasm/src/lib.rs | 8 ++--- 23 files changed, 157 insertions(+), 156 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cf96d640..09b54aa6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,7 @@ Following https://keepachangelog.com/en/1.1.0/ and using - re-arranged file names in the flmodules section, to better fit with the `template` module - changed the names of the networking messages - added an `Overlay` module to abstract the network handling +- more changes in names of the messages to remove ambiguities ## [0.8.0] - 2024-09-09 diff --git a/examples/ping-pong/shared/src/event_loop.rs b/examples/ping-pong/shared/src/event_loop.rs index 2c47ac34..8ae1ea6f 100644 --- a/examples/ping-pong/shared/src/event_loop.rs +++ b/examples/ping-pong/shared/src/event_loop.rs @@ -59,10 +59,10 @@ fn update_list( net: &mut Broker, nodes: &Vec, ) -> Result<(), BrokerError> { - net.emit_msg(NetworkMessage::Input(NetworkIn::SendWSUpdateListRequest))?; + net.emit_msg(NetworkMessage::Input(NetworkIn::WSUpdateListRequest))?; for node in nodes.iter() { if node.get_id() != id { - net.emit_msg(NetworkMessage::Input(NetworkIn::SendNodeMessage( + net.emit_msg(NetworkMessage::Input(NetworkIn::MessageToNode( node.get_id(), serde_json::to_string(&PPMessageNode::Ping).unwrap(), )))?; @@ -79,18 +79,18 @@ fn new_msg( ) -> Result>, BrokerError> { if let Some(NetworkMessage::Output(msg_tap)) = msg { match msg_tap { - NetworkOut::RcvNodeMessage(from, msg_net) => { + NetworkOut::MessageFromNode(from, msg_net) => { if let Ok(msg) = serde_json::from_str::(&msg_net) { ret.emit_msg(PPMessage::FromNetwork(from, msg.clone()))?; if msg == PPMessageNode::Ping { - net.emit_msg(NetworkMessage::Input(NetworkIn::SendNodeMessage( + net.emit_msg(NetworkMessage::Input(NetworkIn::MessageToNode( from, serde_json::to_string(&PPMessageNode::Pong).unwrap(), )))?; } } } - NetworkOut::RcvWSUpdateList(list) => { + NetworkOut::NodeListFromWS(list) => { ret.emit_msg(PPMessage::List(list.clone()))?; return Ok(Some(list)); } diff --git a/examples/ping-pong/shared/src/handler.rs b/examples/ping-pong/shared/src/handler.rs index 39bd84bc..437db712 100644 --- a/examples/ping-pong/shared/src/handler.rs +++ b/examples/ping-pong/shared/src/handler.rs @@ -60,19 +60,19 @@ impl PingPong { } // Translates incoming messages from the network to messages that can be understood by PingPong. - // The only two messages that need to be interpreted are RcvNodeMessage and RcvWSUpdateList. - // For RcvNodeMessage, the enclosed message is interpreted as a PPMessageNode and sent to this + // The only two messages that need to be interpreted are MessageFromNode and NodeListFromWS. + // For MessageFromNode, the enclosed message is interpreted as a PPMessageNode and sent to this // broker. // All other messages coming from Network are ignored. fn net_to_pp(msg: NetworkMessage) -> Option { if let NetworkMessage::Output(rep) = msg { match rep { - NetworkOut::RcvNodeMessage(from, node_msg) => { + NetworkOut::MessageFromNode(from, node_msg) => { serde_json::from_str::(&node_msg) .ok() .map(|ppm| PPMessage::FromNetwork(from, ppm)) } - NetworkOut::RcvWSUpdateList(nodes) => Some(PPMessage::List(nodes)), + NetworkOut::NodeListFromWS(nodes) => Some(PPMessage::List(nodes)), _ => None, } } else { @@ -91,7 +91,7 @@ impl PingPong { // Wraps a PPMessageNode into a json and sends it over the network to the // dst address. async fn send_net_ppm(&mut self, dst: U256, msg: &PPMessageNode) { - self.send_net(NetworkIn::SendNodeMessage( + self.send_net(NetworkIn::MessageToNode( dst, serde_json::to_string(msg).unwrap(), )) @@ -115,7 +115,7 @@ impl SubsystemHandler for PingPong { } PPMessage::FromNetwork(from, PPMessageNode::Ping) => { self.send_net_ppm(from, &PPMessageNode::Pong).await; - self.send_net(NetworkIn::SendWSUpdateListRequest).await; + self.send_net(NetworkIn::WSUpdateListRequest).await; } PPMessage::List(list) => self.nodes = list, PPMessage::Tick => { @@ -185,7 +185,7 @@ mod test { // Receive a ping message through the network net.emit_msg_dest( Destination::NoTap, - NetworkMessage::Output(NetworkOut::RcvNodeMessage( + NetworkMessage::Output(NetworkOut::MessageFromNode( dst_id.clone(), serde_json::to_string(&PPMessageNode::Ping).unwrap(), )), @@ -199,7 +199,7 @@ mod test { net_tap.recv().unwrap() ); assert_eq!( - NetworkMessage::Input(NetworkIn::SendWSUpdateListRequest), + NetworkMessage::Input(NetworkIn::WSUpdateListRequest), net_tap.recv().unwrap() ); @@ -207,7 +207,7 @@ mod test { } fn node_msg(dst: &U256, msg: &PPMessageNode) -> NetworkMessage { - NetworkMessage::Input(NetworkIn::SendNodeMessage( + NetworkMessage::Input(NetworkIn::MessageToNode( dst.clone(), serde_json::to_string(msg).unwrap(), )) diff --git a/examples/ping/src/main.rs b/examples/ping/src/main.rs index cc2c9d3e..6c59fad5 100644 --- a/examples/ping/src/main.rs +++ b/examples/ping/src/main.rs @@ -61,9 +61,9 @@ async fn ping() -> Result<(), BrokerError> { msg = net.recv() => { match msg { // Display the messages received - NetworkOut::RcvNodeMessage(from, msg) => log::info!("Got message {msg:?} from node {from}"), + NetworkOut::MessageFromNode(from, msg) => log::info!("Got message {msg:?} from node {from}"), // If a new list is available, ping all nodes in the list - NetworkOut::RcvWSUpdateList(list) => for node in list { + NetworkOut::NodeListFromWS(list) => for node in list { if node.get_id() != nc.info.get_id() { // Sends a text message to the 'node' if it's not ourselves net.send_msg(node.get_id(), "Ping".into())? @@ -113,7 +113,7 @@ async fn client(server_id: &str) -> Result<(), BrokerError> { log::info!("Server id is {server_id:?}"); // This sends the message by setting up a connection using the signalling server. // The client must already be running and be registered with the signalling server. - // Using `SendNodeMessage` will set up a connection using the signalling server, but + // Using `MessageToNode` will set up a connection using the signalling server, but // in the best case, the signalling server will not be used anymore afterwards. net.send_msg(server_id, "ping".into())?; diff --git a/flmodules/src/gossip_events/broker.rs b/flmodules/src/gossip_events/broker.rs index a1e304c2..a3998488 100644 --- a/flmodules/src/gossip_events/broker.rs +++ b/flmodules/src/gossip_events/broker.rs @@ -119,9 +119,9 @@ impl Translate { if let RandomMessage::Output(msg_out) = msg { match msg_out { RandomOut::NodeIDsConnected(list) => Some(GossipIn::NodeList(list.into()).into()), - RandomOut::NodeMessageFromNetwork(id, msg) => msg + RandomOut::NetworkWrapperFromNetwork(id, msg) => msg .unwrap_yaml(MODULE_NAME) - .map(|msg| GossipIn::Node(id, msg).into()), + .map(|msg| GossipIn::FromNetwork(id, msg).into()), _ => None, } } else { @@ -130,9 +130,9 @@ impl Translate { } fn link_gossip_rnd(msg: GossipMessage) -> Option { - if let GossipMessage::Output(GossipOut::Node(id, msg_node)) = msg { + if let GossipMessage::Output(GossipOut::ToNetwork(id, msg_node)) = msg { Some( - RandomIn::NodeMessageToNetwork( + RandomIn::NetworkMapperToNetwork( id, NetworkWrapper::wrap_yaml(MODULE_NAME, &msg_node).unwrap(), ) @@ -184,7 +184,7 @@ mod tests { use std::error::Error; use crate::gossip_events::core::{Category, Event}; - use crate::gossip_events::messages::MessageNode; + use crate::gossip_events::messages::ModuleMessage; use flarch::nodeids::NodeID; use flarch::{start_logging, tasks::now}; @@ -213,10 +213,10 @@ mod tests { created: now(), msg: "test_msg".into(), }; - let msg = MessageNode::Events(vec![event.clone()]); + let msg = ModuleMessage::Events(vec![event.clone()]); broker_rnd .settle_msg( - RandomOut::NodeMessageFromNetwork( + RandomOut::NetworkWrapperFromNetwork( id2, NetworkWrapper::wrap_yaml(MODULE_NAME, &msg).unwrap(), ) @@ -233,11 +233,11 @@ mod tests { fn assert_msg_reid(tap: &Receiver, id2: &NodeID) -> Result<(), Box> { for msg in tap.try_iter() { - if let RandomMessage::Input(RandomIn::NodeMessageToNetwork(id, msg_mod)) = msg { + if let RandomMessage::Input(RandomIn::NetworkMapperToNetwork(id, msg_mod)) = msg { assert_eq!(id2, &id); assert_eq!(MODULE_NAME.to_string(), msg_mod.module); let msg_yaml = serde_yaml::from_str(&msg_mod.msg)?; - assert_eq!(MessageNode::RequestEventIDs, msg_yaml); + assert_eq!(ModuleMessage::RequestEventIDs, msg_yaml); } else { assert!(false); } diff --git a/flmodules/src/gossip_events/messages.rs b/flmodules/src/gossip_events/messages.rs index 394fc76a..345c8ee9 100644 --- a/flmodules/src/gossip_events/messages.rs +++ b/flmodules/src/gossip_events/messages.rs @@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize}; use super::core::*; #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub enum MessageNode { +pub enum ModuleMessage { KnownEventIDs(Vec), Events(Vec), RequestEventIDs, @@ -20,7 +20,7 @@ pub enum GossipMessage { #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] pub enum GossipIn { Tick, - Node(NodeID, MessageNode), + FromNetwork(NodeID, ModuleMessage), SetStorage(EventsStorage), GetStorage, AddEvent(Event), @@ -29,7 +29,7 @@ pub enum GossipIn { #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] pub enum GossipOut { - Node(NodeID, MessageNode), + ToNetwork(NodeID, ModuleMessage), Storage(EventsStorage), Updated, } @@ -86,7 +86,7 @@ impl GossipEvents { log::trace!("{} got message {:?}", self.cfg.our_id, msg); Ok(match msg { GossipIn::Tick => self.tick(), - GossipIn::Node(src, node_msg) => self.process_node_message(src, node_msg), + GossipIn::FromNetwork(src, node_msg) => self.process_node_message(src, node_msg), GossipIn::AddEvent(ev) => self.add_event(ev), GossipIn::NodeList(ids) => self.node_list(ids), GossipIn::GetStorage => vec![GossipOut::Storage(self.storage.clone())], @@ -99,12 +99,12 @@ impl GossipEvents { /// Processes a node to node message and returns zero or more /// MessageOut. - pub fn process_node_message(&mut self, src: NodeID, msg: MessageNode) -> Vec { + pub fn process_node_message(&mut self, src: NodeID, msg: ModuleMessage) -> Vec { match msg { - MessageNode::KnownEventIDs(ids) => self.node_known_event_ids(src, ids), - MessageNode::Events(events) => self.node_events(src, events), - MessageNode::RequestEvents(ids) => self.node_request_events(src, ids), - MessageNode::RequestEventIDs => self.node_request_event_list(src), + ModuleMessage::KnownEventIDs(ids) => self.node_known_event_ids(src, ids), + ModuleMessage::Events(events) => self.node_events(src, events), + ModuleMessage::RequestEvents(ids) => self.node_request_events(src, ids), + ModuleMessage::RequestEventIDs => self.node_request_event_list(src), } } @@ -136,9 +136,9 @@ impl GossipEvents { .iter() .filter(|&&node_id| node_id != src && node_id != self.cfg.our_id) .map(|node_id| { - GossipOut::Node( + GossipOut::ToNetwork( *node_id, - MessageNode::KnownEventIDs( + ModuleMessage::KnownEventIDs( events .iter() .filter_map(|e| { @@ -162,7 +162,7 @@ impl GossipEvents { .0 .iter() .filter(|&id| !self.nodes.0.contains(id) && id != &self.cfg.our_id) - .map(|&id| GossipOut::Node(id, MessageNode::RequestEventIDs)) + .map(|&id| GossipOut::ToNetwork(id, ModuleMessage::RequestEventIDs)) .collect(); self.nodes = ids; reply @@ -175,9 +175,9 @@ impl GossipEvents { let unknown_ids = self.filter_known_events(ids); if !unknown_ids.is_empty() { self.outstanding.extend(unknown_ids.clone()); - return vec![GossipOut::Node( + return vec![GossipOut::ToNetwork( src, - MessageNode::RequestEvents(unknown_ids), + ModuleMessage::RequestEvents(unknown_ids), )]; } vec![] @@ -204,7 +204,7 @@ impl GossipEvents { pub fn node_request_events(&mut self, src: NodeID, ids: Vec) -> Vec { let events: Vec = self.storage.get_events_by_ids(ids); if !events.is_empty() { - vec![GossipOut::Node(src, MessageNode::Events(events))] + vec![GossipOut::ToNetwork(src, ModuleMessage::Events(events))] } else { vec![] } @@ -212,9 +212,9 @@ impl GossipEvents { /// Returns the list of known events. pub fn node_request_event_list(&mut self, src: NodeID) -> Vec { - vec![GossipOut::Node( + vec![GossipOut::ToNetwork( src, - MessageNode::KnownEventIDs(self.storage.event_ids()), + ModuleMessage::KnownEventIDs(self.storage.event_ids()), )] } @@ -237,7 +237,7 @@ impl GossipEvents { self.nodes .0 .iter() - .map(|id| GossipOut::Node(*id, MessageNode::RequestEventIDs)) + .map(|id| GossipOut::ToNetwork(*id, ModuleMessage::RequestEventIDs)) .collect() } } diff --git a/flmodules/src/network/messages.rs b/flmodules/src/network/messages.rs index f5c93d6b..f866c5d1 100644 --- a/flmodules/src/network/messages.rs +++ b/flmodules/src/network/messages.rs @@ -62,12 +62,12 @@ pub enum NetworkIn { /// The [`NetworkBroker`] will try to set up a connection with the remote node, /// if no such connection exists yet. /// If the node is not connected to the signalling handler, nothing happens. - SendNodeMessage(NodeID, String), + MessageToNode(NodeID, String), /// Sends some stats to the signalling server to monitor the overall health of /// the system. - SendWSStats(Vec), + StatsToWS(Vec), /// Requests a new list of currenlty connected nodes to the signalling server. - SendWSUpdateListRequest, + WSUpdateListRequest, /// Connect to the given node. /// If the node is not connected to the signalling server, no connection is made, /// and no error is produced. @@ -84,9 +84,9 @@ pub enum NetworkIn { /// Messages sent from the [`NetworkBroker`] to the user. pub enum NetworkOut { /// A new message has been received from the given node. - RcvNodeMessage(NodeID, String), + MessageFromNode(NodeID, String), /// An updated list coming from the signalling server. - RcvWSUpdateList(Vec), + NodeListFromWS(Vec), /// Whenever the state of a connection changes, this message is /// sent to the user. ConnectionState(NetworkConnectionState), @@ -118,7 +118,7 @@ impl Network { return Err(NetworkError::SignallingServer); } msg = tap.recv() => { - if matches!(msg, Some(NetworkMessage::Output(NetworkOut::RcvWSUpdateList(_)))){ + if matches!(msg, Some(NetworkMessage::Output(NetworkOut::NodeListFromWS(_)))){ break; } } @@ -150,12 +150,12 @@ impl Network { /// The [`NetworkBroker`] will start a connection with the node if there is none available. /// If the remote node is not available, no error is returned. pub fn send_msg(&mut self, dst: NodeID, msg: String) -> Result<(), BrokerError> { - self.send(NetworkIn::SendNodeMessage(dst, msg)) + self.send(NetworkIn::MessageToNode(dst, msg)) } /// Requests an updated list of all connected nodes to the signalling server. pub fn send_list_request(&mut self) -> Result<(), BrokerError> { - self.send(NetworkIn::SendWSUpdateListRequest) + self.send(NetworkIn::WSUpdateListRequest) } } @@ -260,7 +260,7 @@ impl NetworkBroker { ] } WSSignalMessageToNode::ListIDsReply(list) => { - vec![NetworkOut::RcvWSUpdateList(list).into()] + vec![NetworkOut::NodeListFromWS(list).into()] } WSSignalMessageToNode::PeerSetup(pi) => { let own_id = self.node_config.info.get_id(); @@ -288,7 +288,7 @@ impl NetworkBroker { async fn msg_call(&mut self, msg: NetworkIn) -> Result, NetworkError> { match msg { - NetworkIn::SendNodeMessage(id, msg_str) => { + NetworkIn::MessageToNode(id, msg_str) => { log::trace!( "msg_call: {}->{}: {:?} / {:?}", self.node_config.info.get_id(), @@ -306,8 +306,8 @@ impl NetworkBroker { vec![NetworkMessage::from_nc(NCInput::Text(msg_str), id)], ])) } - NetworkIn::SendWSStats(ss) => Ok(WSSignalMessageFromNode::NodeStats(ss.clone()).into()), - NetworkIn::SendWSUpdateListRequest => Ok(WSSignalMessageFromNode::ListIDsRequest.into()), + NetworkIn::StatsToWS(ss) => Ok(WSSignalMessageFromNode::NodeStats(ss.clone()).into()), + NetworkIn::WSUpdateListRequest => Ok(WSSignalMessageFromNode::ListIDsRequest.into()), NetworkIn::Connect(id) => Ok(self.connect(&id)), NetworkIn::Disconnect(id) => Ok(self.disconnect(&id).await), NetworkIn::Tick => { @@ -326,7 +326,7 @@ impl NetworkBroker { match msg_nc { NCOutput::Connected(_) => vec![NetworkOut::Connected(id).into()], NCOutput::Disconnected(_) => vec![NetworkOut::Disconnected(id).into()], - NCOutput::Text(msg) => vec![NetworkOut::RcvNodeMessage(id, msg).into()], + NCOutput::Text(msg) => vec![NetworkOut::MessageFromNode(id, msg).into()], NCOutput::State(dir, state) => { vec![NetworkOut::ConnectionState(NetworkConnectionState { id, @@ -457,9 +457,9 @@ impl NetworkMessage { impl fmt::Display for NetworkIn { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - NetworkIn::SendNodeMessage(_, _) => write!(f, "SendNodeMessage()"), - NetworkIn::SendWSStats(_) => write!(f, "SendWSStats()"), - NetworkIn::SendWSUpdateListRequest => write!(f, "SendWSUpdateListRequest"), + NetworkIn::MessageToNode(_, _) => write!(f, "MessageToNode()"), + NetworkIn::StatsToWS(_) => write!(f, "StatsToWS()"), + NetworkIn::WSUpdateListRequest => write!(f, "WSUpdateListRequest"), NetworkIn::Connect(_) => write!(f, "Connect()"), NetworkIn::Disconnect(_) => write!(f, "Disconnect()"), NetworkIn::Tick => write!(f, "Tick"), @@ -484,8 +484,8 @@ impl From for Vec { impl fmt::Display for NetworkOut { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - NetworkOut::RcvNodeMessage(_, _) => write!(f, "RcvNodeMessage()"), - NetworkOut::RcvWSUpdateList(_) => write!(f, "RcvWSUpdateList()"), + NetworkOut::MessageFromNode(_, _) => write!(f, "MessageFromNode()"), + NetworkOut::NodeListFromWS(_) => write!(f, "NodeListFromWS()"), NetworkOut::ConnectionState(_) => write!(f, "ConnectionState()"), NetworkOut::Connected(_) => write!(f, "Connected()"), NetworkOut::Disconnected(_) => write!(f, "Disconnected()"), diff --git a/flmodules/src/network/mod.rs b/flmodules/src/network/mod.rs index 7dfd06ec..11928d12 100644 --- a/flmodules/src/network/mod.rs +++ b/flmodules/src/network/mod.rs @@ -88,7 +88,7 @@ //! log::info!("Server id is {server_id:?}"); //! // This sends the message by setting up a connection using the signalling server. //! // The client must already be running and be registered with the signalling server. -//! // Using `SendNodeMessage` will set up a connection using the signalling server, but +//! // Using `MessageToNode` will set up a connection using the signalling server, but //! // in the best case, the signalling server will not be used anymore afterwards. //! net.send_msg(server_id, "ping".into())?; //! diff --git a/flmodules/src/network/testing.rs b/flmodules/src/network/testing.rs index 8b264e14..0f6c9186 100644 --- a/flmodules/src/network/testing.rs +++ b/flmodules/src/network/testing.rs @@ -73,16 +73,16 @@ impl NSHub { fn net_msg(&self, id: U256, net_msg: NetworkMessage) -> Vec { if let NetworkMessage::Input(msg) = net_msg { match msg { - NetworkIn::SendNodeMessage(id_dst, msg_node) => { + NetworkIn::MessageToNode(id_dst, msg_node) => { vec![NSHubMessage::ToClient( id_dst, - NetworkMessage::Output(NetworkOut::RcvNodeMessage(id, msg_node)), + NetworkMessage::Output(NetworkOut::MessageFromNode(id, msg_node)), )] } - NetworkIn::SendWSUpdateListRequest => { + NetworkIn::WSUpdateListRequest => { vec![NSHubMessage::ToClient( id, - NetworkMessage::Output(NetworkOut::RcvWSUpdateList(self.nodes.clone())), + NetworkMessage::Output(NetworkOut::NodeListFromWS(self.nodes.clone())), )] } _ => { diff --git a/flmodules/src/overlay/broker.rs b/flmodules/src/overlay/broker.rs index 68556733..c97c20c4 100644 --- a/flmodules/src/overlay/broker.rs +++ b/flmodules/src/overlay/broker.rs @@ -32,7 +32,7 @@ impl OverlayRandom { RandomOut::NodeInfosConnected(infos) => { OverlayOut::NodeInfosConnected(infos) } - RandomOut::NodeMessageFromNetwork(id, module_message) => { + RandomOut::NetworkWrapperFromNetwork(id, module_message) => { OverlayOut::NetworkMapperFromNetwork(id, module_message) } _ => return None, @@ -45,7 +45,7 @@ impl OverlayRandom { if let OverlayMessage::Input(input) = msg { let ret = match input { OverlayIn::NetworkWrapperToNetwork(id, module_message) => { - RandomIn::NodeMessageToNetwork(id, module_message) + RandomIn::NetworkMapperToNetwork(id, module_message) } }; return Some(RandomMessage::Input(ret)); @@ -89,12 +89,12 @@ impl OverlayDirect { Box::new(|msg| { if let NetworkMessage::Output(out) = msg { return match out { - NetworkOut::RcvNodeMessage(id, msg_str) => { + NetworkOut::MessageFromNode(id, msg_str) => { serde_yaml::from_str(&msg_str).ok().map(|module_message| { OverlayOut::NetworkMapperFromNetwork(id, module_message).into() }) } - NetworkOut::RcvWSUpdateList(vec) => { + NetworkOut::NodeListFromWS(vec) => { Some(OverlayInternal::Available(vec).into()) } NetworkOut::Connected(id) => Some(OverlayInternal::Connected(id).into()), @@ -111,7 +111,7 @@ impl OverlayDirect { let ret = match input { OverlayIn::NetworkWrapperToNetwork(id, module_message) => { if let Ok(msg_str) = serde_yaml::to_string(&module_message) { - NetworkIn::SendNodeMessage(id, msg_str) + NetworkIn::MessageToNode(id, msg_str) } else { return None; } diff --git a/flmodules/src/ping/broker.rs b/flmodules/src/ping/broker.rs index 79fbb517..9d68a9d6 100644 --- a/flmodules/src/ping/broker.rs +++ b/flmodules/src/ping/broker.rs @@ -91,9 +91,9 @@ impl Translate { match msg_out { RandomOut::DisconnectNode(id) => Some(PingIn::DisconnectNode(id).into()), RandomOut::NodeIDsConnected(list) => Some(PingIn::NodeList(list.into()).into()), - RandomOut::NodeMessageFromNetwork(id, msg) => msg + RandomOut::NetworkWrapperFromNetwork(id, msg) => msg .unwrap_yaml(MODULE_NAME) - .map(|msg| PingIn::Message(id, msg).into()), + .map(|msg| PingIn::FromNetwork(id, msg).into()), _ => None, } } else { @@ -104,8 +104,8 @@ impl Translate { fn link_ping_rnd(msg: PingMessage) -> Option { if let PingMessage::Output(msg_out) = msg { match msg_out { - PingOut::Message(id, msg_node) => Some( - RandomIn::NodeMessageToNetwork( + PingOut::ToNetwork(id, msg_node) => Some( + RandomIn::NetworkMapperToNetwork( id, NetworkWrapper::wrap_yaml(MODULE_NAME, &msg_node).unwrap(), ) diff --git a/flmodules/src/ping/messages.rs b/flmodules/src/ping/messages.rs index 947806b8..1e38f355 100644 --- a/flmodules/src/ping/messages.rs +++ b/flmodules/src/ping/messages.rs @@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize}; use super::core::PingStorage; #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub enum MessageNode { +pub enum ModuleMessage { Ping, Pong, } @@ -18,14 +18,14 @@ pub enum PingMessage { #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] pub enum PingIn { Tick, - Message(NodeID, MessageNode), + FromNetwork(NodeID, ModuleMessage), NodeList(NodeIDs), DisconnectNode(NodeID), } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] pub enum PingOut { - Message(NodeID, MessageNode), + ToNetwork(NodeID, ModuleMessage), Storage(PingStorage), Failed(NodeID), } @@ -52,7 +52,7 @@ impl Ping { pub fn process_msg(&mut self, msg: PingIn) -> Vec { match msg { PingIn::Tick => self.tick(), - PingIn::Message(id, msg_node) => self.message(id, msg_node), + PingIn::FromNetwork(id, msg_node) => self.message(id, msg_node), PingIn::NodeList(ids) => self.new_nodes(ids), PingIn::DisconnectNode(id) => { self.storage.remove_node(&id); @@ -69,12 +69,12 @@ impl Ping { ]) } - pub fn message(&mut self, id: NodeID, msg: MessageNode) -> Vec { + pub fn message(&mut self, id: NodeID, msg: ModuleMessage) -> Vec { match msg { - MessageNode::Ping => { - vec![PingOut::Message(id, MessageNode::Pong)] + ModuleMessage::Ping => { + vec![PingOut::ToNetwork(id, ModuleMessage::Pong)] } - MessageNode::Pong => { + ModuleMessage::Pong => { self.storage.pong(id); self.create_messages() } @@ -91,7 +91,7 @@ impl Ping { fn create_messages(&mut self) -> Vec { let mut out = vec![]; for id in self.storage.ping.drain(..) { - out.push(PingOut::Message(id, MessageNode::Ping).into()); + out.push(PingOut::ToNetwork(id, ModuleMessage::Ping).into()); } for id in self.storage.failed.drain(..) { out.push(PingOut::Failed(id).into()); diff --git a/flmodules/src/random_connections/broker.rs b/flmodules/src/random_connections/broker.rs index 3d67b47b..f3b1533a 100644 --- a/flmodules/src/random_connections/broker.rs +++ b/flmodules/src/random_connections/broker.rs @@ -9,7 +9,7 @@ use flarch::{ use crate::{ network::messages::{NetworkIn, NetworkOut, NetworkMessage}, random_connections::{ - messages::{Config, NodeMessage, RandomConnections, RandomIn, RandomMessage, RandomOut}, + messages::{Config, ModuleMessage, RandomConnections, RandomIn, RandomMessage, RandomOut}, core::RandomStorage, }, timer::TimerMessage, @@ -82,12 +82,12 @@ impl Translate { Box::new(move |msg: NetworkMessage| { if let NetworkMessage::Output(msg_net) = msg { match msg_net { - NetworkOut::RcvNodeMessage(id, msg_str) => { - if let Ok(msg_rnd) = serde_yaml::from_str::(&msg_str) { - return Some(RandomIn::NodeMessageFromNetwork(id, msg_rnd).into()); + NetworkOut::MessageFromNode(id, msg_str) => { + if let Ok(msg_rnd) = serde_yaml::from_str::(&msg_str) { + return Some(RandomIn::NodeCommFromNetwork(id, msg_rnd).into()); } } - NetworkOut::RcvWSUpdateList(list) => { + NetworkOut::NodeListFromWS(list) => { return Some( RandomIn::NodeList( list.into_iter() @@ -113,9 +113,9 @@ impl Translate { match msg_out { RandomOut::ConnectNode(id) => return Some(NetworkIn::Connect(id).into()), RandomOut::DisconnectNode(id) => return Some(NetworkIn::Disconnect(id).into()), - RandomOut::NodeMessageToNetwork(id, msg) => { + RandomOut::NodeCommToNetwork(id, msg) => { let msg_str = serde_yaml::to_string(&msg).unwrap(); - return Some(NetworkIn::SendNodeMessage(id, msg_str).into()); + return Some(NetworkIn::MessageToNode(id, msg_str).into()); } _ => {} } diff --git a/flmodules/src/random_connections/messages.rs b/flmodules/src/random_connections/messages.rs index eeac7a4e..78554d0f 100644 --- a/flmodules/src/random_connections/messages.rs +++ b/flmodules/src/random_connections/messages.rs @@ -8,7 +8,7 @@ use crate::{nodeconfig::NodeInfo, overlay::messages::NetworkWrapper}; use super::core::RandomStorage; #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub enum NodeMessage { +pub enum ModuleMessage { Module(NetworkWrapper), DropConnection, } @@ -25,8 +25,8 @@ pub enum RandomIn { NodeFailure(NodeID), NodeConnected(NodeID), NodeDisconnected(NodeID), - NodeMessageFromNetwork(NodeID, NodeMessage), - NodeMessageToNetwork(NodeID, NetworkWrapper), + NodeCommFromNetwork(NodeID, ModuleMessage), + NetworkMapperToNetwork(NodeID, NetworkWrapper), Tick, } @@ -36,8 +36,8 @@ pub enum RandomOut { DisconnectNode(NodeID), NodeIDsConnected(NodeIDs), NodeInfosConnected(Vec), - NodeMessageToNetwork(NodeID, NodeMessage), - NodeMessageFromNetwork(NodeID, NetworkWrapper), + NodeCommToNetwork(NodeID, ModuleMessage), + NetworkWrapperFromNetwork(NodeID, NetworkWrapper), Storage(RandomStorage), } @@ -94,12 +94,12 @@ impl RandomConnections { self.update(), ]) } - RandomIn::NodeMessageFromNetwork(id, node_msg) => self.network_msg(id, node_msg), - RandomIn::NodeMessageToNetwork(dst, msg) => { + RandomIn::NodeCommFromNetwork(id, node_msg) => self.network_msg(id, node_msg), + RandomIn::NetworkMapperToNetwork(dst, msg) => { if self.storage.connected.contains(&dst) { - vec![RandomOut::NodeMessageToNetwork( + vec![RandomOut::NodeCommToNetwork( dst, - NodeMessage::Module(msg), + ModuleMessage::Module(msg), )] } else { log::warn!( @@ -116,10 +116,10 @@ impl RandomConnections { } /// Processes one message from the network. - pub fn network_msg(&mut self, id: U256, msg: NodeMessage) -> Vec { + pub fn network_msg(&mut self, id: U256, msg: ModuleMessage) -> Vec { match msg { - NodeMessage::Module(msg_mod) => vec![RandomOut::NodeMessageFromNetwork(id, msg_mod)], - NodeMessage::DropConnection => { + ModuleMessage::Module(msg_mod) => vec![RandomOut::NetworkWrapperFromNetwork(id, msg_mod)], + ModuleMessage::DropConnection => { self.storage.disconnect((&vec![id]).into()); concat([vec![RandomOut::DisconnectNode(id)], self.new_connection()]) } @@ -151,7 +151,7 @@ impl RandomConnections { .into_iter() .flat_map(|n| { vec![ - RandomOut::NodeMessageToNetwork(n, NodeMessage::DropConnection), + RandomOut::NodeCommToNetwork(n, ModuleMessage::DropConnection), RandomOut::DisconnectNode(n), ] }) diff --git a/flmodules/src/template/broker.rs b/flmodules/src/template/broker.rs index cc181ebe..1e384435 100644 --- a/flmodules/src/template/broker.rs +++ b/flmodules/src/template/broker.rs @@ -13,7 +13,7 @@ use flarch::{ use super::{ core::{TemplateConfig, TemplateStorage, TemplateStorageSave}, - messages::{MessageNode, TemplateIn, TemplateMessage, TemplateMessages, TemplateOut}, + messages::{ModuleMessage, TemplateIn, TemplateMessage, TemplateMessages, TemplateOut}, }; const MODULE_NAME: &str = "Template"; @@ -67,7 +67,7 @@ impl Template { pub fn increase_self(&mut self, counter: u32) -> Result<(), BrokerError> { self.broker - .emit_msg(TemplateIn::Node(self.our_id, MessageNode::Increase(counter)).into()) + .emit_msg(TemplateIn::FromNetwork(self.our_id, ModuleMessage::Increase(counter)).into()) } pub fn get_counter(&self) -> u32 { @@ -106,9 +106,9 @@ impl Translate { RandomOut::NodeIDsConnected(list) => { Some(TemplateIn::UpdateNodeList(list.into()).into()) } - RandomOut::NodeMessageFromNetwork(id, msg) => msg + RandomOut::NetworkWrapperFromNetwork(id, msg) => msg .unwrap_yaml(MODULE_NAME) - .map(|msg| TemplateIn::Node(id, msg).into()), + .map(|msg| TemplateIn::FromNetwork(id, msg).into()), _ => None, } } else { @@ -117,9 +117,9 @@ impl Translate { } fn link_template_rnd(msg: TemplateMessage) -> Option { - if let TemplateMessage::Output(TemplateOut::Node(id, msg_node)) = msg { + if let TemplateMessage::Output(TemplateOut::ToNetwork(id, msg_node)) = msg { Some( - RandomIn::NodeMessageToNetwork( + RandomIn::NetworkMapperToNetwork( id, NetworkWrapper::wrap_yaml(MODULE_NAME, &msg_node).unwrap(), ) diff --git a/flmodules/src/template/messages.rs b/flmodules/src/template/messages.rs index 597c870a..1898d9ed 100644 --- a/flmodules/src/template/messages.rs +++ b/flmodules/src/template/messages.rs @@ -8,7 +8,7 @@ use super::core::*; /// These are the messages which will be exchanged between the nodes for this /// module. #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub enum MessageNode { +pub enum ModuleMessage { Increase(u32), Counter(u32), } @@ -24,13 +24,13 @@ pub enum TemplateMessage { /// The messages here represent all possible interactions with this module. #[derive(Debug, Clone)] pub enum TemplateIn { - Node(NodeID, MessageNode), + FromNetwork(NodeID, ModuleMessage), UpdateNodeList(NodeIDs), } #[derive(Debug, Clone)] pub enum TemplateOut { - Node(NodeID, MessageNode), + ToNetwork(NodeID, ModuleMessage), UpdateStorage(TemplateStorage), } @@ -63,7 +63,7 @@ impl TemplateMessages { for msg in msgs { log::trace!("Got msg: {msg:?}"); out.extend(match msg { - TemplateIn::Node(src, node_msg) => self.process_node_message(src, node_msg), + TemplateIn::FromNetwork(src, node_msg) => self.process_node_message(src, node_msg), TemplateIn::UpdateNodeList(ids) => self.node_list(ids), }); } @@ -72,9 +72,9 @@ impl TemplateMessages { /// Processes a node to node message and returns zero or more /// MessageOut. - pub fn process_node_message(&mut self, _src: NodeID, msg: MessageNode) -> Vec { + pub fn process_node_message(&mut self, _src: NodeID, msg: ModuleMessage) -> Vec { match msg { - MessageNode::Increase(c) => { + ModuleMessage::Increase(c) => { // When increasing the counter, send 'self' counter to all other nodes. // Also send a StorageUpdate message. self.core.increase(c); @@ -83,15 +83,15 @@ impl TemplateMessages { .0 .iter() .map(|id| { - TemplateOut::Node( + TemplateOut::ToNetwork( id.clone(), - MessageNode::Counter(self.core.storage.counter), + ModuleMessage::Counter(self.core.storage.counter), ) }) .chain(vec![TemplateOut::UpdateStorage(self.core.storage.clone())]) .collect(); } - MessageNode::Counter(c) => log::info!("Got counter from {}: {}", _src, c), + ModuleMessage::Counter(c) => log::info!("Got counter from {}: {}", _src, c), } vec![] } @@ -130,11 +130,11 @@ mod tests { let mut msg = TemplateMessages::new(storage, TemplateConfig::default(), id0)?; msg.process_messages(vec![TemplateIn::UpdateNodeList(ids).into()]); let ret = - msg.process_messages(vec![TemplateIn::Node(id1, MessageNode::Increase(2)).into()]); + msg.process_messages(vec![TemplateIn::FromNetwork(id1, ModuleMessage::Increase(2)).into()]); assert_eq!(2, ret.len()); assert!(matches!( ret[0], - TemplateOut::Node(_, MessageNode::Counter(2)) + TemplateOut::ToNetwork(_, ModuleMessage::Counter(2)) )); assert!(matches!( ret[1], diff --git a/flmodules/src/web_proxy/broker.rs b/flmodules/src/web_proxy/broker.rs index c5d571a5..fdfe3d2f 100644 --- a/flmodules/src/web_proxy/broker.rs +++ b/flmodules/src/web_proxy/broker.rs @@ -136,7 +136,7 @@ impl Translate { } OverlayOut::NetworkMapperFromNetwork(id, msg) => msg .unwrap_yaml(MODULE_NAME) - .map(|msg| WebProxyIn::Node(id, msg).into()), + .map(|msg| WebProxyIn::FromNetwork(id, msg).into()), _ => None, } } else { @@ -145,7 +145,7 @@ impl Translate { } fn link_proxy_overlay(msg: WebProxyMessage) -> Option { - if let WebProxyMessage::Output(WebProxyOut::Node(id, msg_node)) = msg { + if let WebProxyMessage::Output(WebProxyOut::ToNetwork(id, msg_node)) = msg { Some( OverlayIn::NetworkWrapperToNetwork( id, diff --git a/flmodules/src/web_proxy/messages.rs b/flmodules/src/web_proxy/messages.rs index e901eeda..3b0fff7a 100644 --- a/flmodules/src/web_proxy/messages.rs +++ b/flmodules/src/web_proxy/messages.rs @@ -19,7 +19,7 @@ use super::{ /// Messages between different instances of this module. #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub enum MessageNode { +pub enum ModuleMessage { /// The request holds a random ID so that the reply can be mapped to the correct /// request. Request(U256, String), @@ -39,7 +39,7 @@ pub enum WebProxyMessage { /// All possible calls TO this module. #[derive(Debug, Clone)] pub enum WebProxyIn { - Node(NodeID, MessageNode), + FromNetwork(NodeID, ModuleMessage), NodeInfoConnected(Vec), RequestGet(U256, String, Sender), } @@ -47,7 +47,7 @@ pub enum WebProxyIn { /// All possible replies FROM this module. #[derive(Debug, Clone)] pub enum WebProxyOut { - Node(NodeID, MessageNode), + ToNetwork(NodeID, ModuleMessage), ResponseGet(NodeID, U256, ResponseHeader), UpdateStorage(WebProxyStorage), } @@ -77,7 +77,7 @@ impl WebProxyMessages { pub fn process_messages(&mut self, msgs: Vec) -> Vec { msgs.into_iter() .map(|msg| match msg { - WebProxyIn::Node(src, node_msg) => self.process_node_message(src, node_msg), + WebProxyIn::FromNetwork(src, node_msg) => self.process_node_message(src, node_msg), WebProxyIn::NodeInfoConnected(ids) => self.node_list(ids), WebProxyIn::RequestGet(rnd, url, tx) => self.request_get(rnd, url, tx), }) @@ -87,10 +87,10 @@ impl WebProxyMessages { /// Processes a node to node message and returns zero or more /// MessageOut. - pub fn process_node_message(&mut self, src: NodeID, msg: MessageNode) -> Vec { + pub fn process_node_message(&mut self, src: NodeID, msg: ModuleMessage) -> Vec { let mut out = match msg { - MessageNode::Request(nonce, request) => self.start_request(src, nonce, request), - MessageNode::Response(nonce, response) => self.handle_response(src, nonce, response), + ModuleMessage::Request(nonce, request) => self.start_request(src, nonce, request), + ModuleMessage::Response(nonce, response) => self.handle_response(src, nonce, response), }; out.push(WebProxyOut::UpdateStorage(self.core.storage.clone())); out @@ -111,7 +111,7 @@ impl WebProxyMessages { fn request_get(&mut self, rnd: U256, url: String, tx: Sender) -> Vec { self.core.request_get(rnd, tx).map_or(vec![], |node| { - vec![WebProxyOut::Node(node, MessageNode::Request(rnd, url))] + vec![WebProxyOut::ToNetwork(node, ModuleMessage::Request(rnd, url))] }) } @@ -121,18 +121,18 @@ impl WebProxyMessages { match reqwest::get(request).await { Ok(resp) => { broker - .emit_msg(WebProxyMessage::Output(WebProxyOut::Node( + .emit_msg(WebProxyMessage::Output(WebProxyOut::ToNetwork( src, - MessageNode::Response(nonce, ResponseMessage::Header((&resp).into())), + ModuleMessage::Response(nonce, ResponseMessage::Header((&resp).into())), ))) .expect("sending header"); let mut stream = resp.bytes_stream().chunks(1024); while let Some(chunks) = stream.next().await { for chunk in chunks { broker - .emit_msg(WebProxyMessage::Output(WebProxyOut::Node( + .emit_msg(WebProxyMessage::Output(WebProxyOut::ToNetwork( src, - MessageNode::Response( + ModuleMessage::Response( nonce, ResponseMessage::Body(chunk.expect("getting chunk")), ), @@ -141,26 +141,26 @@ impl WebProxyMessages { } } broker - .emit_msg(WebProxyMessage::Output(WebProxyOut::Node( + .emit_msg(WebProxyMessage::Output(WebProxyOut::ToNetwork( src, - MessageNode::Response(nonce, ResponseMessage::Done), + ModuleMessage::Response(nonce, ResponseMessage::Done), ))) .expect("sending done"); } Err(e) => { broker - .emit_msg(WebProxyMessage::Output(WebProxyOut::Node( + .emit_msg(WebProxyMessage::Output(WebProxyOut::ToNetwork( src, - MessageNode::Response(nonce, ResponseMessage::Error(e.to_string())), + ModuleMessage::Response(nonce, ResponseMessage::Error(e.to_string())), ))) .expect("Sending done message for"); return; } } broker - .emit_msg(WebProxyMessage::Output(WebProxyOut::Node( + .emit_msg(WebProxyMessage::Output(WebProxyOut::ToNetwork( src, - MessageNode::Response(nonce, ResponseMessage::Done), + ModuleMessage::Response(nonce, ResponseMessage::Done), ))) .expect("Sending done message for"); }); diff --git a/flmodules/tests/load.rs b/flmodules/tests/load.rs index 1f2a08d0..4b621df5 100644 --- a/flmodules/tests/load.rs +++ b/flmodules/tests/load.rs @@ -3,7 +3,7 @@ use std::error::Error; use flarch::{nodeids::NodeID, start_logging}; use flmodules::gossip_events::{ core::{Category, EventsStorage}, - messages::{Config, GossipEvents, GossipIn, GossipOut, MessageNode}, + messages::{Config, GossipEvents, GossipIn, GossipOut, ModuleMessage}, }; #[tokio::test] @@ -26,7 +26,7 @@ async fn test_gossip() -> Result<(), Box> { let msg12 = es1.process_messages(msg_out(msg21))?; let msg21 = es2.process_messages(msg_out(msg12))?; assert_eq!(1, msg21.len()); - if let GossipOut::Node(_, MessageNode::Events(events)) = &msg21[0] { + if let GossipOut::ToNetwork(_, ModuleMessage::Events(events)) = &msg21[0] { assert_eq!( 2, events @@ -44,7 +44,7 @@ async fn test_gossip() -> Result<(), Box> { fn msg_out(mut msgs: Vec) -> Vec { msgs.drain(..) .filter_map(|msg| match msg { - GossipOut::Node(id, msg_node) => Some(GossipIn::Node(id, msg_node)), + GossipOut::ToNetwork(id, msg_node) => Some(GossipIn::FromNetwork(id, msg_node)), _ => None, }) .collect() diff --git a/flnode/src/node.rs b/flnode/src/node.rs index a1c8de6d..7c9d8c4d 100644 --- a/flnode/src/node.rs +++ b/flnode/src/node.rs @@ -187,7 +187,7 @@ impl Node { /// Requests a list of all connected nodes pub async fn request_list(&mut self) -> Result<(), NodeError> { self.broker_net - .emit_msg(NetworkIn::SendWSUpdateListRequest.into())?; + .emit_msg(NetworkIn::WSUpdateListRequest.into())?; Ok(()) } diff --git a/flnode/tests/helpers/mod.rs b/flnode/tests/helpers/mod.rs index 71c64c23..3607be8c 100644 --- a/flnode/tests/helpers/mod.rs +++ b/flnode/tests/helpers/mod.rs @@ -66,7 +66,7 @@ impl NetworkSimul { for id in self.nodes.keys() { if let Some(broker) = self.node_brokers.get_mut(id) { broker - .settle_msg(NetworkOut::RcvWSUpdateList(list.clone()).into()) + .settle_msg(NetworkOut::NodeListFromWS(list.clone()).into()) .await?; } } @@ -134,9 +134,9 @@ impl NetworkSimul { (id_dst, NetworkOut::Connected(*id).into()), ] } - NetworkMessage::Input(NetworkIn::SendNodeMessage(from_id, msg_str)) => vec![( + NetworkMessage::Input(NetworkIn::MessageToNode(from_id, msg_str)) => vec![( from_id, - NetworkOut::RcvNodeMessage(id.clone(), msg_str).into(), + NetworkOut::MessageFromNode(id.clone(), msg_str).into(), )], NetworkMessage::WebRTC(WebRTCConnMessage::InputNC( id_dst, diff --git a/test/webrtc-libc-wasm/libc/src/main.rs b/test/webrtc-libc-wasm/libc/src/main.rs index 5614b838..ac183239 100644 --- a/test/webrtc-libc-wasm/libc/src/main.rs +++ b/test/webrtc-libc-wasm/libc/src/main.rs @@ -39,7 +39,7 @@ async fn main() -> Result<(), MainError> { loop { let msg = tap.recv().await.expect("expected message"); - if let NetworkMessage::Output(NetworkOut::RcvNodeMessage(id, msg_net)) = msg { + if let NetworkMessage::Output(NetworkOut::MessageFromNode(id, msg_net)) = msg { log::info!("Got message from other node: {}", msg_net); if msgs_rcv == 0 { msgs_rcv += 1; @@ -74,7 +74,7 @@ async fn spawn_node() -> Result<(NodeConfig, Broker), MainError> } async fn send(src: &mut Broker, id: U256, msg: &str) { - src.emit_msg(NetworkMessage::Input(NetworkIn::SendNodeMessage( + src.emit_msg(NetworkMessage::Input(NetworkIn::MessageToNode( id, msg.into(), ))) @@ -115,7 +115,7 @@ mod tests { async fn wait_msg(tap: &Receiver, msg: &str) { for msg_net in tap { - if let NetworkMessage::Output(NetworkOut::RcvNodeMessage(_, nm)) = &msg_net { + if let NetworkMessage::Output(NetworkOut::MessageFromNode(_, nm)) = &msg_net { if nm == msg { break; } diff --git a/test/webrtc-libc-wasm/wasm/src/lib.rs b/test/webrtc-libc-wasm/wasm/src/lib.rs index 334c3006..753e9720 100644 --- a/test/webrtc-libc-wasm/wasm/src/lib.rs +++ b/test/webrtc-libc-wasm/wasm/src/lib.rs @@ -40,12 +40,12 @@ async fn run_app() -> Result<(), StartError> { while let Ok(msg) = rx.try_recv() { if let NetworkMessage::Output(reply) = msg { match reply { - NetworkOut::RcvNodeMessage(id, msg_net) => { + NetworkOut::MessageFromNode(id, msg_net) => { log::info!("Got node message: {} / {:?}", id, msg_net); net.remove_subsystem(tap_indx).await?; return Ok(()); } - NetworkOut::RcvWSUpdateList(list) => { + NetworkOut::NodeListFromWS(list) => { let other: Vec = list .iter() .filter(|n| n.get_id() != nc.info.get_id()) @@ -55,7 +55,7 @@ async fn run_app() -> Result<(), StartError> { if other.len() > 0 { net.emit_msg_dest( Destination::NoTap, - NetworkIn::SendNodeMessage( + NetworkIn::MessageToNode( other.get(0).unwrap().get_id(), "Hello from Rust wasm".to_string(), ) @@ -67,7 +67,7 @@ async fn run_app() -> Result<(), StartError> { } } } - net.emit_msg(NetworkMessage::Input(NetworkIn::SendWSUpdateListRequest))?; + net.emit_msg(NetworkMessage::Input(NetworkIn::WSUpdateListRequest))?; wait_ms(1000).await; } }