Merge #1720

1720: Simplify transport creation r=thomaseizinger a=thomaseizinger



Co-authored-by: Thomas Eizinger <[email protected]>

Author: bors[bot]

Cargo.lock

@@ -36,7 +36,6 @@ hyper = "0.12"
 lazy_static = "1"
 libp2p = { version = "0.13" }
 libp2p-comit = { path = "../libp2p-comit" }
-libp2p-core = "0.13"
 libsqlite3-sys = { version = ">=0.8.0, <0.13.0", features = ["bundled"] }
 log = { version = "0.4", features = ["serde"] }
 maplit = "1"

cnd/Cargo.toml

@@ -1,17 +1,28 @@
 use libp2p::{
-    dns, identity, mplex, secio, tcp, yamux, Multiaddr, PeerId, Transport, TransportError,
+    core::{
+        muxing::{StreamMuxer, StreamMuxerBox},
+        upgrade::{SelectUpgrade, Version},
+    },
+    dns::DnsConfig,
+    identity,
+    mplex::MplexConfig,
+    secio::SecioConfig,
+    tcp::TcpConfig,
+    yamux, PeerId, Transport,
 };
-use libp2p_core::{muxing, upgrade};
 use std::{error, io, time::Duration};
 
-/// Builds a `Transport` that supports the most commonly-used protocols that
-/// libp2p supports.
+/// Builds a libp2p transport with the following features:
+/// - TcpConnection
+/// - DNS name resolution
+/// - authentication via secio
+/// - multiplexing via yamux or mplex
 pub fn build_comit_transport(
     keypair: identity::Keypair,
 ) -> impl Transport<
     Output = (
         PeerId,
-        impl muxing::StreamMuxer<
+        impl StreamMuxer<
                 OutboundSubstream = impl Send,
                 Substream = impl Send,
                 Error = impl Into<io::Error>,
@@ -23,71 +34,16 @@ pub fn build_comit_transport(
     Dial = impl Send,
     ListenerUpgrade = impl Send,
 > + Clone {
-    build_tcp_ws_secio_mplex_yamux(keypair)
-}
+    let transport = TcpConfig::new().nodelay(true);
+    let transport = DnsConfig::new(transport);
 
-/// Builds an implementation of `Transport` that is suitable for usage with the
-/// `Swarm`.
-///
-/// The implementation supports TCP/IP, secio as the encryption layer, and mplex
-/// or yamux as the multiplexing layer.
-pub fn build_tcp_ws_secio_mplex_yamux(
-    keypair: identity::Keypair,
-) -> impl Transport<
-    Output = (
-        PeerId,
-        impl muxing::StreamMuxer<
-                OutboundSubstream = impl Send,
-                Substream = impl Send,
-                Error = impl Into<io::Error>,
-            > + Send
-            + Sync,
-    ),
-    Error = impl error::Error + Send,
-    Listener = impl Send,
-    Dial = impl Send,
-    ListenerUpgrade = impl Send,
-> + Clone {
-    ComitTransport::new()
-        .upgrade(upgrade::Version::V1)
-        .authenticate(secio::SecioConfig::new(keypair))
-        .multiplex(upgrade::SelectUpgrade::new(
+    transport
+        .upgrade(Version::V1)
+        .authenticate(SecioConfig::new(keypair))
+        .multiplex(SelectUpgrade::new(
             yamux::Config::default(),
-            mplex::MplexConfig::new(),
+            MplexConfig::new(),
         ))
-        .map(|(peer, muxer), _| (peer, muxing::StreamMuxerBox::new(muxer)))
+        .map(|(peer, muxer), _| (peer, StreamMuxerBox::new(muxer)))
         .timeout(Duration::from_secs(20))
 }
-
-#[derive(Debug, Clone)]
-struct ComitTransport {
-    inner: InnerImplementation,
-}
-
-type InnerImplementation = dns::DnsConfig<tcp::TcpConfig>;
-
-impl ComitTransport {
-    /// Initializes the `ComitTransport`.
-    pub fn new() -> ComitTransport {
-        let tcp = tcp::TcpConfig::new().nodelay(true);
-        let transport = dns::DnsConfig::new(tcp);
-
-        ComitTransport { inner: transport }
-    }
-}
-
-impl Transport for ComitTransport {
-    type Output = <InnerImplementation as Transport>::Output;
-    type Error = <InnerImplementation as Transport>::Error;
-    type Listener = <InnerImplementation as Transport>::Listener;
-    type ListenerUpgrade = <InnerImplementation as Transport>::ListenerUpgrade;
-    type Dial = <InnerImplementation as Transport>::Dial;
-
-    fn listen_on(self, addr: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>> {
-        self.inner.listen_on(addr)
-    }
-
-    fn dial(self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
-        self.inner.dial(addr)
-    }
-}