1 files changed, 41 insertions, 10 deletions

diff --git a/src/transport/traffic.rs b/src/transport/traffic.rs
index b332d3d..b237db2 100644
--- a/src/transport/traffic.rs
+++ b/src/transport/traffic.rs
@@ -5,8 +5,8 @@
 //! (for Mycelium: the topic, or the base64 of its HTTP API). Counters only grow (from
 //! the start of the process); rates are for whoever reads them.
 //!
-//! A message dropped by the debug firewall still counts as sent (the firewall plays a
-//! lossy network) but not as received.
+//! A message dropped by the debug firewall (in the paths layer, below) still counts as
+//! sent (the firewall plays a lossy network) but not as received.
 
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex, MutexGuard};
@@ -37,12 +37,14 @@ pub(crate) struct ByKind {
     pub(crate) hello: Counter,
     pub(crate) hello_reply: Counter,
     pub(crate) sync: Counter,
-    pub(crate) ping: Counter,
-    pub(crate) pong: Counter,
+    pub(crate) status: Counter,
+    pub(crate) status_reply: Counter,
     pub(crate) blob: Counter,
     /// WHO and ME (`transport::identity`), counted by the identity layer under the
     /// address they went to or came from.
     pub(crate) identity: Counter,
+    /// PING and PONG (`transport::paths`), counted by the paths layer under the address.
+    pub(crate) paths: Counter,
 }
 
 impl ByKind {
@@ -51,10 +53,11 @@ impl ByKind {
             MessageKind::Hello => &mut self.hello,
             MessageKind::HelloReply => &mut self.hello_reply,
             MessageKind::Sync => &mut self.sync,
-            MessageKind::Ping => &mut self.ping,
-            MessageKind::Pong => &mut self.pong,
+            MessageKind::Status => &mut self.status,
+            MessageKind::StatusReply => &mut self.status_reply,
             MessageKind::Blob => &mut self.blob,
             MessageKind::Who | MessageKind::Me => &mut self.identity,
+            MessageKind::Ping | MessageKind::Pong => &mut self.paths,
         }
     }
 }
@@ -157,6 +160,10 @@ impl Transport for CountingTransport {
         self.inner.addresses_of(peer)
     }
 
+    fn identities_of(&self, peer: &str) -> Vec<String> {
+        self.inner.identities_of(peer)
+    }
+
     fn learn_addresses(&self, peer: &str, addresses: &[String]) {
         self.inner.learn_addresses(peer, addresses)
     }
@@ -173,6 +180,30 @@ impl Transport for CountingTransport {
         self.inner.transports()
     }
 
+    fn learn_relays(&self, addresses: &[String]) {
+        self.inner.learn_relays(addresses)
+    }
+
+    fn destination(&self, peer: &str) -> Option<crate::transport::Destination> {
+        self.inner.destination(peer)
+    }
+
+    fn connection(&self, target: &str) -> Option<crate::transport::Connection> {
+        self.inner.connection(target)
+    }
+
+    fn stats(&self) -> crate::transport::stats::TransportStats {
+        self.inner.stats()
+    }
+
+    fn answers_pings(&self) -> bool {
+        self.inner.answers_pings()
+    }
+
+    fn rtt(&self, peer: &str) -> Option<std::time::Duration> {
+        self.inner.rtt(peer)
+    }
+
     async fn resolve_seed(&self, seed: &str) -> Result<String> {
         self.inner.resolve_seed(seed).await
     }
@@ -215,20 +246,20 @@ mod tests {
     #[test]
     fn totals_survive_retain() {
         let traffic = Traffic::default();
-        traffic.sent("a", MessageKind::Ping, 100);
+        traffic.sent("a", MessageKind::Status, 100);
         traffic.sent("b", MessageKind::Sync, 1000);
-        traffic.received("b", MessageKind::Pong, 90);
+        traffic.received("b", MessageKind::StatusReply, 90);
         traffic.refused("a", MessageKind::Sync, 500);
 
         let b = traffic.peer("b").unwrap();
         assert_eq!(b.sent.sync.messages, 1);
-        assert_eq!(b.received.pong.bytes, 90);
+        assert_eq!(b.received.status_reply.bytes, 90);
 
         traffic.retain(|peer| peer == "b");
         assert!(traffic.peer("a").is_none());
 
         let total = traffic.total();
-        assert_eq!(total.sent.ping.bytes, 100);
+        assert_eq!(total.sent.status.bytes, 100);
         assert_eq!(total.sent.sync.bytes, 1000);
         assert_eq!(total.refused.sync.bytes, 500);
     }