fix: Change request-response type

Author: aidan46

node/src/service/p2p/bootstrap.rs

@@ -14,7 +14,7 @@ use libp2p::{
     tcp, yamux, Multiaddr, PeerId, StreamProtocol, Swarm, SwarmBuilder,
 };
 use log::{debug, error, info, warn};
-use primitives::p2p::{PeerInfo, WPeerId};
+use primitives::p2p::{PeerIdRequest, PeerInfo, PeerInfoResponse};
 
 use crate::service::p2p::{P2PError, DEFAULT_REGISTRATION_TTL};
 
@@ -25,7 +25,7 @@ pub struct BootstrapBehaviour {
     pub rendezvous: rendezvous::server::Behaviour,
     pub identify: identify::Behaviour,
     pub gossipsub: gossipsub::Behaviour,
-    pub request_response: request_response::cbor::Behaviour<WPeerId, PeerInfo>,
+    pub request_response: request_response::cbor::Behaviour<PeerIdRequest, PeerInfoResponse>,
 }
 
 pub struct BootstrapConfig {
@@ -185,7 +185,7 @@ fn on_rendezvous_event(
                             info.multiaddrs.push(addr.clone())
                         }
                     }
-                }  )
+                })
                 .or_insert(peer_info);
             // Send registration information to other bootstrap nodes.
             match swarm
@@ -236,7 +236,7 @@ fn on_gossipsub_event(
                             info.multiaddrs.push(addr.clone())
                         }
                     }
-                }  )
+                })
                 .or_insert(peer_info);
         }
         other => debug!("Encountered other gossipsub event: {other:?}"),
