refactor(request-response): revise public API to follow naming conven…

…tion (libp2p#3159)

src/behaviour.rs

@@ -32,8 +32,7 @@ use libp2p_core::{
     connection::ConnectionId, multiaddr::Protocol, ConnectedPoint, Endpoint, Multiaddr, PeerId,
 };
 use libp2p_request_response::{
-    ProtocolSupport, RequestId, RequestResponse, RequestResponseConfig, RequestResponseEvent,
-    RequestResponseMessage, ResponseChannel,
+    self as request_response, ProtocolSupport, RequestId, ResponseChannel,
 };
 use libp2p_swarm::{
     behaviour::{
@@ -167,7 +166,7 @@ pub struct Behaviour {
     local_peer_id: PeerId,
 
     // Inner behaviour for sending requests and receiving the response.
-    inner: RequestResponse<AutoNatCodec>,
+    inner: request_response::Behaviour<AutoNatCodec>,
 
     config: Config,
 
@@ -218,9 +217,9 @@ pub struct Behaviour {
 impl Behaviour {
     pub fn new(local_peer_id: PeerId, config: Config) -> Self {
         let protocols = iter::once((AutoNatProtocol, ProtocolSupport::Full));
-        let mut cfg = RequestResponseConfig::default();
+        let mut cfg = request_response::Config::default();
         cfg.set_request_timeout(config.timeout);
-        let inner = RequestResponse::new(AutoNatCodec, protocols, cfg);
+        let inner = request_response::Behaviour::new(AutoNatCodec, protocols, cfg);
         Self {
             local_peer_id,
             inner,
@@ -419,7 +418,8 @@ impl Behaviour {
 }
 
 impl NetworkBehaviour for Behaviour {
-    type ConnectionHandler = <RequestResponse<AutoNatCodec> as NetworkBehaviour>::ConnectionHandler;
+    type ConnectionHandler =
+        <request_response::Behaviour<AutoNatCodec> as NetworkBehaviour>::ConnectionHandler;
     type OutEvent = Event;
 
     fn poll(&mut self, cx: &mut Context<'_>, params: &mut impl PollParameters) -> Poll<Action> {
@@ -432,21 +432,21 @@ impl NetworkBehaviour for Behaviour {
             match self.inner.poll(cx, params) {
                 Poll::Ready(NetworkBehaviourAction::GenerateEvent(event)) => {
                     let (mut events, action) = match event {
-                        RequestResponseEvent::Message {
-                            message: RequestResponseMessage::Response { .. },
+                        request_response::Event::Message {
+                            message: request_response::Message::Response { .. },
                             ..
                         }
-                        | RequestResponseEvent::OutboundFailure { .. } => {
+                        | request_response::Event::OutboundFailure { .. } => {
                             self.as_client().handle_event(params, event)
                         }
-                        RequestResponseEvent::Message {
-                            message: RequestResponseMessage::Request { .. },
+                        request_response::Event::Message {
+                            message: request_response::Message::Request { .. },
                             ..
                         }
-                        | RequestResponseEvent::InboundFailure { .. } => {
+                        | request_response::Event::InboundFailure { .. } => {
                             self.as_server().handle_event(params, event)
                         }
-                        RequestResponseEvent::ResponseSent { .. } => (VecDeque::new(), None),
+                        request_response::Event::ResponseSent { .. } => (VecDeque::new(), None),
                     };
                     self.pending_out_events.append(&mut events);
                     if let Some(action) = action {
@@ -542,12 +542,12 @@ type Action = NetworkBehaviourAction<
     <Behaviour as NetworkBehaviour>::ConnectionHandler,
 >;
 
-// Trait implemented for `AsClient` as `AsServer` to handle events from the inner [`RequestResponse`] Protocol.
+// Trait implemented for `AsClient` and `AsServer` to handle events from the inner [`request_response::Behaviour`] Protocol.
 trait HandleInnerEvent {
     fn handle_event(
         &mut self,
         params: &mut impl PollParameters,
-        event: RequestResponseEvent<DialRequest, DialResponse>,
+        event: request_response::Event<DialRequest, DialResponse>,
     ) -> (VecDeque<Event>, Option<Action>);
 }
 

src/behaviour/as_client.rs

@@ -28,9 +28,7 @@ use futures::FutureExt;
 use futures_timer::Delay;
 use instant::Instant;
 use libp2p_core::{connection::ConnectionId, Multiaddr, PeerId};
-use libp2p_request_response::{
-    OutboundFailure, RequestId, RequestResponse, RequestResponseEvent, RequestResponseMessage,
-};
+use libp2p_request_response::{self as request_response, OutboundFailure, RequestId};
 use libp2p_swarm::{AddressScore, NetworkBehaviourAction, PollParameters};
 use rand::{seq::SliceRandom, thread_rng};
 use std::{
@@ -83,7 +81,7 @@ pub enum OutboundProbeEvent {
 
 /// View over [`super::Behaviour`] in a client role.
 pub struct AsClient<'a> {
-    pub inner: &'a mut RequestResponse<AutoNatCodec>,
+    pub inner: &'a mut request_response::Behaviour<AutoNatCodec>,
     pub local_peer_id: PeerId,
     pub config: &'a Config,
     pub connected: &'a HashMap<PeerId, HashMap<ConnectionId, Option<Multiaddr>>>,
@@ -105,15 +103,15 @@ impl<'a> HandleInnerEvent for AsClient<'a> {
     fn handle_event(
         &mut self,
         params: &mut impl PollParameters,
-        event: RequestResponseEvent<DialRequest, DialResponse>,
+        event: request_response::Event<DialRequest, DialResponse>,
     ) -> (VecDeque<Event>, Option<Action>) {
         let mut events = VecDeque::new();
         let mut action = None;
         match event {
-            RequestResponseEvent::Message {
+            request_response::Event::Message {
                 peer,
                 message:
-                    RequestResponseMessage::Response {
+                    request_response::Message::Response {
                         request_id,
                         response,
                     },
@@ -160,7 +158,7 @@ impl<'a> HandleInnerEvent for AsClient<'a> {
                     }
                 }
             }
-            RequestResponseEvent::OutboundFailure {
+            request_response::Event::OutboundFailure {
                 peer,
                 error,
                 request_id,

src/behaviour/as_server.rs

@@ -25,8 +25,7 @@ use super::{
 use instant::Instant;
 use libp2p_core::{connection::ConnectionId, multiaddr::Protocol, Multiaddr, PeerId};
 use libp2p_request_response::{
-    InboundFailure, RequestId, RequestResponse, RequestResponseEvent, RequestResponseMessage,
-    ResponseChannel,
+    self as request_response, InboundFailure, RequestId, ResponseChannel,
 };
 use libp2p_swarm::{
     dial_opts::{DialOpts, PeerCondition},
@@ -75,7 +74,7 @@ pub enum InboundProbeEvent {
 
 /// View over [`super::Behaviour`] in a server role.
 pub struct AsServer<'a> {
-    pub inner: &'a mut RequestResponse<AutoNatCodec>,
+    pub inner: &'a mut request_response::Behaviour<AutoNatCodec>,
     pub config: &'a Config,
     pub connected: &'a HashMap<PeerId, HashMap<ConnectionId, Option<Multiaddr>>>,
     pub probe_id: &'a mut ProbeId,
@@ -98,15 +97,15 @@ impl<'a> HandleInnerEvent for AsServer<'a> {
     fn handle_event(
         &mut self,
         _params: &mut impl PollParameters,
-        event: RequestResponseEvent<DialRequest, DialResponse>,
+        event: request_response::Event<DialRequest, DialResponse>,
     ) -> (VecDeque<Event>, Option<Action>) {
         let mut events = VecDeque::new();
         let mut action = None;
         match event {
-            RequestResponseEvent::Message {
+            request_response::Event::Message {
                 peer,
                 message:
-                    RequestResponseMessage::Request {
+                    request_response::Message::Request {
                         request_id,
                         request,
                         channel,
@@ -161,7 +160,7 @@ impl<'a> HandleInnerEvent for AsServer<'a> {
                     }
                 }
             }
-            RequestResponseEvent::InboundFailure {
+            request_response::Event::InboundFailure {
                 peer,
                 error,
                 request_id,

src/protocol.rs

@@ -22,7 +22,7 @@ use crate::structs_proto;
 use async_trait::async_trait;
 use futures::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
 use libp2p_core::{upgrade, Multiaddr, PeerId};
-use libp2p_request_response::{ProtocolName, RequestResponseCodec};
+use libp2p_request_response::{self as request_response, ProtocolName};
 use prost::Message;
 use std::{convert::TryFrom, io};
 
@@ -42,7 +42,7 @@ impl ProtocolName for AutoNatProtocol {
 pub struct AutoNatCodec;
 
 #[async_trait]
-impl RequestResponseCodec for AutoNatCodec {
+impl request_response::Codec for AutoNatCodec {
     type Protocol = AutoNatProtocol;
     type Request = DialRequest;
     type Response = DialResponse;