chore: remove unnecessary rwlock

Author: driftluo

network/src/protocols/hole_punching/component/connection_request.rs

@@ -84,7 +84,7 @@ impl TryFrom<&packed::ConnectionRequestReader<'_>> for RequestContent {
 
 pub(crate) struct ConnectionRequestProcess<'a> {
     message: packed::ConnectionRequestReader<'a>,
-    protocol: &'a HolePunching,
+    protocol: &'a mut HolePunching,
     peer: PeerIndex,
     p2p_control: &'a ServiceAsyncControl,
     msg_item_id: u32,
@@ -93,7 +93,7 @@ pub(crate) struct ConnectionRequestProcess<'a> {
 impl<'a> ConnectionRequestProcess<'a> {
     pub(crate) fn new(
         message: packed::ConnectionRequestReader<'a>,
-        protocol: &'a HolePunching,
+        protocol: &'a mut HolePunching,
         peer: PeerIndex,
         p2p_control: &'a ServiceAsyncControl,
         msg_item_id: u32,
@@ -107,7 +107,7 @@ impl<'a> ConnectionRequestProcess<'a> {
         }
     }
 
-    pub(crate) async fn execute(self) -> Status {
+    pub(crate) async fn execute(mut self) -> Status {
         let content = match RequestContent::try_from(&self.message) {
             Ok(content) => content,
             Err(status) => return status,
@@ -153,12 +153,12 @@ impl<'a> ConnectionRequestProcess<'a> {
     }
 
     async fn respond_delivered(
-        &self,
+        &mut self,
         from_peer_id: PeerId,
         to_peer_id: &PeerId,
         remote_listens: Vec<Multiaddr>,
     ) -> Status {
-        if let Some((_, t)) = self.protocol.pending_delivered.read().get(&from_peer_id) {
+        if let Some((_, t)) = self.protocol.pending_delivered.get(&from_peer_id) {
             let now = unix_time_as_millis();
             if now - t < HOLE_PUNCHING_INTERVAL {
                 return StatusCode::Ignore
@@ -231,9 +231,10 @@ impl<'a> ConnectionRequestProcess<'a> {
             return StatusCode::ForwardError.with_context(error);
         }
 
-        let mut pending_delivered = self.protocol.pending_delivered.write();
         let now = unix_time_as_millis();
-        pending_delivered.insert(from_peer_id, (remote_listens, now));
+        self.protocol
+            .pending_delivered
+            .insert(from_peer_id, (remote_listens, now));
 
         Status::ok()
     }

network/src/protocols/hole_punching/component/connection_request_delivered.rs

@@ -91,7 +91,7 @@ impl TryFrom<&packed::ConnectionRequestDeliveredReader<'_>> for DeliverdContent
 
 pub struct ConnectionRequestDeliveredProcess<'a> {
     message: packed::ConnectionRequestDeliveredReader<'a>,
-    protocol: &'a HolePunching,
+    protocol: &'a mut HolePunching,
     p2p_control: &'a ServiceAsyncControl,
     peer: PeerIndex,
     bind_addr: Option<SocketAddr>,
@@ -101,7 +101,7 @@ pub struct ConnectionRequestDeliveredProcess<'a> {
 impl<'a> ConnectionRequestDeliveredProcess<'a> {
     pub(crate) fn new(
         message: packed::ConnectionRequestDeliveredReader<'a>,
-        protocol: &'a HolePunching,
+        protocol: &'a mut HolePunching,
         p2p_control: &'a ServiceAsyncControl,
         peer: PeerIndex,
         bind_addr: Option<SocketAddr>,
@@ -153,7 +153,7 @@ impl<'a> ConnectionRequestDeliveredProcess<'a> {
                     self.forward_delivered(&content.from).await
                 } else {
                     // the current peer is the target peer, respond the sync back
-                    let request_start = self.protocol.inflight_requests.write().remove(&content.to);
+                    let request_start = self.protocol.inflight_requests.remove(&content.to);
 
                     match request_start {
                         Some(start) => {

network/src/protocols/hole_punching/component/connection_sync.rs

@@ -107,7 +107,6 @@ impl<'a> ConnectionSyncProcess<'a> {
                     let listens_info = self
                         .protocol
                         .pending_delivered
-                        .read()
                         .get(&content.from)
                         .map(|info| info.0.clone());
 

network/src/protocols/hole_punching/mod.rs

@@ -3,7 +3,6 @@ use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 use ckb_logger::{debug, error, trace, warn};
 use ckb_systemtime::unix_time_as_millis;
 use ckb_types::{packed, prelude::*};
-use ckb_util::RwLock;
 use p2p::{
     async_trait, bytes,
     context::{ProtocolContext, ProtocolContextMutRef},
@@ -40,9 +39,9 @@ pub(crate) struct HolePunching {
     network_state: Arc<NetworkState>,
     bind_addr: Option<SocketAddr>,
     // Request timestamp recorded
-    inflight_requests: RwLock<HashMap<PeerId, u64>>,
+    inflight_requests: HashMap<PeerId, u64>,
     // Delivered timestamp recorded
-    pending_delivered: RwLock<HashMap<PeerId, PendingDeliveredInfo>>,
+    pending_delivered: HashMap<PeerId, PendingDeliveredInfo>,
     rate_limiter: RateLimiter<(PeerIndex, u32)>,
     forward_rate_limiter: RateLimiter<(PeerId, PeerId, u32)>,
 }
@@ -170,14 +169,10 @@ impl ServiceProtocol for HolePunching {
     async fn notify(&mut self, context: &mut ProtocolContext, _token: u64) {
         let status = self.network_state.connection_status();
 
-        {
-            let mut pending_delivered = self.pending_delivered.write();
-            let mut inflight_requests = self.inflight_requests.write();
-
-            let now = unix_time_as_millis();
-            pending_delivered.retain(|_, (_, t)| (now - *t) < TIMEOUT);
-            inflight_requests.retain(|_, t| (now - *t) < TIMEOUT);
-        }
+        let now = unix_time_as_millis();
+        self.pending_delivered
+            .retain(|_, (_, t)| (now - *t) < TIMEOUT);
+        self.inflight_requests.retain(|_, t| (now - *t) < TIMEOUT);
 
         if status.non_whitelist_outbound < status.max_outbound && status.total > 0 {
             let target = &self.network_state.required_flags;
@@ -241,10 +236,9 @@ impl ServiceProtocol for HolePunching {
                 }
             }
 
-            let mut inflight_requests = self.inflight_requests.write();
             let now = unix_time_as_millis();
             for peer_id in inflight {
-                inflight_requests.insert(peer_id, now);
+                self.inflight_requests.insert(peer_id, now);
             }
         }
     }
@@ -280,12 +274,11 @@ impl HolePunching {
                         }
                     }
                 }
-
                 bind_addr
             },
             network_state,
-            pending_delivered: RwLock::new(HashMap::new()),
-            inflight_requests: RwLock::new(HashMap::new()),
+            pending_delivered: HashMap::new(),
+            inflight_requests: HashMap::new(),
             rate_limiter,
             forward_rate_limiter,
         }