Use naming as per #2174

Author: thomaseizinger

protocols/rendezvous/examples/discover.rs

@@ -23,13 +23,12 @@ use libp2p::core::identity;
 use libp2p::core::PeerId;
 use libp2p::multiaddr::Protocol;
 use libp2p::ping::{Ping, PingConfig, PingEvent, PingSuccess};
-use libp2p::rendezvous::{Namespace, Rendezvous};
 use libp2p::swarm::Swarm;
 use libp2p::swarm::SwarmEvent;
 use libp2p::{development_transport, rendezvous, Multiaddr};
 use std::time::Duration;
 
-const NAMESPACE: &'static str = "rendezvous";
+const NAMESPACE: &str = "rendezvous";
 
 #[async_std::main]
 async fn main() {
@@ -44,7 +43,7 @@ async fn main() {
     let mut swarm = Swarm::new(
         development_transport(identity.clone()).await.unwrap(),
         MyBehaviour {
-            rendezvous: Rendezvous::new(identity.clone(), rendezvous::Config::default()),
+            rendezvous: rendezvous::Behaviour::new(identity.clone(), rendezvous::Config::default()),
             ping: Ping::new(PingConfig::new().with_interval(Duration::from_secs(1))),
         },
         PeerId::from(identity.public()),
@@ -63,7 +62,7 @@ async fn main() {
                 );
 
                 swarm.behaviour_mut().rendezvous.discover(
-                    Some(Namespace::new(NAMESPACE.to_string()).unwrap()),
+                    Some(rendezvous::Namespace::new(NAMESPACE.to_string()).unwrap()),
                     None,
                     None,
                     rendezvous_point,
@@ -89,7 +88,7 @@ async fn main() {
                         let peer = registration.record.peer_id();
                         log::info!("Discovered peer {} at {}", peer, address);
 
-                        let p2p_suffix = Protocol::P2p(peer.as_ref().clone());
+                        let p2p_suffix = Protocol::P2p(*peer.as_ref());
                         let address_with_p2p =
                             if !address.ends_with(&Multiaddr::empty().with(p2p_suffix.clone())) {
                                 address.clone().with(p2p_suffix)
@@ -136,6 +135,6 @@ impl From<PingEvent> for MyEvent {
 #[behaviour(event_process = false)]
 #[behaviour(out_event = "MyEvent")]
 struct MyBehaviour {
-    rendezvous: Rendezvous,
+    rendezvous: rendezvous::Behaviour,
     ping: Ping,
 }

protocols/rendezvous/examples/register.rs

@@ -22,12 +22,10 @@ use futures::StreamExt;
 use libp2p::core::identity;
 use libp2p::core::PeerId;
 use libp2p::ping::{Ping, PingConfig, PingEvent, PingSuccess};
-use libp2p::rendezvous::Rendezvous;
 use libp2p::swarm::Swarm;
 use libp2p::swarm::SwarmEvent;
 use libp2p::{development_transport, rendezvous};
 use libp2p::{Multiaddr, NetworkBehaviour};
-use libp2p_rendezvous::Namespace;
 use libp2p_swarm::AddressScore;
 use std::time::Duration;
 
@@ -45,7 +43,7 @@ async fn main() {
     let mut swarm = Swarm::new(
         development_transport(identity.clone()).await.unwrap(),
         MyBehaviour {
-            rendezvous: Rendezvous::new(identity.clone(), rendezvous::Config::default()),
+            rendezvous: rendezvous::Behaviour::new(identity.clone(), rendezvous::Config::default()),
             ping: Ping::new(PingConfig::new().with_interval(Duration::from_secs(1))),
         },
         PeerId::from(identity.public()),
@@ -76,7 +74,7 @@ async fn main() {
             }
             SwarmEvent::ConnectionEstablished { peer_id, .. } if peer_id == rendezvous_point => {
                 swarm.behaviour_mut().rendezvous.register(
-                    Namespace::from_static("rendezvous"),
+                    rendezvous::Namespace::from_static("rendezvous"),
                     rendezvous_point,
                     None,
                 );
@@ -136,6 +134,6 @@ impl From<PingEvent> for MyEvent {
 #[behaviour(event_process = false)]
 #[behaviour(out_event = "MyEvent")]
 struct MyBehaviour {
-    rendezvous: Rendezvous,
+    rendezvous: rendezvous::Behaviour,
     ping: Ping,
 }

protocols/rendezvous/examples/register_with_identify.rs

@@ -23,12 +23,10 @@ use libp2p::core::identity;
 use libp2p::core::PeerId;
 use libp2p::identify::{Identify, IdentifyConfig, IdentifyEvent};
 use libp2p::ping::{Ping, PingConfig, PingEvent, PingSuccess};
-use libp2p::rendezvous::Rendezvous;
 use libp2p::swarm::Swarm;
 use libp2p::swarm::SwarmEvent;
 use libp2p::{development_transport, rendezvous};
 use libp2p::{Multiaddr, NetworkBehaviour};
-use libp2p_rendezvous::Namespace;
 use std::time::Duration;
 
 #[async_std::main]
@@ -49,7 +47,7 @@ async fn main() {
                 "rendezvous-example/1.0.0".to_string(),
                 identity.public(),
             )),
-            rendezvous: Rendezvous::new(identity.clone(), rendezvous::Config::default()),
+            rendezvous: rendezvous::Behaviour::new(identity.clone(), rendezvous::Config::default()),
             ping: Ping::new(PingConfig::new().with_interval(Duration::from_secs(1))),
         },
         PeerId::from(identity.public()),
@@ -76,7 +74,7 @@ async fn main() {
             // once `/identify` did its job, we know our external address and can register
             SwarmEvent::Behaviour(MyEvent::Identify(IdentifyEvent::Received { .. })) => {
                 swarm.behaviour_mut().rendezvous.register(
-                    Namespace::from_static("rendezvous"),
+                    rendezvous::Namespace::from_static("rendezvous"),
                     rendezvous_point,
                     None,
                 );
@@ -142,6 +140,6 @@ impl From<PingEvent> for MyEvent {
 #[behaviour(out_event = "MyEvent")]
 struct MyBehaviour {
     identify: Identify,
-    rendezvous: Rendezvous,
+    rendezvous: rendezvous::Behaviour,
     ping: Ping,
 }

protocols/rendezvous/examples/rendezvous_point.rs

@@ -22,7 +22,6 @@ use futures::StreamExt;
 use libp2p::core::identity;
 use libp2p::core::PeerId;
 use libp2p::ping::{Ping, PingEvent};
-use libp2p::rendezvous::Rendezvous;
 use libp2p::swarm::{Swarm, SwarmEvent};
 use libp2p::NetworkBehaviour;
 use libp2p::{development_transport, rendezvous};
@@ -38,7 +37,7 @@ async fn main() {
     let mut swarm = Swarm::new(
         development_transport(identity.clone()).await.unwrap(),
         MyBehaviour {
-            rendezvous: Rendezvous::new(identity.clone(), rendezvous::Config::default()),
+            rendezvous: rendezvous::Behaviour::new(identity.clone(), rendezvous::Config::default()),
             ping: Ping::default(),
         },
         PeerId::from(identity.public()),
@@ -107,6 +106,6 @@ impl From<PingEvent> for MyEvent {
 #[behaviour(event_process = false)]
 #[behaviour(out_event = "MyEvent")]
 struct MyBehaviour {
-    rendezvous: Rendezvous,
+    rendezvous: rendezvous::Behaviour,
     ping: Ping,
 }

protocols/rendezvous/src/behaviour.rs

@@ -40,7 +40,7 @@ use std::iter::FromIterator;
 use std::task::{Context, Poll};
 use std::time::Duration;
 
-pub struct Rendezvous {
+pub struct Behaviour {
     events: VecDeque<NetworkBehaviourAction<handler::InEvent, Event>>,
     registrations: Registrations,
     keypair: Keypair,
@@ -78,7 +78,7 @@ impl Default for Config {
     }
 }
 
-impl Rendezvous {
+impl Behaviour {
     /// Create a new instance of the rendezvous [`NetworkBehaviour`].
     pub fn new(keypair: Keypair, config: Config) -> Self {
         Self {
@@ -201,7 +201,7 @@ pub enum Event {
     RegistrationExpired(Registration),
 }
 
-impl NetworkBehaviour for Rendezvous {
+impl NetworkBehaviour for Behaviour {
     type ProtocolsHandler =
         SubstreamProtocolsHandler<inbound::Stream, outbound::Stream, outbound::OpenInfo>;
     type OutEvent = Event;

protocols/rendezvous/src/lib.rs

@@ -18,7 +18,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-pub use self::behaviour::{Config, Event, RegisterError, Rendezvous};
+pub use self::behaviour::{Behaviour, Config, Event, RegisterError};
 pub use self::codec::{ErrorCode, Namespace, NamespaceTooLong, Registration, Ttl};
 
 mod behaviour;

protocols/rendezvous/tests/harness/mod.rs

@@ -20,20 +20,18 @@
 
 use async_trait::async_trait;
 use futures::stream::FusedStream;
-use futures::Future;
 use futures::StreamExt;
 use futures::{future, Stream};
 use libp2p::core::muxing::StreamMuxerBox;
 use libp2p::core::transport::upgrade::Version;
 use libp2p::core::transport::MemoryTransport;
 use libp2p::core::upgrade::SelectUpgrade;
-use libp2p::core::{identity, Executor, Multiaddr, PeerId, Transport};
+use libp2p::core::{identity, Multiaddr, PeerId, Transport};
 use libp2p::mplex::MplexConfig;
 use libp2p::noise::{Keypair, NoiseConfig, X25519Spec};
 use libp2p::swarm::{AddressScore, NetworkBehaviour, Swarm, SwarmBuilder, SwarmEvent};
 use libp2p::yamux::YamuxConfig;
 use std::fmt::Debug;
-use std::pin::Pin;
 use std::time::Duration;
 
 pub fn new_swarm<B, F>(behaviour_fn: F) -> Swarm<B>