@@ -246,7 +246,7 @@ fn on_gossipsub_event(
 /// Handles events within the request_response protocol
 fn on_request_response_event(
     swarm: &mut Swarm<BootstrapBehaviour>,
-    event: request_response::Event<WPeerId, PeerInfo>,
+    event: request_response::Event<PeerIdRequest, PeerInfoResponse>,
     registrations: &HashMap<PeerId, PeerInfo>,
 ) {
     match event {
@@ -260,20 +260,25 @@ fn on_request_response_event(
             {
                 info!("Got request with id {request_id} from {peer}");
                 let id: PeerId = request.into();
-                match registrations.get(&id) {
+                let response = match registrations.get(&id) {
                     Some(peer_info) => {
-                        // Sending the peer information back to the client who opened the channel.
-                        if swarm
-                            .behaviour_mut()
-                            .request_response
-                            .send_response(channel, peer_info.clone())
-                            .is_err()
-                        {
-                            // Could add retries here.
-                            error!("Failed to send peer info to {peer:?}");
-                        }
+                        info!("Peer {id:?} found in registrations");
+                        PeerInfoResponse::Found(peer_info.clone())
                     }
-                    None => warn!("Peer {id:?} not found in registrations"),
+                    None => {
+                        info!("Peer {id:?} not found in registrations");
+                        PeerInfoResponse::NotFound(id.into())
+                    }
+                };
+                // Sending the peer information back to the client who opened the channel.
+                // Could add retries here.
+                if swarm
+                    .behaviour_mut()
+                    .request_response
+                    .send_response(channel, response)
+                    .is_err()
+                {
+                    error!("Failed to send peer info to {peer:?}");
                 }
             }
         }

primitives/src/p2p.rs

@@ -34,34 +34,46 @@ pub struct PeerInfo {
     pub multiaddrs: Vec<Multiaddr>,
 }
 
-fn deserialize_peer_id<'de, D: de::Deserializer<'de>>(d: D) -> Result<PeerId, D::Error> {
-    let s: String = de::Deserialize::deserialize(d)?;
-    PeerId::from_str(&s).map_err(de::Error::custom)
-}
-
-fn serialize_peer_id<S: Serializer>(id: &PeerId, serializer: S) -> Result<S::Ok, S::Error> {
-    let id = id.to_string();
-    serializer.collect_str(&id)
+/// This enum is used in the request response P2P protocol.
+/// PeerInfoResponse::NotFound is returned when the requested peer ID was not found.
+/// PeerInfoResponse::Found(..) is returned when the requested peer ID was found.
+/// The latter holds the relevant [`PeerInfo`] inside.
+#[cfg(feature = "std")]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum PeerInfoResponse {
+    Found(PeerInfo),
+    NotFound(PeerIdRequest),
 }
 
-/// Wrapper struct for Peer ID so we can implement `Deserialize` and `Serialize`
-/// and use this type in the request response behaviour.
+/// The request type used for the request response P2P protocol.
+/// We cannot use PeerId directly because it does not implement
+/// Serialize and Deserialize.
 #[cfg(feature = "std")]
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct WPeerId(
+pub struct PeerIdRequest(
     #[serde(serialize_with = "serialize_peer_id")]
     #[serde(deserialize_with = "deserialize_peer_id")]
     PeerId,
 );
 
-impl From<PeerId> for WPeerId {
+impl From<PeerId> for PeerIdRequest {
     fn from(value: PeerId) -> Self {
         Self(value)
     }
 }
 
-impl Into<PeerId> for WPeerId {
+impl Into<PeerId> for PeerIdRequest {
     fn into(self) -> PeerId {
         self.0
     }
-}
+}
+
+fn deserialize_peer_id<'de, D: de::Deserializer<'de>>(d: D) -> Result<PeerId, D::Error> {
+    let s: String = de::Deserialize::deserialize(d)?;
+    PeerId::from_str(&s).map_err(de::Error::custom)
+}
+
+fn serialize_peer_id<S: Serializer>(id: &PeerId, serializer: S) -> Result<S::Ok, S::Error> {
+    let id = id.to_string();
+    serializer.collect_str(&id)
+}

storage-provider/client/examples/peer-resolver.rs

@@ -16,11 +16,12 @@ use libp2p::swarm::SwarmEvent;
 use libp2p::{
     noise, request_response, tcp, yamux, Multiaddr, PeerId, StreamProtocol, Swarm, SwarmBuilder,
 };
-use primitives::p2p::{PeerInfo, WPeerId};
+use primitives::p2p::{PeerIdRequest, PeerInfoResponse};
 use tracing_subscriber::EnvFilter;
 
 /// Create a discovery swarm
-fn create_discover_swarm() -> Result<Swarm<request_response::cbor::Behaviour<WPeerId, PeerInfo>>> {
+fn create_discover_swarm(
+) -> Result<Swarm<request_response::cbor::Behaviour<PeerIdRequest, PeerInfoResponse>>> {
     let swarm = SwarmBuilder::with_new_identity()
         .with_tokio()
         .with_tcp(
@@ -44,11 +45,11 @@ fn create_discover_swarm() -> Result<Swarm<request_response::cbor::Behaviour<WPe
 
 /// Run the discovery swarm and request the peer ID to multiaddrs mapping.
 async fn run_discover(
-    mut swarm: Swarm<request_response::cbor::Behaviour<WPeerId, PeerInfo>>,
+    mut swarm: Swarm<request_response::cbor::Behaviour<PeerIdRequest, PeerInfoResponse>>,
     bootstrap_addr: Multiaddr,
     bootstrap_id: &PeerId,
     resolve_id: PeerId,
-) -> Result<PeerInfo> {
+) -> Result<PeerInfoResponse> {
     swarm.dial(bootstrap_addr)?;
 
     loop {
@@ -116,9 +117,12 @@ async fn main() -> Result<()> {
     println!("Attempting to get multiaddrs for peer {:?}", cli.resolve_id);
     let peer_info =
         run_discover(swarm, cli.bootstrap_addr, &cli.bootstrap_id, cli.resolve_id).await?;
-    println!(
-        "Got multiaddrs {:#?} for peer {:?}",
-        peer_info.multiaddrs, peer_info.peer_id
-    );
+    match peer_info {
+        PeerInfoResponse::NotFound(peer) => println!("Peer {:?} is not registered", peer),
+        PeerInfoResponse::Found(info) => println!(
+            "Got multiaddrs {:#?} for peer {:?}",
+            info.multiaddrs, info.peer_id
+        ),
+    }
     Ok(())
 }