use customized rpc implementation, remove Tarpc & Tonic (#348)

This patch removes Tarpc & Tonic GRPC and implements a customized rpc framework, which can be used by peer rpc and cli interface.

web config server can also use this rpc framework.

moreover, rewrite the public server logic, use ospf route to implement public server based networking. this make public server mesh possible.

easytier/src/connector/direct.rs

@@ -5,9 +5,17 @@ use std::{net::SocketAddr, sync::Arc};
 use crate::{
     common::{error::Error, global_ctx::ArcGlobalCtx, PeerId},
     peers::{peer_manager::PeerManager, peer_rpc::PeerRpcManager},
+    proto::{
+        peer_rpc::{
+            DirectConnectorRpc, DirectConnectorRpcClientFactory, DirectConnectorRpcServer,
+            GetIpListRequest, GetIpListResponse,
+        },
+        rpc_types::{self, controller::BaseController},
+    },
 };
 
-use crate::rpc::{peer::GetIpListResponse, PeerConnInfo};
+use crate::proto::cli::PeerConnInfo;
+use anyhow::Context;
 use tokio::{task::JoinSet, time::timeout};
 use tracing::Instrument;
 use url::Host;
@@ -17,11 +25,6 @@ use super::create_connector_by_url;
 pub const DIRECT_CONNECTOR_SERVICE_ID: u32 = 1;
 pub const DIRECT_CONNECTOR_BLACKLIST_TIMEOUT_SEC: u64 = 300;
 
-#[tarpc::service]
-pub trait DirectConnectorRpc {
-    async fn get_ip_list() -> GetIpListResponse;
-}
-
 #[async_trait::async_trait]
 pub trait PeerManagerForDirectConnector {
     async fn list_peers(&self) -> Vec<PeerId>;
@@ -57,12 +60,23 @@ struct DirectConnectorManagerRpcServer {
     global_ctx: ArcGlobalCtx,
 }
 
-#[tarpc::server]
+#[async_trait::async_trait]
 impl DirectConnectorRpc for DirectConnectorManagerRpcServer {
-    async fn get_ip_list(self, _: tarpc::context::Context) -> GetIpListResponse {
+    type Controller = BaseController;
+
+    async fn get_ip_list(
+        &self,
+        _: BaseController,
+        _: GetIpListRequest,
+    ) -> rpc_types::error::Result<GetIpListResponse> {
         let mut ret = self.global_ctx.get_ip_collector().collect_ip_addrs().await;
-        ret.listeners = self.global_ctx.get_running_listeners();
-        ret
+        ret.listeners = self
+            .global_ctx
+            .get_running_listeners()
+            .into_iter()
+            .map(Into::into)
+            .collect();
+        Ok(ret)
     }
 }
 
@@ -130,10 +144,17 @@ impl DirectConnectorManager {
     }
 
     pub fn run_as_server(&mut self) {
-        self.data.peer_manager.get_peer_rpc_mgr().run_service(
-            DIRECT_CONNECTOR_SERVICE_ID,
-            DirectConnectorManagerRpcServer::new(self.global_ctx.clone()).serve(),
-        );
+        self.data
+            .peer_manager
+            .get_peer_rpc_mgr()
+            .rpc_server()
+            .registry()
+            .register(
+                DirectConnectorRpcServer::new(DirectConnectorManagerRpcServer::new(
+                    self.global_ctx.clone(),
+                )),
+                &self.data.global_ctx.get_network_name(),
+            );
     }
 
     pub fn run_as_client(&mut self) {
@@ -238,7 +259,8 @@ impl DirectConnectorManager {
         let enable_ipv6 = data.global_ctx.get_flags().enable_ipv6;
         let available_listeners = ip_list
             .listeners
-            .iter()
+            .into_iter()
+            .map(Into::<url::Url>::into)
             .filter_map(|l| if l.scheme() != "ring" { Some(l) } else { None })
             .filter(|l| l.port().is_some() && l.host().is_some())
             .filter(|l| {
@@ -268,7 +290,7 @@ impl DirectConnectorManager {
             Some(SocketAddr::V4(_)) => {
                 ip_list.interface_ipv4s.iter().for_each(|ip| {
                     let mut addr = (*listener).clone();
-                    if addr.set_host(Some(ip.as_str())).is_ok() {
+                    if addr.set_host(Some(ip.to_string().as_str())).is_ok() {
                         tasks.spawn(Self::try_connect_to_ip(
                             data.clone(),
                             dst_peer_id.clone(),
@@ -277,19 +299,27 @@ impl DirectConnectorManager {
                     }
                 });
 
-                let mut addr = (*listener).clone();
-                if addr.set_host(Some(ip_list.public_ipv4.as_str())).is_ok() {
-                    tasks.spawn(Self::try_connect_to_ip(
-                        data.clone(),
-                        dst_peer_id.clone(),
-                        addr.to_string(),
-                    ));
+                if let Some(public_ipv4) = ip_list.public_ipv4 {
+                    let mut addr = (*listener).clone();
+                    if addr
+                        .set_host(Some(public_ipv4.to_string().as_str()))
+                        .is_ok()
+                    {
+                        tasks.spawn(Self::try_connect_to_ip(
+                            data.clone(),
+                            dst_peer_id.clone(),
+                            addr.to_string(),
+                        ));
+                    }
                 }
             }
             Some(SocketAddr::V6(_)) => {
                 ip_list.interface_ipv6s.iter().for_each(|ip| {
                     let mut addr = (*listener).clone();
-                    if addr.set_host(Some(format!("[{}]", ip).as_str())).is_ok() {
+                    if addr
+                        .set_host(Some(format!("[{}]", ip.to_string()).as_str()))
+                        .is_ok()
+                    {
                         tasks.spawn(Self::try_connect_to_ip(
                             data.clone(),
                             dst_peer_id.clone(),
@@ -298,16 +328,18 @@ impl DirectConnectorManager {
                     }
                 });
 
-                let mut addr = (*listener).clone();
-                if addr
-                    .set_host(Some(format!("[{}]", ip_list.public_ipv6).as_str()))
-                    .is_ok()
-                {
-                    tasks.spawn(Self::try_connect_to_ip(
-                        data.clone(),
-                        dst_peer_id.clone(),
-                        addr.to_string(),
-                    ));
+                if let Some(public_ipv6) = ip_list.public_ipv6 {
+                    let mut addr = (*listener).clone();
+                    if addr
+                        .set_host(Some(format!("[{}]", public_ipv6.to_string()).as_str()))
+                        .is_ok()
+                    {
+                        tasks.spawn(Self::try_connect_to_ip(
+                            data.clone(),
+                            dst_peer_id.clone(),
+                            addr.to_string(),
+                        ));
+                    }
                 }
             }
             p => {
@@ -351,16 +383,21 @@ impl DirectConnectorManager {
 
         tracing::trace!("try direct connect to peer: {}", dst_peer_id);
 
-        let ip_list = peer_manager
+        let rpc_stub = peer_manager
             .get_peer_rpc_mgr()
-            .do_client_rpc_scoped(1, dst_peer_id, |c| async {
-                let client =
-                    DirectConnectorRpcClient::new(tarpc::client::Config::default(), c).spawn();
-                let ip_list = client.get_ip_list(tarpc::context::current()).await;
-                tracing::info!(ip_list = ?ip_list, dst_peer_id = ?dst_peer_id, "got ip list");
-                ip_list
-            })
-            .await?;
+            .rpc_client()
+            .scoped_client::<DirectConnectorRpcClientFactory<BaseController>>(
+                peer_manager.my_peer_id(),
+                dst_peer_id,
+                data.global_ctx.get_network_name(),
+            );
+
+        let ip_list = rpc_stub
+            .get_ip_list(BaseController {}, GetIpListRequest {})
+            .await
+            .with_context(|| format!("get ip list from peer {}", dst_peer_id))?;
+
+        tracing::info!(ip_list = ?ip_list, dst_peer_id = ?dst_peer_id, "got ip list");
 
         Self::do_try_direct_connect_internal(data, dst_peer_id, ip_list).await
     }
@@ -380,7 +417,7 @@ mod tests {
             connect_peer_manager, create_mock_peer_manager, wait_route_appear,
             wait_route_appear_with_cost,
         },
-        rpc::peer::GetIpListResponse,
+        proto::peer_rpc::GetIpListResponse,
     };
 
     #[rstest::rstest]
@@ -436,12 +473,14 @@ mod tests {
             p_a.get_global_ctx(),
             p_a.clone(),
         ));
-        let mut ip_list = GetIpListResponse::new();
+        let mut ip_list = GetIpListResponse::default();
         ip_list
             .listeners
             .push("tcp://127.0.0.1:10222".parse().unwrap());
 
-        ip_list.interface_ipv4s.push("127.0.0.1".to_string());
+        ip_list
+            .interface_ipv4s
+            .push("127.0.0.1".parse::<std::net::Ipv4Addr>().unwrap().into());
 
         DirectConnectorManager::do_try_direct_connect_internal(data.clone(), 1, ip_list.clone())
             .await

easytier/src/connector/manual.rs

@@ -11,7 +11,12 @@ use tokio::{
 use crate::{
     common::PeerId,
     peers::peer_conn::PeerConnId,
-    rpc as easytier_rpc,
+    proto::{
+        cli::{
+            ConnectorManageAction, ListConnectorResponse, ManageConnectorResponse, PeerConnInfo,
+        },
+        rpc_types::{self, controller::BaseController},
+    },
     tunnel::{IpVersion, TunnelConnector},
 };
 
@@ -23,9 +28,9 @@ use crate::{
     },
     connector::set_bind_addr_for_peer_connector,
     peers::peer_manager::PeerManager,
-    rpc::{
-        connector_manage_rpc_server::ConnectorManageRpc, Connector, ConnectorStatus,
-        ListConnectorRequest, ManageConnectorRequest,
+    proto::cli::{
+        Connector, ConnectorManageRpc, ConnectorStatus, ListConnectorRequest,
+        ManageConnectorRequest,
     },
     use_global_var,
 };
@@ -105,12 +110,18 @@ impl ManualConnectorManager {
         Ok(())
     }
 
-    pub async fn remove_connector(&self, url: &str) -> Result<(), Error> {
+    pub async fn remove_connector(&self, url: url::Url) -> Result<(), Error> {
         tracing::info!("remove_connector: {}", url);
-        if !self.list_connectors().await.iter().any(|x| x.url == url) {
+        let url = url.into();
+        if !self
+            .list_connectors()
+            .await
+            .iter()
+            .any(|x| x.url.as_ref() == Some(&url))
+        {
             return Err(Error::NotFound);
         }
-        self.data.removed_conn_urls.insert(url.into());
+        self.data.removed_conn_urls.insert(url.to_string());
         Ok(())
     }
 
@@ -137,7 +148,7 @@ impl ManualConnectorManager {
             ret.insert(
                 0,
                 Connector {
-                    url: conn_url,
+                    url: Some(conn_url.parse().unwrap()),
                     status: status.into(),
                 },
             );
@@ -154,7 +165,7 @@ impl ManualConnectorManager {
             ret.insert(
                 0,
                 Connector {
-                    url: conn_url,
+                    url: Some(conn_url.parse().unwrap()),
                     status: ConnectorStatus::Connecting.into(),
                 },
             );
@@ -213,14 +224,14 @@ impl ManualConnectorManager {
     }
 
     async fn handle_event(event: &GlobalCtxEvent, data: &ConnectorManagerData) {
-        let need_add_alive = |conn_info: &easytier_rpc::PeerConnInfo| conn_info.is_client;
+        let need_add_alive = |conn_info: &PeerConnInfo| conn_info.is_client;
         match event {
             GlobalCtxEvent::PeerConnAdded(conn_info) => {
                 if !need_add_alive(conn_info) {
                     return;
                 }
                 let addr = conn_info.tunnel.as_ref().unwrap().remote_addr.clone();
-                data.alive_conn_urls.insert(addr);
+                data.alive_conn_urls.insert(addr.unwrap().to_string());
                 tracing::warn!("peer conn added: {:?}", conn_info);
             }
 
@@ -229,7 +240,7 @@ impl ManualConnectorManager {
                     return;
                 }
                 let addr = conn_info.tunnel.as_ref().unwrap().remote_addr.clone();
-                data.alive_conn_urls.remove(&addr);
+                data.alive_conn_urls.remove(&addr.unwrap().to_string());
                 tracing::warn!("peer conn removed: {:?}", conn_info);
             }
 
@@ -303,7 +314,7 @@ impl ManualConnectorManager {
         tracing::info!("reconnect get tunnel succ: {:?}", tunnel);
         assert_eq!(
             dead_url,
-            tunnel.info().unwrap().remote_addr,
+            tunnel.info().unwrap().remote_addr.unwrap().to_string(),
             "info: {:?}",
             tunnel.info()
         );
@@ -385,45 +396,43 @@ impl ManualConnectorManager {
     }
 }
 
+#[derive(Clone)]
 pub struct ConnectorManagerRpcService(pub Arc<ManualConnectorManager>);
 
-#[tonic::async_trait]
+#[async_trait::async_trait]
 impl ConnectorManageRpc for ConnectorManagerRpcService {
+    type Controller = BaseController;
+
     async fn list_connector(
         &self,
-        _request: tonic::Request<ListConnectorRequest>,
-    ) -> Result<tonic::Response<easytier_rpc::ListConnectorResponse>, tonic::Status> {
-        let mut ret = easytier_rpc::ListConnectorResponse::default();
+        _: BaseController,
+        _request: ListConnectorRequest,
+    ) -> Result<ListConnectorResponse, rpc_types::error::Error> {
+        let mut ret = ListConnectorResponse::default();
         let connectors = self.0.list_connectors().await;
         ret.connectors = connectors;
-        Ok(tonic::Response::new(ret))
+        Ok(ret)
     }
 
     async fn manage_connector(
         &self,
-        request: tonic::Request<ManageConnectorRequest>,
-    ) -> Result<tonic::Response<easytier_rpc::ManageConnectorResponse>, tonic::Status> {
-        let req = request.into_inner();
-        let url = url::Url::parse(&req.url)
-            .map_err(|_| tonic::Status::invalid_argument("invalid url"))?;
-        if req.action == easytier_rpc::ConnectorManageAction::Remove as i32 {
-            self.0.remove_connector(url.path()).await.map_err(|e| {
-                tonic::Status::invalid_argument(format!("remove connector failed: {:?}", e))
-            })?;
-            return Ok(tonic::Response::new(
-                easytier_rpc::ManageConnectorResponse::default(),
-            ));
+        _: BaseController,
+        req: ManageConnectorRequest,
+    ) -> Result<ManageConnectorResponse, rpc_types::error::Error> {
+        let url: url::Url = req.url.ok_or(anyhow::anyhow!("url is empty"))?.into();
+        if req.action == ConnectorManageAction::Remove as i32 {
+            self.0
+                .remove_connector(url.clone())
+                .await
+                .with_context(|| format!("remove connector failed: {:?}", url))?;
+            return Ok(ManageConnectorResponse::default());
         } else {
             self.0
                 .add_connector_by_url(url.as_str())
                 .await
-                .map_err(|e| {
-                    tonic::Status::invalid_argument(format!("add connector failed: {:?}", e))
-                })?;
+                .with_context(|| format!("add connector failed: {:?}", url))?;
         }
-        Ok(tonic::Response::new(
-            easytier_rpc::ManageConnectorResponse::default(),
-        ))
+        Ok(ManageConnectorResponse::default())
     }
 }
 

easytier/src/connector/mod.rs

@@ -32,14 +32,14 @@ async fn set_bind_addr_for_peer_connector(
     if is_ipv4 {
         let mut bind_addrs = vec![];
         for ipv4 in ips.interface_ipv4s {
-            let socket_addr = SocketAddrV4::new(ipv4.parse().unwrap(), 0).into();
+            let socket_addr = SocketAddrV4::new(ipv4.into(), 0).into();
             bind_addrs.push(socket_addr);
         }
         connector.set_bind_addrs(bind_addrs);
     } else {
         let mut bind_addrs = vec![];
         for ipv6 in ips.interface_ipv6s {
-            let socket_addr = SocketAddrV6::new(ipv6.parse().unwrap(), 0, 0, 0).into();
+            let socket_addr = SocketAddrV6::new(ipv6.into(), 0, 0, 0).into();
             bind_addrs.push(socket_addr);
         }
         connector.set_bind_addrs(bind_addrs);

easytier/src/connector/udp_hole_punch.rs

@@ -5,6 +5,7 @@ use std::{
         Arc,
     },
     time::Duration,
+    u16,
 };
 
 use anyhow::Context;
@@ -21,12 +22,20 @@ use zerocopy::FromBytes;
 
 use crate::{
     common::{
-        constants, error::Error, global_ctx::ArcGlobalCtx, join_joinset_background, netns::NetNS,
+        error::Error, global_ctx::ArcGlobalCtx, join_joinset_background, netns::NetNS,
         scoped_task::ScopedTask, stun::StunInfoCollectorTrait, PeerId,
     },
     defer,
     peers::peer_manager::PeerManager,
-    rpc::NatType,
+    proto::{
+        common::NatType,
+        peer_rpc::{
+            TryPunchHoleRequest, TryPunchHoleResponse, TryPunchSymmetricRequest,
+            TryPunchSymmetricResponse, UdpHolePunchRpc, UdpHolePunchRpcClientFactory,
+            UdpHolePunchRpcServer,
+        },
+        rpc_types::{self, controller::BaseController},
+    },
     tunnel::{
         common::setup_sokcet2,
         packet_def::{UDPTunnelHeader, UdpPacketType, UDP_TUNNEL_HEADER_SIZE},
@@ -186,21 +195,6 @@ impl std::fmt::Debug for UdpSocketArray {
     }
 }
 
-#[tarpc::service]
-pub trait UdpHolePunchService {
-    async fn try_punch_hole(local_mapped_addr: SocketAddr) -> Option<SocketAddr>;
-    async fn try_punch_symmetric(
-        listener_addr: SocketAddr,
-        port: u16,
-        public_ips: Vec<Ipv4Addr>,
-        min_port: u16,
-        max_port: u16,
-        transaction_id: u32,
-        round: u32,
-        last_port_index: usize,
-    ) -> Option<usize>;
-}
-
 #[derive(Debug)]
 struct UdpHolePunchListener {
     socket: Arc<UdpSocket>,
@@ -324,23 +318,34 @@ impl UdpHolePunchConnectorData {
 }
 
 #[derive(Clone)]
-struct UdpHolePunchRpcServer {
+struct UdpHolePunchRpcService {
     data: Arc<UdpHolePunchConnectorData>,
 
     tasks: Arc<std::sync::Mutex<JoinSet<()>>>,
 }
 
-#[tarpc::server]
-impl UdpHolePunchService for UdpHolePunchRpcServer {
+#[async_trait::async_trait]
+impl UdpHolePunchRpc for UdpHolePunchRpcService {
+    type Controller = BaseController;
+
     #[tracing::instrument(skip(self))]
     async fn try_punch_hole(
-        self,
-        _: tarpc::context::Context,
-        local_mapped_addr: SocketAddr,
-    ) -> Option<SocketAddr> {
+        &self,
+        _: BaseController,
+        request: TryPunchHoleRequest,
+    ) -> Result<TryPunchHoleResponse, rpc_types::error::Error> {
+        let local_mapped_addr = request.local_mapped_addr.ok_or(anyhow::anyhow!(
+            "try_punch_hole request missing local_mapped_addr"
+        ))?;
+        let local_mapped_addr = std::net::SocketAddr::from(local_mapped_addr);
         // local mapped addr will be unspecified if peer is symmetric
         let peer_is_symmetric = local_mapped_addr.ip().is_unspecified();
-        let (socket, mapped_addr) = self.select_listener(peer_is_symmetric).await?;
+        let (socket, mapped_addr) =
+            self.select_listener(peer_is_symmetric)
+                .await
+                .ok_or(anyhow::anyhow!(
+                    "failed to select listener for hole punching"
+                ))?;
         tracing::warn!(?local_mapped_addr, ?mapped_addr, "start hole punching");
 
         if !peer_is_symmetric {
@@ -380,32 +385,48 @@ impl UdpHolePunchService for UdpHolePunchRpcServer {
             }
         }
 
-        Some(mapped_addr)
+        Ok(TryPunchHoleResponse {
+            remote_mapped_addr: Some(mapped_addr.into()),
+        })
     }
 
     #[instrument(skip(self))]
     async fn try_punch_symmetric(
-        self,
-        _: tarpc::context::Context,
-        listener_addr: SocketAddr,
-        port: u16,
-        public_ips: Vec<Ipv4Addr>,
-        mut min_port: u16,
-        mut max_port: u16,
-        transaction_id: u32,
-        round: u32,
-        last_port_index: usize,
-    ) -> Option<usize> {
+        &self,
+        _: BaseController,
+        request: TryPunchSymmetricRequest,
+    ) -> Result<TryPunchSymmetricResponse, rpc_types::error::Error> {
+        let listener_addr = request.listener_addr.ok_or(anyhow::anyhow!(
+            "try_punch_symmetric request missing listener_addr"
+        ))?;
+        let listener_addr = std::net::SocketAddr::from(listener_addr);
+        let port = request.port as u16;
+        let public_ips = request
+            .public_ips
+            .into_iter()
+            .map(|ip| std::net::Ipv4Addr::from(ip))
+            .collect::<Vec<_>>();
+        let mut min_port = request.min_port as u16;
+        let mut max_port = request.max_port as u16;
+        let transaction_id = request.transaction_id;
+        let round = request.round;
+        let last_port_index = request.last_port_index as usize;
+
         tracing::info!("try_punch_symmetric start");
 
         let punch_predictablely = self.data.punch_predicablely.load(Ordering::Relaxed);
         let punch_randomly = self.data.punch_randomly.load(Ordering::Relaxed);
         let total_port_count = self.data.shuffled_port_vec.len();
-        let listener = self.find_listener(&listener_addr).await?;
+        let listener = self
+            .find_listener(&listener_addr)
+            .await
+            .ok_or(anyhow::anyhow!(
+                "try_punch_symmetric failed to find listener"
+            ))?;
         let ip_count = public_ips.len();
         if ip_count == 0 {
             tracing::warn!("try_punch_symmetric got zero len public ip");
-            return None;
+            return Err(anyhow::anyhow!("try_punch_symmetric got zero len public ip").into());
         }
 
         min_port = std::cmp::max(1, min_port);
@@ -447,7 +468,7 @@ impl UdpHolePunchService for UdpHolePunchRpcServer {
                 &ports,
             )
             .await
-            .ok()?;
+            .with_context(|| "failed to send symmetric hole punch packet predict")?;
         }
 
         if punch_randomly {
@@ -461,20 +482,22 @@ impl UdpHolePunchService for UdpHolePunchRpcServer {
                 &self.data.shuffled_port_vec[start..end],
             )
             .await
-            .ok()?;
+            .with_context(|| "failed to send symmetric hole punch packet randomly")?;
 
             return if end >= self.data.shuffled_port_vec.len() {
-                Some(1)
+                Ok(TryPunchSymmetricResponse { last_port_index: 1 })
             } else {
-                Some(end)
+                Ok(TryPunchSymmetricResponse {
+                    last_port_index: end as u32,
+                })
             };
         }
 
-        return Some(1);
+        return Ok(TryPunchSymmetricResponse { last_port_index: 1 });
     }
 }
 
-impl UdpHolePunchRpcServer {
+impl UdpHolePunchRpcService {
     pub fn new(data: Arc<UdpHolePunchConnectorData>) -> Self {
         let tasks = Arc::new(std::sync::Mutex::new(JoinSet::new()));
         join_joinset_background(tasks.clone(), "UdpHolePunchRpcServer".to_owned());
@@ -593,10 +616,15 @@ impl UdpHolePunchConnector {
     }
 
     pub async fn run_as_server(&mut self) -> Result<(), Error> {
-        self.data.peer_mgr.get_peer_rpc_mgr().run_service(
-            constants::UDP_HOLE_PUNCH_CONNECTOR_SERVICE_ID,
-            UdpHolePunchRpcServer::new(self.data.clone()).serve(),
-        );
+        self.data
+            .peer_mgr
+            .get_peer_rpc_mgr()
+            .rpc_server()
+            .registry()
+            .register(
+                UdpHolePunchRpcServer::new(UdpHolePunchRpcService::new(self.data.clone())),
+                &self.data.global_ctx.get_network_name(),
+            );
 
         Ok(())
     }
@@ -736,26 +764,26 @@ impl UdpHolePunchConnector {
             .with_context(|| "failed to get udp port mapping")?;
 
         // client -> server: tell server the mapped port, server will return the mapped address of listening port.
-        let Some(remote_mapped_addr) = data
+        let rpc_stub = data
             .peer_mgr
             .get_peer_rpc_mgr()
-            .do_client_rpc_scoped(
-                constants::UDP_HOLE_PUNCH_CONNECTOR_SERVICE_ID,
+            .rpc_client()
+            .scoped_client::<UdpHolePunchRpcClientFactory<BaseController>>(
+                data.peer_mgr.my_peer_id(),
                 dst_peer_id,
-                |c| async {
-                    let client =
-                        UdpHolePunchServiceClient::new(tarpc::client::Config::default(), c).spawn();
-                    let remote_mapped_addr = client
-                        .try_punch_hole(tarpc::context::current(), local_mapped_addr)
-                        .await;
-                    tracing::info!(?remote_mapped_addr, ?dst_peer_id, "got remote mapped addr");
-                    remote_mapped_addr
+                data.global_ctx.get_network_name(),
+            );
+
+        let remote_mapped_addr = rpc_stub
+            .try_punch_hole(
+                BaseController {},
+                TryPunchHoleRequest {
+                    local_mapped_addr: Some(local_mapped_addr.into()),
                 },
             )
             .await?
-        else {
-            return Err(anyhow::anyhow!("failed to get remote mapped addr"));
-        };
+            .remote_mapped_addr
+            .ok_or(anyhow::anyhow!("failed to get remote mapped addr"))?;
 
         // server: will send some punching resps, total 10 packets.
         // client: use the socket to create UdpTunnel with UdpTunnelConnector
@@ -769,9 +797,11 @@ impl UdpHolePunchConnector {
         setup_sokcet2(&socket2_socket, &local_socket_addr)?;
         let socket = Arc::new(UdpSocket::from_std(socket2_socket.into())?);
 
-        Ok(Self::try_connect_with_socket(socket, remote_mapped_addr)
-            .await
-            .with_context(|| "UdpTunnelConnector failed to connect remote")?)
+        Ok(
+            Self::try_connect_with_socket(socket, remote_mapped_addr.into())
+                .await
+                .with_context(|| "UdpTunnelConnector failed to connect remote")?,
+        )
     }
 
     #[tracing::instrument(err(level = Level::ERROR))]
@@ -783,30 +813,28 @@ impl UdpHolePunchConnector {
             return Err(anyhow::anyhow!("udp array not started"));
         };
 
-        let Some(remote_mapped_addr) = data
+        let rpc_stub = data
             .peer_mgr
             .get_peer_rpc_mgr()
-            .do_client_rpc_scoped(
-                constants::UDP_HOLE_PUNCH_CONNECTOR_SERVICE_ID,
+            .rpc_client()
+            .scoped_client::<UdpHolePunchRpcClientFactory<BaseController>>(
+                data.peer_mgr.my_peer_id(),
                 dst_peer_id,
-                |c| async {
-                    let client =
-                        UdpHolePunchServiceClient::new(tarpc::client::Config::default(), c).spawn();
-                    let remote_mapped_addr = client
-                        .try_punch_hole(tarpc::context::current(), "0.0.0.0:0".parse().unwrap())
-                        .await;
-                    tracing::debug!(
-                        ?remote_mapped_addr,
-                        ?dst_peer_id,
-                        "hole punching symmetric got remote mapped addr"
-                    );
-                    remote_mapped_addr
+                data.global_ctx.get_network_name(),
+            );
+
+        let local_mapped_addr: SocketAddr = "0.0.0.0:0".parse().unwrap();
+        let remote_mapped_addr = rpc_stub
+            .try_punch_hole(
+                BaseController {},
+                TryPunchHoleRequest {
+                    local_mapped_addr: Some(local_mapped_addr.into()),
                 },
             )
             .await?
-        else {
-            return Err(anyhow::anyhow!("failed to get remote mapped addr"));
-        };
+            .remote_mapped_addr
+            .ok_or(anyhow::anyhow!("failed to get remote mapped addr"))?
+            .into();
 
         // try direct connect first
         if data.try_direct_connect.load(Ordering::Relaxed) {
@@ -852,38 +880,26 @@ impl UdpHolePunchConnector {
         let mut last_port_idx = rand::thread_rng().gen_range(0..data.shuffled_port_vec.len());
 
         for round in 0..5 {
-            let ret = data
-                .peer_mgr
-                .get_peer_rpc_mgr()
-                .do_client_rpc_scoped(
-                    constants::UDP_HOLE_PUNCH_CONNECTOR_SERVICE_ID,
-                    dst_peer_id,
-                    |c| async {
-                        let client =
-                            UdpHolePunchServiceClient::new(tarpc::client::Config::default(), c)
-                                .spawn();
-                        let last_port_idx = client
-                            .try_punch_symmetric(
-                                tarpc::context::current(),
-                                remote_mapped_addr,
-                                port,
-                                public_ips.clone(),
-                                stun_info.min_port as u16,
-                                stun_info.max_port as u16,
-                                tid,
-                                round,
-                                last_port_idx,
-                            )
-                            .await;
-                        tracing::info!(?last_port_idx, ?dst_peer_id, "punch symmetric return");
-                        last_port_idx
+            let ret = rpc_stub
+                .try_punch_symmetric(
+                    BaseController {},
+                    TryPunchSymmetricRequest {
+                        listener_addr: Some(remote_mapped_addr.into()),
+                        port: port as u32,
+                        public_ips: public_ips.clone().into_iter().map(|x| x.into()).collect(),
+                        min_port: stun_info.min_port as u32,
+                        max_port: stun_info.max_port as u32,
+                        transaction_id: tid,
+                        round,
+                        last_port_index: last_port_idx as u32,
                     },
                 )
                 .await;
+            tracing::info!(?ret, "punch symmetric return");
 
             let next_last_port_idx = match ret {
-                Ok(Some(idx)) => idx,
-                err => {
+                Ok(s) => s.last_port_index as usize,
+                Err(err) => {
                     tracing::error!(?err, "failed to get remote mapped addr");
                     rand::thread_rng().gen_range(0..data.shuffled_port_vec.len())
                 }
@@ -1027,11 +1043,11 @@ pub mod tests {
 
     use tokio::net::UdpSocket;
 
-    use crate::rpc::{NatType, StunInfo};
+    use crate::common::stun::MockStunInfoCollector;
+    use crate::proto::common::NatType;
     use crate::tunnel::common::tests::wait_for_condition;
 
     use crate::{
-        common::{error::Error, stun::StunInfoCollectorTrait},
         connector::udp_hole_punch::UdpHolePunchConnector,
         peers::{
             peer_manager::PeerManager,
@@ -1042,31 +1058,6 @@ pub mod tests {
         },
     };
 
-    struct MockStunInfoCollector {
-        udp_nat_type: NatType,
-    }
-
-    #[async_trait::async_trait]
-    impl StunInfoCollectorTrait for MockStunInfoCollector {
-        fn get_stun_info(&self) -> StunInfo {
-            StunInfo {
-                udp_nat_type: self.udp_nat_type as i32,
-                tcp_nat_type: NatType::Unknown as i32,
-                last_update_time: std::time::Instant::now().elapsed().as_secs() as i64,
-                min_port: 100,
-                max_port: 200,
-                ..Default::default()
-            }
-        }
-
-        async fn get_udp_port_mapping(&self, mut port: u16) -> Result<std::net::SocketAddr, Error> {
-            if port == 0 {
-                port = 40144;
-            }
-            Ok(format!("127.0.0.1:{}", port).parse().unwrap())
-        }
-    }
-
     pub fn replace_stun_info_collector(peer_mgr: Arc<PeerManager>, udp_nat_type: NatType) {
         let collector = Box::new(MockStunInfoCollector { udp_nat_type });
         peer_mgr