Replace the macro in libp2p-tcp with a generic, inner implementation

To avoid code duplication, a generic inner implementation is used
that does all of the heavy lifting. To abstract over the individual
types, we create traits that are private to the module.

Consumers of the crate shouldn't be concerned with this because
a) none of the generic types are exported
b) there are no type parameters in public interfaces

core/src/nodes/listeners.rs

@@ -45,7 +45,7 @@ use std::{collections::VecDeque, fmt, pin::Pin};
 /// use futures::prelude::*;
 /// use libp2p_core::nodes::listeners::{ListenersEvent, ListenersStream};
 ///
-/// let mut listeners = ListenersStream::new(libp2p_tcp::TcpConfig::new());
+/// let mut listeners = ListenersStream::new(libp2p_tcp::async_std::TcpConfig::new());
 ///
 /// // Ask the `listeners` to start listening on the given multiaddress.
 /// listeners.listen_on("/ip4/0.0.0.0/tcp/0".parse().unwrap()).unwrap();

core/tests/network_dial_error.rs

@@ -86,7 +86,7 @@ fn deny_incoming_connec() {
     let mut swarm1: Network<_, _, _, NodeHandlerWrapperBuilder<TestHandler>, _, _> = {
         let local_key = identity::Keypair::generate_ed25519();
         let local_public_key = local_key.public();
-        let transport = libp2p_tcp::TcpConfig::new()
+        let transport = libp2p_tcp::async_std::TcpConfig::new()
             .upgrade(upgrade::Version::V1)
             .authenticate(libp2p_secio::SecioConfig::new(local_key))
             .multiplex(libp2p_mplex::MplexConfig::new())
@@ -97,7 +97,7 @@ fn deny_incoming_connec() {
     let mut swarm2 = {
         let local_key = identity::Keypair::generate_ed25519();
         let local_public_key = local_key.public();
-        let transport = libp2p_tcp::TcpConfig::new()
+        let transport = libp2p_tcp::async_std::TcpConfig::new()
             .upgrade(upgrade::Version::V1)
             .authenticate(libp2p_secio::SecioConfig::new(local_key))
             .multiplex(libp2p_mplex::MplexConfig::new())
@@ -162,7 +162,7 @@ fn dial_self() {
     let mut swarm = {
         let local_key = identity::Keypair::generate_ed25519();
         let local_public_key = local_key.public();
-        let transport = libp2p_tcp::TcpConfig::new()
+        let transport = libp2p_tcp::async_std::TcpConfig::new()
             .upgrade(upgrade::Version::V1)
             .authenticate(libp2p_secio::SecioConfig::new(local_key))
             .multiplex(libp2p_mplex::MplexConfig::new())
@@ -239,7 +239,7 @@ fn dial_self_by_id() {
     let mut swarm: Network<_, _, _, NodeHandlerWrapperBuilder<TestHandler>, _, _> = {
         let local_key = identity::Keypair::generate_ed25519();
         let local_public_key = local_key.public();
-        let transport = libp2p_tcp::TcpConfig::new()
+        let transport = libp2p_tcp::async_std::TcpConfig::new()
             .upgrade(upgrade::Version::V1)
             .authenticate(libp2p_secio::SecioConfig::new(local_key))
             .multiplex(libp2p_mplex::MplexConfig::new())
@@ -258,7 +258,7 @@ fn multiple_addresses_err() {
     let mut swarm = {
         let local_key = identity::Keypair::generate_ed25519();
         let local_public_key = local_key.public();
-        let transport = libp2p_tcp::TcpConfig::new()
+        let transport = libp2p_tcp::async_std::TcpConfig::new()
             .upgrade(upgrade::Version::V1)
             .authenticate(libp2p_secio::SecioConfig::new(local_key))
             .multiplex(libp2p_mplex::MplexConfig::new())

core/tests/network_simult.rs

@@ -98,7 +98,7 @@ fn raw_swarm_simultaneous_connect() {
         let mut swarm1 = {
             let local_key = identity::Keypair::generate_ed25519();
             let local_public_key = local_key.public();
-            let transport = libp2p_tcp::TcpConfig::new()
+            let transport = libp2p_tcp::async_std::TcpConfig::new()
                 .upgrade(upgrade::Version::V1Lazy)
                 .authenticate(libp2p_secio::SecioConfig::new(local_key))
                 .multiplex(libp2p_mplex::MplexConfig::new())
@@ -109,7 +109,7 @@ fn raw_swarm_simultaneous_connect() {
         let mut swarm2 = {
             let local_key = identity::Keypair::generate_ed25519();
             let local_public_key = local_key.public();
-            let transport = libp2p_tcp::TcpConfig::new()
+            let transport = libp2p_tcp::async_std::TcpConfig::new()
                 .upgrade(upgrade::Version::V1Lazy)
                 .authenticate(libp2p_secio::SecioConfig::new(local_key))
                 .multiplex(libp2p_mplex::MplexConfig::new())

examples/ipfs-private.rs

@@ -43,7 +43,7 @@ use libp2p::{
     pnet::{PnetConfig, PreSharedKey},
     secio::SecioConfig,
     swarm::NetworkBehaviourEventProcess,
-    tcp::TcpConfig,
+    tcp::async_std::TcpConfig,
     yamux::Config as YamuxConfig,
     Multiaddr, NetworkBehaviour, PeerId, Swarm, Transport,
 };

muxers/mplex/tests/async_write.rs

@@ -19,7 +19,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use libp2p_core::{muxing, upgrade, Transport};
-use libp2p_tcp::TcpConfig;
+use libp2p_tcp::async_std::TcpConfig;
 use futures::{prelude::*, channel::oneshot};
 use std::sync::Arc;
 

muxers/mplex/tests/two_peers.rs

@@ -19,7 +19,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use libp2p_core::{muxing, upgrade, Transport};
-use libp2p_tcp::TcpConfig;
+use libp2p_tcp::async_std::TcpConfig;
 use futures::{channel::oneshot, prelude::*};
 use std::sync::Arc;
 

protocols/deflate/tests/test.rs

@@ -21,7 +21,7 @@
 use futures::{future, prelude::*};
 use libp2p_core::{transport::Transport, upgrade};
 use libp2p_deflate::DeflateConfig;
-use libp2p_tcp::TcpConfig;
+use libp2p_tcp::async_std::TcpConfig;
 use quickcheck::{QuickCheck, RngCore, TestResult};
 
 #[test]

protocols/identify/src/identify.rs

@@ -260,7 +260,7 @@ mod tests {
         Transport,
         upgrade
     };
-    use libp2p_tcp::TcpConfig;
+    use libp2p_tcp::async_std::TcpConfig;
     use libp2p_secio::SecioConfig;
     use libp2p_swarm::{Swarm, SwarmEvent};
     use libp2p_mplex::MplexConfig;

protocols/identify/src/protocol.rs

@@ -207,7 +207,7 @@ fn parse_proto_msg(msg: impl AsRef<[u8]>) -> Result<(IdentifyInfo, Multiaddr), i
 #[cfg(test)]
 mod tests {
     use crate::protocol::{IdentifyInfo, RemoteInfo, IdentifyProtocolConfig};
-    use libp2p_tcp::TcpConfig;
+    use libp2p_tcp::async_std::TcpConfig;
     use futures::{prelude::*, channel::oneshot};
     use libp2p_core::{
         identity,

protocols/noise/src/lib.rs

@@ -37,7 +37,7 @@
 //!
 //! ```
 //! use libp2p_core::{identity, Transport, upgrade};
-//! use libp2p_tcp::TcpConfig;
+//! use libp2p_tcp::async_std::TcpConfig;
 //! use libp2p_noise::{Keypair, X25519, NoiseConfig};
 //!
 //! # fn main() {

protocols/noise/tests/smoke.rs

@@ -23,7 +23,7 @@ use libp2p_core::identity;
 use libp2p_core::upgrade::{self, Negotiated, apply_inbound, apply_outbound};
 use libp2p_core::transport::{Transport, ListenerEvent};
 use libp2p_noise::{Keypair, X25519, NoiseConfig, RemoteIdentity, NoiseError, NoiseOutput};
-use libp2p_tcp::{TcpConfig, TcpTransStream};
+use libp2p_tcp::{async_std::TcpConfig, async_std::TcpTransStream};
 use log::info;
 use quickcheck::QuickCheck;
 use std::{convert::TryInto, io};

protocols/ping/tests/ping.rs

@@ -31,7 +31,7 @@ use libp2p_core::{
 use libp2p_ping::*;
 use libp2p_secio::SecioConfig;
 use libp2p_swarm::Swarm;
-use libp2p_tcp::TcpConfig;
+use libp2p_tcp::async_std::TcpConfig;
 use futures::{prelude::*, channel::mpsc};
 use std::{io, time::Duration};
 

protocols/secio/src/lib.rs

@@ -34,7 +34,7 @@
 //! use libp2p_core::{PeerId, Multiaddr, identity, upgrade};
 //! use libp2p_core::transport::Transport;
 //! use libp2p_mplex::MplexConfig;
-//! use libp2p_tcp::TcpConfig;
+//! use libp2p_tcp::async_std::TcpConfig;
 //!
 //! // Create a local peer identity.
 //! let local_keys = identity::Keypair::generate_ed25519();

src/lib.rs

@@ -47,7 +47,7 @@
 //! Example (Dialing a TCP/IP multi-address):
 //!
 //! ```rust
-//! use libp2p::{Multiaddr, Transport, tcp::TcpConfig};
+//! use libp2p::{Multiaddr, Transport, tcp::async_std::TcpConfig};
 //! let tcp = TcpConfig::new();
 //! let addr: Multiaddr = "/ip4/98.97.96.95/tcp/20500".parse().expect("invalid multiaddr");
 //! let _conn = tcp.dial(addr);
@@ -86,7 +86,7 @@
 //!
 //! ```rust
 //! # #[cfg(all(not(any(target_os = "emscripten", target_os = "unknown")), feature = "libp2p-secio"))] {
-//! use libp2p::{Transport, tcp::TcpConfig, secio::SecioConfig, identity::Keypair, yamux};
+//! use libp2p::{Transport, tcp::async_std::TcpConfig, secio::SecioConfig, identity::Keypair, yamux};
 //! let tcp = TcpConfig::new();
 //! let secio = SecioConfig::new(Keypair::generate_ed25519());
 //! let yamux = yamux::Config::default();
@@ -141,7 +141,7 @@
 //! [`Keypair`]: identity::Keypair
 //! [`PublicKey`]: identity::PublicKey
 //! [`Future`]: futures::Future
-//! [`TcpConfig`]: tcp::TcpConfig
+//! [`TcpConfig`]: tcp::async_std::TcpConfig
 //! [`NetworkBehaviour`]: swarm::NetworkBehaviour
 //! [`StreamMuxer`]: core::muxing::StreamMuxer
 //! [`Yamux`]: yamux::Yamux
@@ -282,9 +282,9 @@ struct CommonTransport {
 }
 
 #[cfg(all(not(any(target_os = "emscripten", target_os = "unknown")), feature = "libp2p-websocket"))]
-type InnerImplementation = core::transport::OrTransport<dns::DnsConfig<tcp::TcpConfig>, websocket::WsConfig<dns::DnsConfig<tcp::TcpConfig>>>;
+type InnerImplementation = core::transport::OrTransport<dns::DnsConfig<tcp::async_std::TcpConfig>, websocket::WsConfig<dns::DnsConfig<tcp::async_std::TcpConfig>>>;
 #[cfg(all(not(any(target_os = "emscripten", target_os = "unknown")), not(feature = "libp2p-websocket")))]
-type InnerImplementation = dns::DnsConfig<tcp::TcpConfig>;
+type InnerImplementation = dns::DnsConfig<tcp::async_std::TcpConfig>;
 #[cfg(any(target_os = "emscripten", target_os = "unknown"))]
 type InnerImplementation = core::transport::dummy::DummyTransport;
 
@@ -297,7 +297,7 @@ impl CommonTransport {
     /// Initializes the `CommonTransport`.
     #[cfg(not(any(target_os = "emscripten", target_os = "unknown")))]
     pub fn new() -> io::Result<CommonTransport> {
-        let tcp = tcp::TcpConfig::new().nodelay(true);
+        let tcp = tcp::async_std::TcpConfig::new().nodelay(true);
         let transport = dns::DnsConfig::new(tcp)?;
         #[cfg(feature = "libp2p-websocket")]
         let transport = {

transports/tcp/Cargo.toml

@@ -18,6 +18,7 @@ ipnet = "2.0.0"
 libp2p-core = { version = "0.16.0", path = "../../core" }
 log = "0.4.1"
 tokio = { version = "0.2", default-features = false, features = ["tcp"], optional = true }
+async-trait = "0.1"
 
 [features]
 default = ["async-std"]