added idle_connection_timeout for swarm builder

swarm/src/connection.rs

@@ -149,6 +149,7 @@ where
 
     local_supported_protocols: HashSet<StreamProtocol>,
     remote_supported_protocols: HashSet<StreamProtocol>,
+    idle_connection_timeout: Option<u64>, // Timeout in seconds
 }
 
 impl<THandler> fmt::Debug for Connection<THandler>
@@ -176,9 +177,9 @@ where
         mut handler: THandler,
         substream_upgrade_protocol_override: Option<upgrade::Version>,
         max_negotiating_inbound_streams: usize,
+        idle_connection_timeout: Option<u64>, // Add this parameter
     ) -> Self {
         let initial_protocols = gather_supported_protocols(&handler);
-
         if !initial_protocols.is_empty() {
             handler.on_connection_event(ConnectionEvent::LocalProtocolsChange(
                 ProtocolsChange::Added(ProtocolsAdded::from_set(&initial_protocols)),
@@ -196,6 +197,7 @@ where
             requested_substreams: Default::default(),
             local_supported_protocols: initial_protocols,
             remote_supported_protocols: Default::default(),
+            idle_connection_timeout,
         }
     }
 
@@ -227,6 +229,7 @@ where
             substream_upgrade_protocol_override,
             local_supported_protocols: supported_protocols,
             remote_supported_protocols,
+            idle_connection_timeout
         } = self.get_mut();
 
         loop {
@@ -351,9 +354,19 @@ where
                         *shutdown = Shutdown::Later(Delay::new(dur), t)
                     }
                 }
-                (_, KeepAlive::No) => *shutdown = Shutdown::Asap,
+                (_, KeepAlive::No) => {
+                    // handle idle_connection_timeout
+                    let timeout = idle_connection_timeout.unwrap_or(0); // Default timeout is 0 seconds
+                    if timeout > 0 {
+                        let duration = Duration::from_secs(timeout);
+                        let deadline = Instant::now() + duration;
+                        *shutdown = Shutdown::Later(Delay::new(duration), deadline);
+                    } else {
+                        *shutdown = Shutdown::Asap;
+                    }
+                }
                 (_, KeepAlive::Yes) => *shutdown = Shutdown::None,
-            };
+            };          
 
             // Check if the connection (and handler) should be shut down.
             // As long as we're still negotiating substreams, shutdown is always postponed.
@@ -713,6 +726,7 @@ mod tests {
                 keep_alive::ConnectionHandler,
                 None,
                 max_negotiating_inbound_streams,
+                None
             );
 
             let result = connection.poll_noop_waker();
@@ -736,6 +750,7 @@ mod tests {
             MockConnectionHandler::new(upgrade_timeout),
             None,
             2,
+            None
         );
 
         connection.handler.open_new_outbound();
@@ -758,6 +773,7 @@ mod tests {
             ConfigurableProtocolConnectionHandler::default(),
             None,
             0,
+            None
         );
 
         // First, start listening on a single protocol.
@@ -796,6 +812,7 @@ mod tests {
             ConfigurableProtocolConnectionHandler::default(),
             None,
             0,
+            None
         );
 
         // First, remote supports a single protocol.

swarm/src/connection/pool.rs

@@ -492,6 +492,7 @@ where
         endpoint: &ConnectedPoint,
         connection: NewConnection,
         handler: THandler,
+        idle_connection_timeout: Option<u64>
     ) {
         let connection = connection.extract();
 
@@ -518,6 +519,7 @@ where
             handler,
             self.substream_upgrade_protocol_override,
             self.max_negotiating_inbound_streams,
+            idle_connection_timeout
         );
 
         self.executor.spawn(task::new_for_established_connection(

swarm/src/lib.rs

@@ -736,7 +736,7 @@ where
                 .expect("n + 1 is always non-zero; qed");
 
                 self.pool
-                    .spawn_connection(id, peer_id, &endpoint, connection, handler);
+                    .spawn_connection(id, peer_id, &endpoint, connection, handler, None);
 
                 log::debug!(
                     "Connection established: {:?} {:?}; Total (peer): {}.",