feat: enable relay protocol of libp2p

Author: Ma233

Cargo.lock

@@ -1,14 +1,14 @@
 [package]
 name = "dephy-pproxy"
-version = "0.2.1"
+version = "0.3.1"
 edition = "2021"
 
 [dependencies]
 async-trait = "0.1.81"
 clap = "4.5.4"
 futures = "0.3.30"
 hex = "0.4.3"
-libp2p = { version = "0.53.2", features = ["tokio", "macros", "yamux", "noise", "tcp", "request-response"] }
+libp2p = { version = "0.53.2", features = ["tokio", "macros", "yamux", "noise", "tcp", "request-response", "relay"] }
 prost = "0.13.1"
 thiserror = "1.0.60"
 tokio = { version = "1.37.0", features = ["rt-multi-thread"] }

Cargo.toml

@@ -20,7 +20,16 @@ message CreateTunnelServerResponse {
   string address = 2;
 }
 
+message ConnectRelayRequest {
+  string address = 1;
+}
+
+message ConnectRelayResponse {
+  string relaied_address = 1;
+}
+
 service CommandService {
   rpc AddPeer(AddPeerRequest) returns (AddPeerResponse);
   rpc CreateTunnelServer(CreateTunnelServerRequest) returns (CreateTunnelServerResponse);
+  rpc ConnectRelay(ConnectRelayRequest) returns (ConnectRelayResponse);
 }

proto/command_v1.proto

@@ -28,7 +28,7 @@ impl proto::command_service_server::CommandService for PProxyCommander {
         &self,
         request: Request<proto::AddPeerRequest>,
     ) -> Result<Response<proto::AddPeerResponse>, Status> {
-        tracing::trace!("handle request: {:?}", request);
+        tracing::debug!("handle request: {:?}", request);
 
         self.handle
             .add_peer(request.into_inner())
@@ -42,12 +42,25 @@ impl proto::command_service_server::CommandService for PProxyCommander {
         request: tonic::Request<proto::CreateTunnelServerRequest>,
     ) -> std::result::Result<tonic::Response<proto::CreateTunnelServerResponse>, tonic::Status>
     {
-        tracing::trace!("handle request: {:?}", request);
+        tracing::debug!("handle request: {:?}", request);
 
         self.handle
             .create_tunnel_server(request.into_inner())
             .await
             .map(Response::new)
             .map_err(|e| tonic::Status::internal(format!("{:?}", e)))
     }
+
+    async fn connect_relay(
+        &self,
+        request: tonic::Request<proto::ConnectRelayRequest>,
+    ) -> std::result::Result<tonic::Response<proto::ConnectRelayResponse>, tonic::Status> {
+        tracing::debug!("handle request: {:?}", request);
+
+        self.handle
+            .connect_relay(request.into_inner())
+            .await
+            .map(Response::new)
+            .map_err(|e| tonic::Status::internal(format!("{:?}", e)))
+    }
 }

src/command.rs

