Remove Pong event

This simplifies the API and reduces code. The hypothesis is that
nobody is really interested in `Pong` events.

examples/ipfs-private/src/main.rs

@@ -249,20 +249,14 @@ async fn main() -> Result<(), Box<dyn Error>> {
                         match event {
                             ping::Event {
                                 peer,
-                                result: Result::Ok(ping::Success::Ping { rtt }),
+                                result: Result::Ok(rtt),
                             } => {
                                 println!(
                                     "ping: rtt to {} is {} ms",
                                     peer.to_base58(),
                                     rtt.as_millis()
                                 );
                             }
-                            ping::Event {
-                                peer,
-                                result: Result::Ok(ping::Success::Pong),
-                            } => {
-                                println!("ping: pong from {}", peer.to_base58());
-                            }
                             ping::Event {
                                 peer,
                                 result: Result::Err(ping::Failure::Timeout),

examples/rendezvous/src/bin/rzv-discover.rs

@@ -105,7 +105,7 @@ async fn main() {
                     }
                     SwarmEvent::Behaviour(MyBehaviourEvent::Ping(ping::Event {
                         peer,
-                        result: Ok(ping::Success::Ping { rtt }),
+                        result: Ok(rtt),
                     })) if peer != rendezvous_point => {
                         log::info!("Ping to {} is {}ms", peer, rtt.as_millis())
                     }

examples/rendezvous/src/bin/rzv-identify.rs

@@ -106,7 +106,7 @@ async fn main() {
             }
             SwarmEvent::Behaviour(MyBehaviourEvent::Ping(ping::Event {
                 peer,
-                result: Ok(ping::Success::Ping { rtt }),
+                result: Ok(rtt),
             })) if peer != rendezvous_point => {
                 log::info!("Ping to {} is {}ms", peer, rtt.as_millis())
             }

examples/rendezvous/src/bin/rzv-register.rs

@@ -104,7 +104,7 @@ async fn main() {
             }
             SwarmEvent::Behaviour(MyBehaviourEvent::Ping(ping::Event {
                 peer,
-                result: Ok(ping::Success::Ping { rtt }),
+                result: Ok(rtt),
             })) if peer != rendezvous_point => {
                 log::info!("Ping to {} is {}ms", peer, rtt.as_millis())
             }

interop-tests/src/bin/ping.rs

@@ -138,7 +138,7 @@ async fn main() -> Result<()> {
         let rtt = loop {
             if let Some(SwarmEvent::Behaviour(BehaviourEvent::Ping(ping::Event {
                 peer: _,
-                result: Ok(ping::Success::Ping { rtt }),
+                result: Ok(rtt),
             }))) = swarm.next().await
             {
                 log::info!("Ping successful: {rtt:?}");

misc/metrics/CHANGELOG.md

@@ -22,6 +22,8 @@
 - Raise MSRV to 1.65.
   See [PR 3715].
 
+- TODO: Removed `pong_received`.
+
 [PR 3715]: https://github.com/libp2p/rust-libp2p/pull/3715
 [PR 3325]: https://github.com/libp2p/rust-libp2p/pull/3325
 

misc/metrics/src/ping.rs

@@ -55,7 +55,6 @@ enum Failure {
 pub(crate) struct Metrics {
     rtt: Histogram,
     failure: Family<FailureLabels, Counter>,
-    pong_received: Counter,
 }
 
 impl Metrics {
@@ -77,28 +76,14 @@ impl Metrics {
             failure.clone(),
         );
 
-        let pong_received = Counter::default();
-        sub_registry.register(
-            "pong_received",
-            "Number of 'pong's received",
-            pong_received.clone(),
-        );
-
-        Self {
-            rtt,
-            failure,
-            pong_received,
-        }
+        Self { rtt, failure }
     }
 }
 
 impl super::Recorder<libp2p_ping::Event> for Metrics {
     fn record(&self, event: &libp2p_ping::Event) {
         match &event.result {
-            Ok(libp2p_ping::Success::Pong) => {
-                self.pong_received.inc();
-            }
-            Ok(libp2p_ping::Success::Ping { rtt }) => {
+            Ok(rtt) => {
                 self.rtt.observe(rtt.as_secs_f64());
             }
             Err(failure) => {

protocols/ping/src/handler.rs

@@ -106,17 +106,6 @@ impl Default for Config {
     }
 }
 
-/// The successful result of processing an inbound or outbound ping.
-#[derive(Debug)]
-pub enum Success {
-    /// Received a ping and sent back a pong.
-    Pong,
-    /// Sent a ping and received back a pong.
-    ///
-    /// Includes the round-trip time.
-    Ping { rtt: Duration },
-}
-
 /// An outbound ping failure.
 #[derive(Debug)]
 pub enum Failure {
@@ -243,7 +232,7 @@ impl Handler {
 
 impl ConnectionHandler for Handler {
     type FromBehaviour = Void;
-    type ToBehaviour = Result<Success, Failure>;
+    type ToBehaviour = Result<Duration, Failure>;
     type Error = Failure;
     type InboundProtocol = ReadyUpgrade<StreamProtocol>;
     type OutboundProtocol = ReadyUpgrade<StreamProtocol>;
@@ -267,7 +256,7 @@ impl ConnectionHandler for Handler {
         ConnectionHandlerEvent<
             ReadyUpgrade<StreamProtocol>,
             (),
-            Result<Success, Failure>,
+            Result<Duration, Failure>,
             Self::Error,
         >,
     > {
@@ -295,7 +284,6 @@ impl ConnectionHandler for Handler {
 
                     // A ping from a remote peer has been answered, wait for the next.
                     self.inbound = Some(protocol::recv_ping(stream).boxed());
-                    return Poll::Ready(ConnectionHandlerEvent::Custom(Ok(Success::Pong)));
                 }
             }
         }
@@ -337,9 +325,7 @@ impl ConnectionHandler for Handler {
                         self.failures = 0;
                         self.interval.reset(self.config.interval);
                         self.outbound = Some(OutboundState::Idle(stream));
-                        return Poll::Ready(ConnectionHandlerEvent::Custom(Ok(Success::Ping {
-                            rtt,
-                        })));
+                        return Poll::Ready(ConnectionHandlerEvent::Custom(Ok(rtt)));
                     }
                     Poll::Ready(Err(e)) => {
                         self.pending_errors.push_front(e);

protocols/ping/src/lib.rs

@@ -43,19 +43,20 @@ mod handler;
 mod protocol;
 
 use handler::Handler;
-pub use handler::{Config, Failure, Success};
 use libp2p_core::{Endpoint, Multiaddr};
 use libp2p_identity::PeerId;
 use libp2p_swarm::{
     behaviour::FromSwarm, ConnectionDenied, ConnectionId, NetworkBehaviour, PollParameters,
     THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
+use std::time::Duration;
 use std::{
     collections::VecDeque,
     task::{Context, Poll},
 };
 
 pub use self::protocol::PROTOCOL_NAME;
+pub use handler::{Config, Failure};
 
 /// A [`NetworkBehaviour`] that responds to inbound pings and
 /// periodically sends outbound pings on every established connection.
@@ -74,7 +75,7 @@ pub struct Event {
     /// The peer ID of the remote.
     pub peer: PeerId,
     /// The result of an inbound or outbound ping.
-    pub result: Result<Success, Failure>,
+    pub result: Result<Duration, Failure>,
 }
 
 impl Behaviour {

protocols/ping/tests/ping.rs

@@ -59,11 +59,9 @@ fn ping_pong() {
 }
 
 fn assert_ping_rtt_less_than_50ms(e: ping::Event) {
-    let success = e.result.expect("a ping success");
+    let rtt = e.result.expect("a ping success");
 
-    if let ping::Success::Ping { rtt } = success {
-        assert!(rtt < Duration::from_millis(50))
-    }
+    assert!(rtt < Duration::from_millis(50))
 }
 
 /// Tests that the connection is closed upon a configurable
@@ -102,8 +100,7 @@ async fn count_ping_failures_until_connection_closed(mut swarm: Swarm<Behaviour>
     loop {
         match swarm.next_swarm_event().await {
             SwarmEvent::Behaviour(BehaviourEvent::Ping(ping::Event {
-                result: Ok(ping::Success::Ping { .. }),
-                ..
+                result: Ok(_rtt), ..
             })) => {
                 failure_count = 0; // there may be an occasional success
             }