Have Transport::Listeners produce ListenerEvents. (#1032)

Replace the listener and address pair returned from `Transport::listen_on` with just a listener that produces `ListenerEvent` values which include upgrades as well as address changes.

protocols/identify/src/id_transport.rs

@@ -24,7 +24,7 @@ use crate::protocol::{RemoteInfo, IdentifyProtocolConfig};
 use futures::{future, prelude::*, stream, AndThen, MapErr};
 use libp2p_core::{
     Multiaddr, PeerId, PublicKey, muxing, Transport,
-    transport::{TransportError, upgrade::TransportUpgradeError},
+    transport::{TransportError, ListenerEvent, upgrade::TransportUpgradeError},
     upgrade::{self, OutboundUpgradeApply, UpgradeError}
 };
 use std::io::Error as IoError;
@@ -66,7 +66,7 @@ where
 {
     type Output = (PeerId, TMuxer);
     type Error = TransportUpgradeError<TTrans::Error, IoError>;     // TODO: better than IoError
-    type Listener = stream::Empty<(Self::ListenerUpgrade, Multiaddr), Self::Error>;
+    type Listener = stream::Empty<ListenerEvent<Self::ListenerUpgrade>, Self::Error>;
     type ListenerUpgrade = future::Empty<Self::Output, Self::Error>;
     type Dial = AndThen<
         MapErr<TTrans::Dial, fn(TTrans::Error) -> Self::Error>,
@@ -75,7 +75,7 @@ where
     >;
 
     #[inline]
-    fn listen_on(self, addr: Multiaddr) -> Result<(Self::Listener, Multiaddr), TransportError<Self::Error>> {
+    fn listen_on(self, addr: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>> {
         Err(TransportError::MultiaddrNotSupported(addr))
     }
 

protocols/identify/src/identify.rs

@@ -222,7 +222,13 @@ mod tests {
     use crate::{Identify, IdentifyEvent};
     use futures::prelude::*;
     use libp2p_core::identity;
-    use libp2p_core::{upgrade, upgrade::OutboundUpgradeExt, upgrade::InboundUpgradeExt, Swarm, Transport};
+    use libp2p_core::{
+        upgrade::{self, OutboundUpgradeExt, InboundUpgradeExt},
+        Multiaddr,
+        Swarm,
+        Transport
+    };
+    use rand::Rng;
     use std::io;
 
     #[test]
@@ -270,8 +276,13 @@ mod tests {
             Swarm::new(transport, Identify::new("c".to_string(), "d".to_string(), node2_public_key.clone()), local_peer_id)
         };
 
-        let actual_addr = Swarm::listen_on(&mut swarm1, "/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap();
-        Swarm::dial_addr(&mut swarm2, actual_addr).unwrap();
+        let addr: Multiaddr = {
+            let port = rand::thread_rng().gen_range(49152, std::u16::MAX);
+            format!("/ip4/127.0.0.1/tcp/{}", port).parse().unwrap()
+        };
+
+        Swarm::listen_on(&mut swarm1, addr.clone()).unwrap();
+        Swarm::dial_addr(&mut swarm2, addr).unwrap();
 
         let mut swarm1_good = false;
         let mut swarm2_good = false;

protocols/identify/src/protocol.rs

@@ -271,7 +271,12 @@ mod tests {
     use tokio::runtime::current_thread::Runtime;
     use libp2p_tcp::TcpConfig;
     use futures::{Future, Stream};
-    use libp2p_core::{identity, Transport, upgrade::{apply_outbound, apply_inbound}};
+    use libp2p_core::{
+        identity,
+        Transport,
+        transport::ListenerEvent,
+        upgrade::{apply_outbound, apply_inbound}
+    };
     use std::{io, sync::mpsc, thread};
 
     #[test]
@@ -286,13 +291,22 @@ mod tests {
         let bg_thread = thread::spawn(move || {
             let transport = TcpConfig::new();
 
-            let (listener, addr) = transport
+            let mut listener = transport
                 .listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
                 .unwrap();
 
+            let addr = listener.by_ref().wait()
+                .next()
+                .expect("some event")
+                .expect("no error")
+                .into_new_address()
+                .expect("listen address");
+
+
             tx.send(addr).unwrap();
 
             let future = listener
+                .filter_map(ListenerEvent::into_upgrade)
                 .into_future()
                 .map_err(|(err, _)| err)
                 .and_then(|(client, _)| client.unwrap().0)
@@ -321,7 +335,7 @@ mod tests {
 
         let transport = TcpConfig::new();
 
-        let future = transport.dial(rx.recv().unwrap())
+        let future = transport.dial(rx.recv().unwrap().clone())
             .unwrap()
             .and_then(|socket| {
                 apply_outbound(socket, IdentifyProtocolConfig)