@@ -17,6 +17,8 @@ pub enum Error {
     EssentialTaskClosed,
     #[error("Libp2p swarm create error: {0}")]
     Libp2pSwarmCreateError(String),
+    #[error("Libp2p transport error: {0}")]
+    Libp2pTransportError(#[from] libp2p::core::transport::TransportError<std::io::Error>),
     #[error("Protocol not support: {0}")]
     ProtocolNotSupport(String),
     #[error("Unexpected response type")]

src/error.rs

@@ -17,6 +17,8 @@ use tokio::sync::mpsc;
 
 use crate::command::proto::AddPeerRequest;
 use crate::command::proto::AddPeerResponse;
+use crate::command::proto::ConnectRelayRequest;
+use crate::command::proto::ConnectRelayResponse;
 use crate::command::proto::CreateTunnelServerRequest;
 use crate::command::proto::CreateTunnelServerResponse;
 use crate::p2p::PProxyNetworkBehaviour;
@@ -59,6 +61,9 @@ pub enum PProxyCommand {
         address: Multiaddr,
         peer_id: PeerId,
     },
+    ConnectRelay {
+        address: Multiaddr,
+    },
     SendConnectCommand {
         peer_id: PeerId,
         tunnel_id: TunnelId,
@@ -73,6 +78,7 @@ pub enum PProxyCommand {
 
 pub enum PProxyCommandResponse {
     AddPeer { peer_id: PeerId },
+    ConnectRelay { relaied_address: Multiaddr },
     SendConnectCommand {},
     SendOutboundPackageCommand {},
 }
@@ -293,6 +299,7 @@ impl PProxy {
             PProxyCommand::AddPeer { address, peer_id } => {
                 self.on_add_peer(address, peer_id, tx).await
             }
+            PProxyCommand::ConnectRelay { address } => self.on_connect_relay(address, tx).await,
             PProxyCommand::SendConnectCommand {
                 peer_id,
                 tunnel_id,
@@ -324,6 +331,17 @@ impl PProxy {
             .map_err(|_| Error::EssentialTaskClosed)
     }
 
+    async fn on_connect_relay(&mut self, address: Multiaddr, tx: CommandNotifier) -> Result<()> {
+        let relaied_address = address
+            .with(multiaddr::Protocol::P2pCircuit)
+            .with(multiaddr::Protocol::P2p(*self.swarm.local_peer_id()));
+
+        self.swarm.listen_on(relaied_address.clone())?;
+
+        tx.send(Ok(PProxyCommandResponse::ConnectRelay { relaied_address }))
+            .map_err(|_| Error::EssentialTaskClosed)
+    }
+
     async fn on_send_connect_command(
         &mut self,
         peer_id: PeerId,
@@ -437,6 +455,31 @@ impl PProxyHandle {
             address: address.to_string(),
         })
     }
+
+    pub async fn connect_relay(
+        &self,
+        request: ConnectRelayRequest,
+    ) -> Result<ConnectRelayResponse> {
+        let (tx, rx) = oneshot::channel();
+
+        let address: Multiaddr = request
+            .address
+            .parse()
+            .map_err(|_| Error::MultiaddrParseError(request.address.clone()))?;
+
+        self.command_tx
+            .send((PProxyCommand::ConnectRelay { address }, tx))
+            .await?;
+
+        let response = rx.await??;
+
+        match response {
+            PProxyCommandResponse::ConnectRelay { relaied_address } => Ok(ConnectRelayResponse {
+                relaied_address: relaied_address.to_string(),
+            }),
+            _ => Err(Error::UnexpectedResponseType),
+        }
+    }
 }
 
 fn extract_peer_id_from_multiaddr(multiaddr: &Multiaddr) -> Result<PeerId> {

src/lib.rs

@@ -1,4 +1,5 @@
 use libp2p::identity::Keypair;
+use libp2p::relay;
 use libp2p::request_response;
 use libp2p::swarm::NetworkBehaviour;
 use libp2p::StreamProtocol;
@@ -8,17 +9,22 @@ use crate::p2p::codec::Codec;
 #[derive(NetworkBehaviour)]
 pub(crate) struct PProxyNetworkBehaviour {
     pub(crate) request_response: request_response::Behaviour<Codec>,
+    pub(crate) relay: relay::Behaviour,
 }
 
 impl PProxyNetworkBehaviour {
-    pub fn new(_key: &Keypair) -> Self {
+    pub fn new(key: &Keypair) -> Self {
         let request_response = request_response::Behaviour::new(
             [(
-                StreamProtocol::new("/pproxy/1"),
+                StreamProtocol::new("/pproxy/1.0.0"),
                 request_response::ProtocolSupport::Full,
             )],
             request_response::Config::default(),
         );
-        Self { request_response }
+        let relay = relay::Behaviour::new(key.public().to_peer_id(), Default::default());
+        Self {
+            request_response,
+            relay,
+        }
     }
 }