fixed broken dispatch bug (command names for send were Version instead of version)

src/net/message_subscriber.rs

@@ -86,6 +86,12 @@ impl<M: Message2> MessageDispatcher<M> {
     }
 
     async fn trigger_all(&self, message: MessageResult<M>) {
+        debug!(
+            "MessageDispatcher<M={}>::trigger_all({}) [START, subs={}]",
+            M::name(),
+            if message.is_ok() { "msg" } else { "err" },
+            self.subs.lock().await.len()
+        );
         let mut garbage_ids = Vec::new();
 
         for (sub_id, sub) in &*self.subs.lock().await {
@@ -100,6 +106,13 @@ impl<M: Message2> MessageDispatcher<M> {
         }
 
         self.collect_garbage(garbage_ids).await;
+
+        debug!(
+            "MessageDispatcher<M={}>::trigger_all({}) [END, subs={}]",
+            M::name(),
+            if message.is_ok() { "msg" } else { "err" },
+            self.subs.lock().await.len()
+        );
     }
 
     async fn collect_garbage(&self, ids: Vec<MessageSubscriptionID>) {
@@ -245,14 +258,19 @@ impl MessageSubsystem {
         Ok(sub)
     }
 
-    pub async fn notify(&self, name: &str, data: Vec<u8>) {
-        let dispatcher = self.dispatchers.lock().await.get(name).cloned();
+    pub async fn notify(&self, command: &str, payload: Vec<u8>) {
+        let dispatcher = self.dispatchers.lock().await.get(command).cloned();
 
         match dispatcher {
             Some(dispatcher) => {
-                dispatcher.trigger(data).await;
+                dispatcher.trigger(payload).await;
+            }
+            None => {
+                warn!(
+                    "MessageSubsystem::notify(\"{}\", payload) did not find a dispatcher",
+                    command
+                );
             }
-            None => {}
         }
     }
 

src/net/messages.rs

@@ -328,15 +328,15 @@ impl Message {
 
     pub fn name(&self) -> &'static str {
         match self {
-            Message::Ping(_) => "Ping",
-            Message::Pong(_) => "Pong",
-            Message::GetAddrs(_) => "GetAddrs",
-            Message::Addrs(_) => "Addrs",
-            Message::Inv(_) => "Inv",
+            Message::Ping(_) => "ping",
+            Message::Pong(_) => "pong",
+            Message::GetAddrs(_) => "getaddr",
+            Message::Addrs(_) => "addr",
+            Message::Inv(_) => "inv",
             Message::GetSlabs(_) => "GetSlabs",
             Message::Slab(_) => "Slab",
-            Message::Version(_) => "Version",
-            Message::Verack(_) => "Verack",
+            Message::Version(_) => "version",
+            Message::Verack(_) => "verack",
         }
     }
 }

src/net/protocols/protocol_address.rs

@@ -67,7 +67,14 @@ impl ProtocolAddress {
         loop {
             let addrs_msg = self.addrs_sub.receive().await?;
 
-            debug!(target: "net", "ProtocolAddress::handle_receive_addrs() storing address in hosts");
+            debug!(
+                target: "net",
+                "ProtocolAddress::handle_receive_addrs() received {} addrs",
+                addrs_msg.addrs.len()
+            );
+            for (i, addr) in addrs_msg.addrs.iter().enumerate() {
+                debug!("  addr[{}]: {}", i, addr);
+            }
             self.hosts.store(addrs_msg.addrs.clone()).await;
         }
     }
@@ -79,11 +86,14 @@ impl ProtocolAddress {
 
             debug!(target: "net", "ProtocolAddress::handle_receive_get_addrs() received GetAddrs message");
 
-            let addrs = messages::Message::Addrs(messages::AddrsMessage {
-                addrs: self.hosts.load_all().await,
-            });
-            debug!(target: "net", "ProtocolAddress::handle_receive_get_addrs() sending Addrs message");
-            self.channel.clone().send(addrs).await?;
+            let addrs = self.hosts.load_all().await;
+            debug!(
+                target: "net",
+                "ProtocolAddress::handle_receive_get_addrs() sending {} addrs",
+                addrs.len()
+            );
+            let addrs_msg = messages::Message::Addrs(messages::AddrsMessage { addrs });
+            self.channel.clone().send(addrs_msg).await?;
         }
     }
 }

src/net/protocols/protocol_seed.rs

@@ -31,7 +31,7 @@ impl ProtocolSeed {
             .expect("Missing addrs dispatcher!");
 
         // Send own address to the seed server
-        self.send_own_address().await?;
+        self.send_self_address().await?;
 
         // Send get address message
         let get_addr = messages::Message::GetAddrs(messages::GetAddrsMessage {});
@@ -39,15 +39,17 @@ impl ProtocolSeed {
 
         // Receive addresses
         let addrs_msg = addr_sub.receive().await?;
+        debug!(target: "net", "ProtocolSeed::start() received {} addrs", addrs_msg.addrs.len());
         self.hosts.store(addrs_msg.addrs.clone()).await;
 
         debug!(target: "net", "ProtocolSeed::start() [END]");
         Ok(())
     }
 
-    pub async fn send_own_address(&self) -> NetResult<()> {
+    pub async fn send_self_address(&self) -> NetResult<()> {
         match self.settings.external_addr {
             Some(addr) => {
+                debug!(target: "net", "ProtocolSeed::send_own_address() addr={}", addr);
                 let addr = messages::Message::Addrs(messages::AddrsMessage { addrs: vec![addr] });
                 self.channel.clone().send(addr).await?;
             }