transports/tcp: Unify symbol naming

examples/chat-tokio.rs

@@ -29,7 +29,6 @@
 //! ```
 
 use futures::StreamExt;
-use libp2p::tcp::GenTcpConfig;
 use libp2p::{
     core::upgrade,
     floodsub::{self, Floodsub, FloodsubEvent},
@@ -39,15 +38,9 @@ use libp2p::{
         // `TokioMdns` is available through the `mdns-tokio` feature.
         TokioMdns,
     },
-    mplex,
-    noise,
+    mplex, noise,
     swarm::{SwarmBuilder, SwarmEvent},
-    // `TokioTcpTransport` is available through the `tcp-tokio` feature.
-    tcp::TokioTcpTransport,
-    Multiaddr,
-    NetworkBehaviour,
-    PeerId,
-    Transport,
+    tcp, Multiaddr, NetworkBehaviour, PeerId, Transport,
 };
 use std::error::Error;
 use tokio::io::{self, AsyncBufReadExt};
@@ -64,7 +57,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     // Create a tokio-based TCP transport use noise for authenticated
     // encryption and Mplex for multiplexing of substreams on a TCP stream.
-    let transport = TokioTcpTransport::new(GenTcpConfig::default().nodelay(true))
+    let transport = tcp::tokio::Transport::new(tcp::Config::default().nodelay(true))
         .upgrade(upgrade::Version::V1)
         .authenticate(
             noise::NoiseAuthenticated::xx(&id_keys)

examples/ipfs-private.rs

@@ -33,7 +33,6 @@
 //! to work, the ipfs node needs to be configured to use gossipsub.
 use async_std::io;
 use futures::{prelude::*, select};
-use libp2p::tcp::GenTcpConfig;
 use libp2p::{
     core::{
         either::EitherTransport, muxing::StreamMuxerBox, transport, transport::upgrade::Version,
@@ -44,7 +43,7 @@ use libp2p::{
     noise, ping,
     pnet::{PnetConfig, PreSharedKey},
     swarm::SwarmEvent,
-    tcp::TcpTransport,
+    tcp,
     yamux::YamuxConfig,
     Multiaddr, NetworkBehaviour, PeerId, Swarm, Transport,
 };
@@ -58,7 +57,7 @@ pub fn build_transport(
     let noise_config = noise::NoiseAuthenticated::xx(&key_pair).unwrap();
     let yamux_config = YamuxConfig::default();
 
-    let base_transport = TcpTransport::new(GenTcpConfig::default().nodelay(true));
+    let base_transport = tcp::async_io::Transport::new(tcp::Config::default().nodelay(true));
     let maybe_encrypted = match psk {
         Some(psk) => EitherTransport::Left(
             base_transport.and_then(move |socket, _| PnetConfig::new(psk).handshake(socket)),

muxers/mplex/benches/split_send_size.rs

@@ -30,9 +30,8 @@ use libp2p::core::muxing::StreamMuxerExt;
 use libp2p::core::{
     identity, multiaddr::multiaddr, muxing, transport, upgrade, Multiaddr, PeerId, Transport,
 };
-use libp2p::mplex;
 use libp2p::plaintext::PlainText2Config;
-use libp2p::tcp::GenTcpConfig;
+use libp2p::{mplex, tcp};
 use std::pin::Pin;
 use std::time::Duration;
 
@@ -166,7 +165,7 @@ fn tcp_transport(split_send_size: usize) -> BenchTransport {
     let mut mplex = mplex::MplexConfig::default();
     mplex.set_split_send_size(split_send_size);
 
-    libp2p::tcp::TcpTransport::new(GenTcpConfig::default().nodelay(true))
+    tcp::async_io::Transport::new(tcp::Config::default().nodelay(true))
         .upgrade(upgrade::Version::V1)
         .authenticate(PlainText2Config { local_public_key })
         .multiplex(mplex)

muxers/mplex/tests/async_write.rs

@@ -21,7 +21,7 @@
 use futures::{channel::oneshot, prelude::*};
 use libp2p::core::muxing::StreamMuxerExt;
 use libp2p::core::{upgrade, Transport};
-use libp2p::tcp::TcpTransport;
+use libp2p::tcp;
 
 #[test]
 fn async_write() {
@@ -32,7 +32,7 @@ fn async_write() {
     let bg_thread = async_std::task::spawn(async move {
         let mplex = libp2p::mplex::MplexConfig::new();
 
-        let mut transport = TcpTransport::default()
+        let mut transport = tcp::async_io::Transport::default()
             .and_then(move |c, e| upgrade::apply(c, mplex, e, upgrade::Version::V1))
             .boxed();
 
@@ -68,7 +68,7 @@ fn async_write() {
 
     async_std::task::block_on(async {
         let mplex = libp2p::mplex::MplexConfig::new();
-        let mut transport = TcpTransport::default()
+        let mut transport = tcp::async_io::Transport::default()
             .and_then(move |c, e| upgrade::apply(c, mplex, e, upgrade::Version::V1));
 
         let mut client = transport.dial(rx.await.unwrap()).unwrap().await.unwrap();

muxers/mplex/tests/two_peers.rs

@@ -21,7 +21,7 @@
 use futures::{channel::oneshot, prelude::*};
 use libp2p::core::muxing::StreamMuxerExt;
 use libp2p::core::{upgrade, Transport};
-use libp2p::tcp::TcpTransport;
+use libp2p::tcp;
 
 #[test]
 fn client_to_server_outbound() {
@@ -32,7 +32,7 @@ fn client_to_server_outbound() {
     let bg_thread = async_std::task::spawn(async move {
         let mplex = libp2p_mplex::MplexConfig::new();
 
-        let mut transport = TcpTransport::default()
+        let mut transport = tcp::async_io::Transport::default()
             .and_then(move |c, e| upgrade::apply(c, mplex, e, upgrade::Version::V1))
             .boxed();
 
@@ -68,7 +68,7 @@ fn client_to_server_outbound() {
 
     async_std::task::block_on(async {
         let mplex = libp2p_mplex::MplexConfig::new();
-        let mut transport = TcpTransport::default()
+        let mut transport = tcp::async_io::Transport::default()
             .and_then(move |c, e| upgrade::apply(c, mplex, e, upgrade::Version::V1))
             .boxed();
 
@@ -90,7 +90,7 @@ fn client_to_server_inbound() {
     let bg_thread = async_std::task::spawn(async move {
         let mplex = libp2p_mplex::MplexConfig::new();
 
-        let mut transport = TcpTransport::default()
+        let mut transport = tcp::async_io::Transport::default()
             .and_then(move |c, e| upgrade::apply(c, mplex, e, upgrade::Version::V1))
             .boxed();
 
@@ -126,7 +126,7 @@ fn client_to_server_inbound() {
 
     async_std::task::block_on(async {
         let mplex = libp2p_mplex::MplexConfig::new();
-        let mut transport = TcpTransport::default()
+        let mut transport = tcp::async_io::Transport::default()
             .and_then(move |c, e| upgrade::apply(c, mplex, e, upgrade::Version::V1))
             .boxed();
 
@@ -147,7 +147,7 @@ fn protocol_not_match() {
     let _bg_thread = async_std::task::spawn(async move {
         let mplex = libp2p_mplex::MplexConfig::new();
 
-        let mut transport = TcpTransport::default()
+        let mut transport = tcp::async_io::Transport::default()
             .and_then(move |c, e| upgrade::apply(c, mplex, e, upgrade::Version::V1))
             .boxed();
 
@@ -185,7 +185,7 @@ fn protocol_not_match() {
         // Make sure they do not connect when protocols do not match
         let mut mplex = libp2p_mplex::MplexConfig::new();
         mplex.set_protocol_name(b"/mplextest/1.0.0");
-        let mut transport = TcpTransport::default()
+        let mut transport = tcp::async_io::Transport::default()
             .and_then(move |c, e| upgrade::apply(c, mplex, e, upgrade::Version::V1))
             .boxed();
 

protocols/dcutr/examples/dcutr.rs

@@ -30,7 +30,7 @@ use libp2p::identify;
 use libp2p::noise;
 use libp2p::relay::v2::client::{self, Client};
 use libp2p::swarm::{SwarmBuilder, SwarmEvent};
-use libp2p::tcp::{GenTcpConfig, TcpTransport};
+use libp2p::tcp;
 use libp2p::Transport;
 use libp2p::{dcutr, ping};
 use libp2p::{identity, NetworkBehaviour, PeerId};
@@ -90,8 +90,8 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let transport = OrTransport::new(
         relay_transport,
-        block_on(DnsConfig::system(TcpTransport::new(
-            GenTcpConfig::default().port_reuse(true),
+        block_on(DnsConfig::system(tcp::async_io::Transport::new(
+            tcp::Config::default().port_reuse(true),
         )))
         .unwrap(),
     )

protocols/identify/src/behaviour.rs

@@ -555,7 +555,7 @@ mod tests {
     use futures::pin_mut;
     use libp2p::mplex::MplexConfig;
     use libp2p::noise;
-    use libp2p::tcp::{GenTcpConfig, TcpTransport};
+    use libp2p::tcp;
     use libp2p_core::{identity, muxing::StreamMuxerBox, transport, upgrade, PeerId, Transport};
     use libp2p_swarm::{Swarm, SwarmEvent};
     use std::time::Duration;
@@ -569,7 +569,7 @@ mod tests {
             .into_authentic(&id_keys)
             .unwrap();
         let pubkey = id_keys.public();
-        let transport = TcpTransport::new(GenTcpConfig::default().nodelay(true))
+        let transport = tcp::async_io::Transport::new(tcp::Config::default().nodelay(true))
             .upgrade(upgrade::Version::V1)
             .authenticate(noise::NoiseConfig::xx(noise_keys).into_authenticated())
             .multiplex(MplexConfig::new())

protocols/identify/src/protocol.rs

@@ -291,7 +291,7 @@ pub enum UpgradeError {
 mod tests {
     use super::*;
     use futures::channel::oneshot;
-    use libp2p::tcp::TcpTransport;
+    use libp2p::tcp;
     use libp2p_core::{
         identity,
         upgrade::{self, apply_inbound, apply_outbound},
@@ -308,7 +308,7 @@ mod tests {
         let (tx, rx) = oneshot::channel();
 
         let bg_task = async_std::task::spawn(async move {
-            let mut transport = TcpTransport::default().boxed();
+            let mut transport = tcp::async_io::Transport::default().boxed();
 
             transport
                 .listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
@@ -351,7 +351,7 @@ mod tests {
         });
 
         async_std::task::block_on(async move {
-            let mut transport = TcpTransport::default();
+            let mut transport = tcp::async_io::Transport::default();
 
             let socket = transport.dial(rx.await.unwrap()).unwrap().await.unwrap();
             let info = apply_outbound(socket, Protocol, upgrade::Version::V1)

protocols/ping/tests/ping.rs

@@ -31,7 +31,7 @@ use libp2p::mplex;
 use libp2p::noise;
 use libp2p::ping;
 use libp2p::swarm::{Swarm, SwarmEvent};
-use libp2p::tcp::{GenTcpConfig, TcpTransport};
+use libp2p::tcp;
 use libp2p::yamux;
 use libp2p::NetworkBehaviour;
 use libp2p_swarm::keep_alive;
@@ -246,7 +246,7 @@ fn mk_transport(muxer: MuxerChoice) -> (PeerId, transport::Boxed<(PeerId, Stream
     let peer_id = id_keys.public().to_peer_id();
     (
         peer_id,
-        TcpTransport::new(GenTcpConfig::default().nodelay(true))
+        tcp::async_io::Transport::new(tcp::Config::default().nodelay(true))
             .upgrade(upgrade::Version::V1)
             .authenticate(noise::NoiseAuthenticated::xx(&id_keys).unwrap())
             .multiplex(match muxer {

protocols/relay/examples/relay_v2.rs

@@ -25,12 +25,13 @@ use futures::stream::StreamExt;
 use libp2p::core::upgrade;
 use libp2p::identify;
 use libp2p::multiaddr::Protocol;
+use libp2p::ping;
 use libp2p::relay::v2::relay::{self, Relay};
 use libp2p::swarm::{Swarm, SwarmEvent};
-use libp2p::tcp::TcpTransport;
+use libp2p::tcp;
+use libp2p::Transport;
 use libp2p::{identity, NetworkBehaviour, PeerId};
 use libp2p::{noise, Multiaddr};
-use libp2p::{ping, Transport};
 use std::error::Error;
 use std::net::{Ipv4Addr, Ipv6Addr};
 
@@ -45,7 +46,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let local_peer_id = PeerId::from(local_key.public());
     println!("Local peer id: {:?}", local_peer_id);
 
-    let tcp_transport = TcpTransport::default();
+    let tcp_transport = tcp::async_io::Transport::default();
 
     let transport = tcp_transport
         .upgrade(upgrade::Version::V1)

protocols/request-response/tests/ping.rs

@@ -25,14 +25,15 @@ use futures::{channel::mpsc, prelude::*, AsyncWriteExt};
 use libp2p::core::{
     identity,
     muxing::StreamMuxerBox,
-    transport::{self, Transport},
+    transport,
     upgrade::{self, read_length_prefixed, write_length_prefixed},
     Multiaddr, PeerId,
 };
 use libp2p::noise::NoiseAuthenticated;
 use libp2p::request_response::*;
 use libp2p::swarm::{Swarm, SwarmEvent};
-use libp2p::tcp::{GenTcpConfig, TcpTransport};
+use libp2p::tcp;
+use libp2p_core::Transport;
 use rand::{self, Rng};
 use std::{io, iter};
 
@@ -298,7 +299,7 @@ fn mk_transport() -> (PeerId, transport::Boxed<(PeerId, StreamMuxerBox)>) {
 
     (
         peer_id,
-        TcpTransport::new(GenTcpConfig::default().nodelay(true))
+        tcp::async_io::Transport::new(tcp::Config::default().nodelay(true))
             .upgrade(upgrade::Version::V1)
             .authenticate(NoiseAuthenticated::xx(&id_keys).unwrap())
             .multiplex(libp2p::yamux::YamuxConfig::default())

src/lib.rs

@@ -204,13 +204,13 @@ pub async fn development_transport(
     keypair: identity::Keypair,
 ) -> std::io::Result<core::transport::Boxed<(PeerId, core::muxing::StreamMuxerBox)>> {
     let transport = {
-        let dns_tcp = dns::DnsConfig::system(tcp::TcpTransport::new(
-            tcp::GenTcpConfig::new().nodelay(true),
+        let dns_tcp = dns::DnsConfig::system(tcp::async_io::Transport::new(
+            tcp::Config::new().nodelay(true),
         ))
         .await?;
         let ws_dns_tcp = websocket::WsConfig::new(
-            dns::DnsConfig::system(tcp::TcpTransport::new(
-                tcp::GenTcpConfig::new().nodelay(true),
+            dns::DnsConfig::system(tcp::async_io::Transport::new(
+                tcp::Config::new().nodelay(true),
             ))
             .await?,
         );
@@ -264,11 +264,11 @@ pub fn tokio_development_transport(
     keypair: identity::Keypair,
 ) -> std::io::Result<core::transport::Boxed<(PeerId, core::muxing::StreamMuxerBox)>> {
     let transport = {
-        let dns_tcp = dns::TokioDnsConfig::system(tcp::TokioTcpTransport::new(
-            tcp::GenTcpConfig::new().nodelay(true),
+        let dns_tcp = dns::TokioDnsConfig::system(tcp::tokio::Transport::new(
+            tcp::Config::new().nodelay(true),
         ))?;
         let ws_dns_tcp = websocket::WsConfig::new(dns::TokioDnsConfig::system(
-            tcp::TokioTcpTransport::new(tcp::GenTcpConfig::new().nodelay(true)),
+            tcp::tokio::Transport::new(tcp::Config::new().nodelay(true)),
         )?);
         dns_tcp.or_transport(ws_dns_tcp)
     };

transports/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::TcpTransport;
+use libp2p::tcp;
 use quickcheck::{QuickCheck, TestResult};
 use rand::RngCore;
 
@@ -46,7 +46,7 @@ fn lot_of_data() {
 
 async fn run(message1: Vec<u8>) {
     let new_transport = || {
-        TcpTransport::default()
+        tcp::async_io::Transport::default()
             .and_then(|conn, endpoint| {
                 upgrade::apply(
                     conn,