refactor: implement builder pattern for TransportManager

src/config.rs

@@ -68,7 +68,7 @@ impl From<Role> for crate::yamux::Mode {
 
 /// Configuration builder for [`Litep2p`](`crate::Litep2p`).
 pub struct ConfigBuilder {
-    // TCP transport configuration.
+    /// TCP transport configuration.
     tcp: Option<TcpConfig>,
 
     /// QUIC transport config.

src/lib.rs

@@ -40,7 +40,7 @@ use crate::{
         request_response::RequestResponseProtocol,
     },
     transport::{
-        manager::{SupportedTransport, TransportManager},
+        manager::{SupportedTransport, TransportManager, TransportManagerBuilder},
         tcp::TcpTransport,
         TransportBuilder, TransportEvent,
     },
@@ -170,14 +170,15 @@ impl Litep2p {
         );
 
         let supported_transports = Self::supported_transports(&litep2p_config);
-        let (mut transport_manager, transport_handle) = TransportManager::new(
-            litep2p_config.keypair.clone(),
-            supported_transports,
-            bandwidth_sink.clone(),
-            litep2p_config.max_parallel_dials,
-            litep2p_config.connection_limits,
-        );
+        let mut transport_manager = TransportManagerBuilder::new()
+            .with_keypair(litep2p_config.keypair.clone())
+            .with_supported_transports(supported_transports)
+            .with_bandwidth_sink(bandwidth_sink.clone())
+            .with_max_parallel_dials(litep2p_config.max_parallel_dials)
+            .with_connection_limits_config(litep2p_config.connection_limits)
+            .build();
 
+        let transport_handle = transport_manager.transport_manager_handle();
         // add known addresses to `TransportManager`, if any exist
         if !litep2p_config.known_addresses.is_empty() {
             for (peer, addresses) in litep2p_config.known_addresses {

src/protocol/libp2p/kademlia/mod.rs

@@ -1250,18 +1250,15 @@ impl Kademlia {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::HashSet;
-
     use super::*;
     use crate::{
         codec::ProtocolCodec,
-        crypto::ed25519::Keypair,
         transport::{
-            manager::{limits::ConnectionLimitsConfig, TransportManager},
+            manager::{TransportManager, TransportManagerBuilder},
             KEEP_ALIVE_TIMEOUT,
         },
         types::protocol::ProtocolName,
-        BandwidthSink, ConnectionId,
+        ConnectionId,
     };
     use multiaddr::Protocol;
     use multihash::Multihash;
@@ -1275,21 +1272,15 @@ mod tests {
     }
 
     fn make_kademlia() -> (Kademlia, Context, TransportManager) {
-        let (manager, handle) = TransportManager::new(
-            Keypair::generate(),
-            HashSet::new(),
-            BandwidthSink::new(),
-            8usize,
-            ConnectionLimitsConfig::default(),
-        );
+        let manager = TransportManagerBuilder::new().build();
 
         let peer = PeerId::random();
         let (transport_service, _tx) = TransportService::new(
             peer,
             ProtocolName::from("/kad/1"),
             Vec::new(),
             Default::default(),
-            handle,
+            manager.transport_manager_handle(),
             KEEP_ALIVE_TIMEOUT,
         );
         let (event_tx, event_rx) = channel(64);

src/protocol/mdns.rs

@@ -363,11 +363,7 @@ impl Mdns {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        crypto::ed25519::Keypair,
-        transport::manager::{limits::ConnectionLimitsConfig, TransportManager},
-        BandwidthSink,
-    };
+    use crate::transport::manager::TransportManagerBuilder;
     use futures::StreamExt;
     use multiaddr::Protocol;
 
@@ -378,16 +374,10 @@ mod tests {
             .try_init();
 
         let (config1, mut stream1) = Config::new(Duration::from_secs(5));
-        let (_manager1, handle1) = TransportManager::new(
-            Keypair::generate(),
-            HashSet::new(),
-            BandwidthSink::new(),
-            8usize,
-            ConnectionLimitsConfig::default(),
-        );
+        let manager1 = TransportManagerBuilder::new().build();
 
         let mdns1 = Mdns::new(
-            handle1,
+            manager1.transport_manager_handle(),
             config1,
             vec![
                 "/ip6/::1/tcp/8888/p2p/12D3KooWNP463TyS3vUpmekjjZ2dg7xy1WHNMM7MqfsMevMTaaaa"
@@ -400,16 +390,10 @@ mod tests {
         );
 
         let (config2, mut stream2) = Config::new(Duration::from_secs(5));
-        let (_manager1, handle2) = TransportManager::new(
-            Keypair::generate(),
-            HashSet::new(),
-            BandwidthSink::new(),
-            8usize,
-            ConnectionLimitsConfig::default(),
-        );
+        let manager2 = TransportManagerBuilder::new().build();
 
         let mdns2 = Mdns::new(
-            handle2,
+            manager2.transport_manager_handle(),
             config2,
             vec![
                 "/ip6/::1/tcp/9999/p2p/12D3KooWNP463TyS3vUpmekjjZ2dg7xy1WHNMM7MqfsMevMTbbbb"

src/protocol/notification/mod.rs

@@ -68,7 +68,7 @@ const LOG_TARGET: &str = "litep2p::notification";
 /// Connection state.
 ///
 /// Used to track transport level connectivity state when there is a pending validation.
-/// See [`PeerState::PendingValidation.`] for more details.
+/// See [`PeerState::ValidationPending`] for more details.
 #[derive(Debug, PartialEq, Eq)]
 enum ConnectionState {
     /// There is a active, transport-level connection open to the peer.

src/protocol/notification/tests/mod.rs

@@ -18,10 +18,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use std::collections::HashSet;
-
 use crate::{
-    crypto::ed25519::Keypair,
     executor::DefaultExecutor,
     protocol::{
         notification::{
@@ -30,11 +27,11 @@ use crate::{
         InnerTransportEvent, ProtocolCommand, TransportService,
     },
     transport::{
-        manager::{limits::ConnectionLimitsConfig, TransportManager},
+        manager::{TransportManager, TransportManagerBuilder},
         KEEP_ALIVE_TIMEOUT,
     },
     types::protocol::ProtocolName,
-    BandwidthSink, PeerId,
+    PeerId,
 };
 
 use tokio::sync::mpsc::{channel, Receiver, Sender};
@@ -51,21 +48,15 @@ fn make_notification_protocol() -> (
     TransportManager,
     Sender<InnerTransportEvent>,
 ) {
-    let (manager, handle) = TransportManager::new(
-        Keypair::generate(),
-        HashSet::new(),
-        BandwidthSink::new(),
-        8usize,
-        ConnectionLimitsConfig::default(),
-    );
+    let manager = TransportManagerBuilder::new().build();
 
     let peer = PeerId::random();
     let (transport_service, tx) = TransportService::new(
         peer,
         ProtocolName::from("/notif/1"),
         Vec::new(),
         std::sync::Arc::new(Default::default()),
-        handle,
+        manager.transport_manager_handle(),
         KEEP_ALIVE_TIMEOUT,
     );
     let (config, handle) = NotificationConfig::new(

src/protocol/request_response/tests.rs

@@ -19,7 +19,6 @@
 // DEALINGS IN THE SOFTWARE.
 
 use crate::{
-    crypto::ed25519::Keypair,
     mock::substream::{DummySubstream, MockSubstream},
     protocol::{
         request_response::{
@@ -30,17 +29,17 @@ use crate::{
     },
     substream::Substream,
     transport::{
-        manager::{limits::ConnectionLimitsConfig, TransportManager},
+        manager::{TransportManager, TransportManagerBuilder},
         KEEP_ALIVE_TIMEOUT,
     },
     types::{RequestId, SubstreamId},
-    BandwidthSink, Error, PeerId, ProtocolName,
+    Error, PeerId, ProtocolName,
 };
 
 use futures::StreamExt;
 use tokio::sync::mpsc::Sender;
 
-use std::{collections::HashSet, task::Poll};
+use std::task::Poll;
 
 // create new protocol for testing
 fn protocol() -> (
@@ -49,21 +48,15 @@ fn protocol() -> (
     TransportManager,
     Sender<InnerTransportEvent>,
 ) {
-    let (manager, handle) = TransportManager::new(
-        Keypair::generate(),
-        HashSet::new(),
-        BandwidthSink::new(),
-        8usize,
-        ConnectionLimitsConfig::default(),
-    );
+    let manager = TransportManagerBuilder::new().build();
 
     let peer = PeerId::random();
     let (transport_service, tx) = TransportService::new(
         peer,
         ProtocolName::from("/notif/1"),
         Vec::new(),
         std::sync::Arc::new(Default::default()),
-        handle,
+        manager.transport_manager_handle(),
         KEEP_ALIVE_TIMEOUT,
     );
     let (config, handle) =