Use ping protocol to prevent connection timeout

Author: Ma233

src/server.rs

@@ -1,9 +1,12 @@
 use std::net::IpAddr;
 use std::net::SocketAddr;
 
+use futures::Stream;
 use futures::StreamExt;
 use litep2p::config::ConfigBuilder;
 use litep2p::crypto::ed25519::SecretKey;
+use litep2p::protocol::libp2p::ping::Config as PingConfig;
+use litep2p::protocol::libp2p::ping::PingEvent;
 use litep2p::protocol::request_response::Config as RequestResponseConfig;
 use litep2p::protocol::request_response::ConfigBuilder as RequestResponseConfigBuilder;
 use litep2p::protocol::request_response::RequestResponseEvent;
@@ -16,18 +19,21 @@ use litep2p::Litep2pEvent;
 #[derive(Debug)]
 pub enum P2pServerEvent {
     Litep2p(Litep2pEvent),
+    PingEvent(PingEvent),
     ControlEvent(RequestResponseEvent),
     TunnelEvent(RequestResponseEvent),
 }
 
 pub struct P2pServer {
     pub(crate) litep2p: Litep2p,
+    pub(crate) ping_stream: Box<dyn Stream<Item = PingEvent> + Send + Unpin>,
     pub(crate) control_handle: RequestResponseHandle,
     pub(crate) tunnel_handle: RequestResponseHandle,
 }
 
 impl P2pServer {
     pub fn new(secret_key: SecretKey, server_addr: SocketAddr) -> Self {
+        let (ping_config, ping_stream) = PingConfig::default();
         let (control_config, control_handle) = Self::init_control();
         let (tunnel_config, tunnel_handle) = Self::init_tunnel();
 
@@ -42,6 +48,7 @@ impl P2pServer {
                 listen_addresses: vec![format!("/{ip_type}/{ip}/tcp/{port}").parse().unwrap()],
                 ..Default::default()
             })
+            .with_libp2p_ping(ping_config)
             .with_request_response_protocol(control_config)
             .with_request_response_protocol(tunnel_config)
             .build();
@@ -52,6 +59,7 @@ impl P2pServer {
 
         Self {
             litep2p,
+            ping_stream,
             control_handle,
             tunnel_handle,
         }
@@ -77,6 +85,9 @@ impl P2pServer {
             ev = self.litep2p.next_event() => {
                 ev.map(P2pServerEvent::Litep2p)
             }
+            ev = self.ping_stream.next() =>  {
+                ev.map(P2pServerEvent::PingEvent)
+            }
             ev = self.control_handle.next() => {
                 ev.map(P2pServerEvent::ControlEvent)
             }