perf: simplify method signatures and reduce clone across multiple files (#1663)

easytier/src/peers/peer.rs

@@ -109,7 +109,7 @@ impl Peer {
 
         Peer {
             peer_node_id,
-            conns: conns.clone(),
+            conns,
             packet_recv_chan,
             global_ctx,
 

easytier/src/peers/peer_conn.rs

@@ -192,7 +192,7 @@ impl PeerConn {
         self.is_hole_punched
     }
 
-    async fn wait_handshake(&mut self, need_retry: &mut bool) -> Result<HandshakeRequest, Error> {
+    async fn wait_handshake(&self, need_retry: &mut bool) -> Result<HandshakeRequest, Error> {
         *need_retry = false;
 
         let mut locked = self.recv.lock().await;
@@ -241,7 +241,7 @@ impl PeerConn {
         Ok(rsp)
     }
 
-    async fn wait_handshake_loop(&mut self) -> Result<HandshakeRequest, Error> {
+    async fn wait_handshake_loop(&self) -> Result<HandshakeRequest, Error> {
         timeout(Duration::from_secs(5), async move {
             loop {
                 let mut need_retry = true;
@@ -260,7 +260,7 @@ impl PeerConn {
         .await?
     }
 
-    async fn send_handshake(&mut self, send_secret_digest: bool) -> Result<(), Error> {
+    async fn send_handshake(&self, send_secret_digest: bool) -> Result<(), Error> {
         let network = self.global_ctx.get_network_identity();
         let mut req = HandshakeRequest {
             magic: MAGIC,
@@ -384,8 +384,7 @@ impl PeerConn {
             traffic_rx_bytes: stats_mgr.get_counter(MetricName::TrafficBytesRx, label_set.clone()),
             traffic_tx_packets: stats_mgr
                 .get_counter(MetricName::TrafficPacketsTx, label_set.clone()),
-            traffic_rx_packets: stats_mgr
-                .get_counter(MetricName::TrafficPacketsRx, label_set.clone()),
+            traffic_rx_packets: stats_mgr.get_counter(MetricName::TrafficPacketsRx, label_set),
         };
         self.counters.store(Some(Arc::new(counters)));
 

easytier/src/peers/peer_conn_ping.rs

@@ -161,7 +161,7 @@ impl PeerConnPinger {
     async fn do_pingpong_once(
         my_node_id: PeerId,
         peer_id: PeerId,
-        sink: &mut MpscTunnelSender,
+        sink: &MpscTunnelSender,
         receiver: &mut broadcast::Receiver<ZCPacket>,
         seq: u32,
     ) -> Result<u128, Error> {
@@ -258,7 +258,7 @@ impl PeerConnPinger {
                         controller,
                     );
 
-                    let mut sink = sink.clone();
+                    let sink = sink.clone();
                     let receiver = ctrl_resp_sender.subscribe();
                     let ping_res_sender = ping_res_sender.clone();
                     pingpong_tasks.spawn(async move {
@@ -266,7 +266,7 @@ impl PeerConnPinger {
                         let pingpong_once_ret = Self::do_pingpong_once(
                             my_node_id,
                             peer_id,
-                            &mut sink,
+                            &sink,
                             &mut receiver,
                             req_seq,
                         )

easytier/src/peers/peer_manager.rs

@@ -242,7 +242,7 @@ impl PeerManager {
         ));
         let foreign_network_client = Arc::new(ForeignNetworkClient::new(
             global_ctx.clone(),
-            packet_send.clone(),
+            packet_send,
             peer_rpc_mgr.clone(),
             my_peer_id,
         ));
@@ -289,7 +289,7 @@ impl PeerManager {
 
             packet_recv: Arc::new(Mutex::new(Some(packet_recv))),
 
-            peers: peers.clone(),
+            peers,
 
             peer_rpc_mgr,
             peer_rpc_tspt: rpc_tspt,

easytier/src/peers/peer_ospf_route.rs

@@ -2717,7 +2717,7 @@ impl PeerRoute {
 
         Arc::new(PeerRoute {
             my_peer_id,
-            global_ctx: global_ctx.clone(),
+            global_ctx,
             peer_rpc: Arc::downgrade(&peer_rpc),
 
             service_impl,

easytier/src/peers/tests.rs

@@ -39,11 +39,11 @@ pub async fn create_mock_peer_manager_with_name(network_name: String) -> Arc<Pee
 
 pub async fn connect_peer_manager(client: Arc<PeerManager>, server: Arc<PeerManager>) {
     let (a_ring, b_ring) = create_ring_tunnel_pair();
-    let a_mgr_copy = client.clone();
+    let a_mgr_copy = client;
     tokio::spawn(async move {
         a_mgr_copy.add_client_tunnel(a_ring, false).await.unwrap();
     });
-    let b_mgr_copy = server.clone();
+    let b_mgr_copy = server;
     tokio::spawn(async move {
         b_mgr_copy.add_tunnel_as_server(b_ring, true).await.unwrap();
     });