clippy all codes (#1214)

1. clippy code 2. add fmt and clippy check in ci
2026-05-07 18:24:36 +00:00 · 2025-08-10 22:56:41 +08:00
parent 0087ac3ffc
commit e43537939a
144 changed files with 1475 additions and 1531 deletions
@@ -170,7 +170,7 @@ impl RoutePeerInfo {
        };

        let need_update_periodically = if let Ok(Ok(d)) =
-            SystemTime::try_from(new.last_update.unwrap()).map(|x| x.elapsed())
+            SystemTime::try_from(new.last_update.unwrap_or_default()).map(|x| x.elapsed())
        {
            d > UPDATE_PEER_INFO_PERIOD
        } else {
@@ -186,45 +186,41 @@ impl RoutePeerInfo {
    }
 }

-impl Into<crate::proto::cli::Route> for RoutePeerInfo {
-    fn into(self) -> crate::proto::cli::Route {
-        let network_length = if self.network_length == 0 {
+impl From<RoutePeerInfo> for crate::proto::cli::Route {
+    fn from(val: RoutePeerInfo) -> Self {
+        let network_length = if val.network_length == 0 {
            24
        } else {
-            self.network_length
+            val.network_length
        };

        crate::proto::cli::Route {
-            peer_id: self.peer_id,
-            ipv4_addr: if let Some(ipv4_addr) = self.ipv4_addr {
-                Some(Ipv4Inet {
-                    address: Some(ipv4_addr.into()),
-                    network_length,
-                })
-            } else {
-                None
-            },
+            peer_id: val.peer_id,
+            ipv4_addr: val.ipv4_addr.map(|ipv4_addr| Ipv4Inet {
+                address: Some(ipv4_addr),
+                network_length,
+            }),
            next_hop_peer_id: 0, // next_hop_peer_id is calculated in RouteTable.
            cost: 0,             // cost is calculated in RouteTable.
            path_latency: 0,     // path_latency is calculated in RouteTable.
-            proxy_cidrs: self.proxy_cidrs.clone(),
-            hostname: self.hostname.unwrap_or_default(),
+            proxy_cidrs: val.proxy_cidrs.clone(),
+            hostname: val.hostname.unwrap_or_default(),
            stun_info: {
                let mut stun_info = StunInfo::default();
-                if let Ok(udp_nat_type) = NatType::try_from(self.udp_stun_info as i32) {
+                if let Ok(udp_nat_type) = NatType::try_from(val.udp_stun_info) {
                    stun_info.set_udp_nat_type(udp_nat_type);
                }
                Some(stun_info)
            },
-            inst_id: self.inst_id.map(|x| x.to_string()).unwrap_or_default(),
-            version: self.easytier_version,
-            feature_flag: self.feature_flag,
+            inst_id: val.inst_id.map(|x| x.to_string()).unwrap_or_default(),
+            version: val.easytier_version,
+            feature_flag: val.feature_flag,

            next_hop_peer_id_latency_first: None,
            cost_latency_first: None,
            path_latency_latency_first: None,

-            ipv6_addr: self.ipv6_addr.map(Into::into),
+            ipv6_addr: val.ipv6_addr,
        }
    }
 }
@@ -235,10 +231,10 @@ struct RouteConnBitmap {
    bitmap: Vec<u8>,
 }

-impl Into<crate::proto::peer_rpc::RouteConnBitmap> for RouteConnBitmap {
-    fn into(self) -> crate::proto::peer_rpc::RouteConnBitmap {
+impl From<RouteConnBitmap> for crate::proto::peer_rpc::RouteConnBitmap {
+    fn from(val: RouteConnBitmap) -> Self {
        crate::proto::peer_rpc::RouteConnBitmap {
-            peer_ids: self
+            peer_ids: val
                .peer_ids
                .into_iter()
                .map(|x| PeerIdVersion {
@@ -246,7 +242,7 @@ impl Into<crate::proto::peer_rpc::RouteConnBitmap> for RouteConnBitmap {
                    version: x.1,
                })
                .collect(),
-            bitmap: self.bitmap,
+            bitmap: val.bitmap,
        }
    }
 }
@@ -318,7 +314,7 @@ impl SyncedRouteInfo {
    fn get_connected_peers<T: FromIterator<PeerId>>(&self, peer_id: PeerId) -> Option<T> {
        self.conn_map
            .get(&peer_id)
-            .map(|x| x.0.clone().iter().map(|x| *x).collect())
+            .map(|x| x.0.clone().iter().copied().collect())
    }

    fn remove_peer(&self, peer_id: PeerId) {
@@ -403,8 +399,8 @@ impl SyncedRouteInfo {
        my_peer_id: PeerId,
        my_peer_route_id: u64,
        dst_peer_id: PeerId,
-        peer_infos: &Vec<RoutePeerInfo>,
-        raw_peer_infos: &Vec<DynamicMessage>,
+        peer_infos: &[RoutePeerInfo],
+        raw_peer_infos: &[DynamicMessage],
    ) -> Result<(), Error> {
        let mut need_inc_version = false;
        for (idx, route_info) in peer_infos.iter().enumerate() {
@@ -476,7 +472,7 @@ impl SyncedRouteInfo {
                })
                .or_insert_with(|| {
                    need_inc_version = true;
-                    (connceted_peers, version.clone().into())
+                    (connceted_peers, (*version).into())
                });
        }
        if need_inc_version {
@@ -512,11 +508,8 @@ impl SyncedRouteInfo {
        my_peer_route_id: u64,
        global_ctx: &ArcGlobalCtx,
    ) -> bool {
-        let mut old = self
-            .peer_infos
-            .entry(my_peer_id)
-            .or_insert(RoutePeerInfo::new());
-        let new = old.update_self(my_peer_id, my_peer_route_id, &global_ctx);
+        let mut old = self.peer_infos.entry(my_peer_id).or_default();
+        let new = old.update_self(my_peer_id, my_peer_route_id, global_ctx);
        let new_version = new.version;
        let old_version = old.version;
        *old = new;
@@ -616,8 +609,8 @@ impl SyncedRouteInfo {
    }

    fn is_peer_directly_connected(&self, src_peer_id: PeerId, dst_peer_id: PeerId) -> bool {
-        return self.is_peer_bidirectly_connected(src_peer_id, dst_peer_id)
-            || self.is_peer_bidirectly_connected(dst_peer_id, src_peer_id);
+        self.is_peer_bidirectly_connected(src_peer_id, dst_peer_id)
+            || self.is_peer_bidirectly_connected(dst_peer_id, src_peer_id)
    }
 }

@@ -674,7 +667,7 @@ impl RouteTable {
    fn get_nat_type(&self, peer_id: PeerId) -> Option<NatType> {
        self.peer_infos
            .get(&peer_id)
-            .map(|x| NatType::try_from(x.udp_stun_info as i32).unwrap_or_default())
+            .map(|x| NatType::try_from(x.udp_stun_info).unwrap_or_default())
    }

    // return graph and start node index (node of my peer id).
@@ -710,9 +703,9 @@ impl RouteTable {
        for item in peer_id_to_node_index.iter() {
            let src_peer_id = item.key();
            let src_node_idx = item.value();
-            let connected_peers = synced_info
+            let connected_peers: BTreeSet<_> = synced_info
                .get_connected_peers(*src_peer_id)
-                .unwrap_or(BTreeSet::new());
+                .unwrap_or_default();

            // if avoid relay, just set all outgoing edges to a large value: AVOID_RELAY_COST.
            let peer_avoid_relay_data = synced_info.get_avoid_relay_data(*src_peer_id);
@@ -798,7 +791,7 @@ impl RouteTable {
        }

        // Step 3: 第二次 Dijkstra - 在子图上找代价最小的路径
-        self.gen_next_hop_map_with_least_cost(&subgraph, &start_node_idx.clone().unwrap(), version);
+        self.gen_next_hop_map_with_least_cost(&subgraph, &start_node_idx.unwrap(), version);
    }

    fn gen_next_hop_map_with_least_cost(
@@ -813,7 +806,7 @@ impl RouteTable {
            let info = NextHopInfo {
                next_hop_peer_id: *graph.node_weight(*next_hop).unwrap(),
                path_latency: (*costs.get(dst).unwrap() % AVOID_RELAY_COST) as i32,
-                path_len: *path_len as usize,
+                path_len: { *path_len },
                version,
            };
            let dst_peer_id = *graph.node_weight(*dst).unwrap();
@@ -841,7 +834,7 @@ impl RouteTable {

        // build next hop map
        let (graph, start_node) =
-            Self::build_peer_graph_from_synced_info(my_peer_id, &synced_info, cost_calc);
+            Self::build_peer_graph_from_synced_info(my_peer_id, synced_info, cost_calc);

        if graph.node_count() == 0 {
            tracing::warn!("no peer in graph, cannot build next hop map");
@@ -1031,11 +1024,11 @@ impl SyncRouteSession {
            .unwrap_or(false)
    }

-    fn update_dst_saved_peer_info_version(&self, infos: &Vec<RoutePeerInfo>) {
+    fn update_dst_saved_peer_info_version(&self, infos: &[RoutePeerInfo]) {
        for info in infos.iter() {
            self.dst_saved_peer_info_versions
                .entry(info.peer_id)
-                .or_insert_with(|| AtomicVersion::new())
+                .or_insert_with(AtomicVersion::new)
                .set_if_larger(info.version);
        }
    }
@@ -1044,7 +1037,7 @@ impl SyncRouteSession {
        for (peer_id, version) in conn_bitmap.peer_ids.iter() {
            self.dst_saved_conn_bitmap_version
                .entry(*peer_id)
-                .or_insert_with(|| AtomicVersion::new())
+                .or_insert_with(AtomicVersion::new)
                .set_if_larger(*version);
        }
    }
@@ -1053,7 +1046,7 @@ impl SyncRouteSession {
        for item in foreign_network.infos.iter() {
            self.dst_saved_foreign_network_versions
                .entry(item.key.clone().unwrap())
-                .or_insert_with(|| AtomicVersion::new())
+                .or_insert_with(AtomicVersion::new)
                .set_if_larger(item.value.as_ref().unwrap().version);
        }
    }
@@ -1249,13 +1242,10 @@ impl PeerRouteServiceImpl {
            .list_foreign_networks()
            .await;

-        let updated = self
-            .synced_route_info
-            .update_my_foreign_network(self.my_peer_id, foreign_networks);
-
        // do not need update owner map because we always filter out my peer id.

-        updated
+        self.synced_route_info
+            .update_my_foreign_network(self.my_peer_id, foreign_networks)
    }

    fn update_route_table(&self) {
@@ -1317,7 +1307,7 @@ impl PeerRouteServiceImpl {
            };
            self.foreign_network_owner_map
                .entry(network_identity)
-                .or_insert_with(|| Vec::new())
+                .or_default()
                .push(entry.my_peer_id_for_this_network);

            self.foreign_network_my_peer_id_map.insert(
@@ -1350,8 +1340,7 @@ impl PeerRouteServiceImpl {
            .synced_route_info
            .conn_map
            .iter()
-            .map(|x| x.value().clone().0.into_iter())
-            .flatten()
+            .flat_map(|x| x.value().clone().0.into_iter())
            .collect::<BTreeSet<_>>();

        let all_peer_ids = self
@@ -1364,7 +1353,7 @@ impl PeerRouteServiceImpl {
            .collect::<Vec<_>>();

        let mut conn_bitmap = RouteConnBitmap::new();
-        conn_bitmap.bitmap = vec![0; (all_peer_ids.len() * all_peer_ids.len() + 7) / 8];
+        conn_bitmap.bitmap = vec![0; (all_peer_ids.len() * all_peer_ids.len()).div_ceil(8)];
        conn_bitmap.peer_ids = all_peer_ids;

        let all_peer_ids = &conn_bitmap.peer_ids;
@@ -1419,7 +1408,7 @@ impl PeerRouteServiceImpl {
        for (peer_id, local_version) in self.cached_local_conn_map.lock().unwrap().peer_ids.iter() {
            let peer_version = session
                .dst_saved_conn_bitmap_version
-                .get(&peer_id)
+                .get(peer_id)
                .map(|item| item.get());
            if peer_version.is_none() || peer_version.unwrap() < *local_version {
                need_update = true;
@@ -1442,7 +1431,7 @@ impl PeerRouteServiceImpl {
        for item in self.synced_route_info.foreign_network.iter() {
            if session
                .dst_saved_foreign_network_versions
-                .get(&item.key())
+                .get(item.key())
                .map(|x| x.get() >= item.value().version)
                .unwrap_or(false)
            {
@@ -1485,9 +1474,9 @@ impl PeerRouteServiceImpl {
        Option<RouteConnBitmap>,
        Option<RouteForeignNetworkInfos>,
    ) {
-        let route_infos = self.build_route_info(&session);
-        let conn_bitmap = self.build_conn_bitmap(&session);
-        let foreign_network = self.build_foreign_network_info(&session);
+        let route_infos = self.build_route_info(session);
+        let conn_bitmap = self.build_conn_bitmap(session);
+        let foreign_network = self.build_foreign_network_info(session);

        (route_infos, conn_bitmap, foreign_network)
    }
@@ -1661,19 +1650,19 @@ impl PeerRouteServiceImpl {
                session.update_dst_session_id(resp.session_id);

                if let Some(peer_infos) = &peer_infos {
-                    session.update_dst_saved_peer_info_version(&peer_infos);
+                    session.update_dst_saved_peer_info_version(peer_infos);
                }

                if let Some(conn_bitmap) = &conn_bitmap {
-                    session.update_dst_saved_conn_bitmap_version(&conn_bitmap);
+                    session.update_dst_saved_conn_bitmap_version(conn_bitmap);
                }

                if let Some(foreign_network) = &foreign_network {
-                    session.update_dst_saved_foreign_network_version(&foreign_network);
+                    session.update_dst_saved_foreign_network_version(foreign_network);
                }
            }
        }
-        return false;
+        false
    }

    fn update_peer_info_last_update(&self) {
@@ -1767,11 +1756,10 @@ impl OspfRouteRpc for RouteSessionManager {

        Ok(match ret {
            Ok(v) => v,
-            Err(e) => {
-                let mut resp = SyncRouteInfoResponse::default();
-                resp.error = Some(e as i32);
-                resp
-            }
+            Err(e) => SyncRouteInfoResponse {
+                error: Some(e as i32),
+                ..Default::default()
+            },
        })
    }
 }
@@ -1828,12 +1816,9 @@ impl RouteSessionManager {

            select! {
                _ = tokio::time::sleep(Duration::from_secs(1)) => {}
-                ret = sync_now.recv() => match ret {
-                    Err(e) => {
-                        tracing::debug!(?e, "session_task sync_now recv failed, ospf route may exit");
-                        break;
-                    },
-                    _ => {}
+                ret = sync_now.recv() => if let Err(e) = ret {
+                    tracing::debug!(?e, "session_task sync_now recv failed, ospf route may exit");
+                    break;
                }
            }
        }
@@ -1903,7 +1888,7 @@ impl RouteSessionManager {
                    };
                    !session.dst_is_initiator.load(Ordering::Relaxed)
                })
-                .map(|x| *x)
+                .copied()
                .collect::<Vec<_>>();

            if initiator_candidates.is_empty() {
@@ -1998,6 +1983,7 @@ impl RouteSessionManager {
        tracing::debug!(?ret, ?reason, "sync_now_broadcast.send");
    }

+    #[allow(clippy::too_many_arguments)]
    async fn do_sync_route_info(
        &self,
        from_peer_id: PeerId,
@@ -2034,7 +2020,7 @@ impl RouteSessionManager {
        }

        if let Some(conn_bitmap) = &conn_bitmap {
-            service_impl.synced_route_info.update_conn_map(&conn_bitmap);
+            service_impl.synced_route_info.update_conn_map(conn_bitmap);
            session.update_dst_saved_conn_bitmap_version(conn_bitmap);
            need_update_route_table = true;
        }
@@ -2046,7 +2032,7 @@ impl RouteSessionManager {
        if let Some(foreign_network) = &foreign_network {
            service_impl
                .synced_route_info
-                .update_foreign_network(&foreign_network);
+                .update_foreign_network(foreign_network);
            session.update_dst_saved_foreign_network_version(foreign_network);
        }

@@ -2267,7 +2253,7 @@ impl Route for PeerRoute {
            route.cost_latency_first = next_hop_peer_latency_first.map(|x| x.path_len as i32);
            route.path_latency_latency_first = next_hop_peer_latency_first.map(|x| x.path_latency);

-            route.feature_flag = item.feature_flag.clone();
+            route.feature_flag = item.feature_flag;

            routes.push(route);
        }
@@ -2455,7 +2441,7 @@ mod tests {
        let r_a = create_mock_route(p_a.clone()).await;
        let r_b = create_mock_route(p_b.clone()).await;

-        for r in vec![r_a.clone(), r_b.clone()].iter() {
+        for r in [r_a.clone(), r_b.clone()].iter() {
            wait_for_condition(
                || async {
                    println!("route: {:?}", r.list_routes().await);
@@ -2507,7 +2493,7 @@ mod tests {
        drop(p_b);

        wait_for_condition(
-            || async { r_a.list_routes().await.len() == 0 },
+            || async { r_a.list_routes().await.is_empty() },
            Duration::from_secs(5),
        )
        .await;
@@ -2531,7 +2517,7 @@ mod tests {
        let r_b = create_mock_route(p_b.clone()).await;
        let r_c = create_mock_route(p_c.clone()).await;

-        for r in vec![r_a.clone(), r_b.clone(), r_c.clone()].iter() {
+        for r in [r_a.clone(), r_b.clone(), r_c.clone()].iter() {
            wait_for_condition(
                || async { r.service_impl.synced_route_info.peer_infos.len() == 3 },
                Duration::from_secs(5),
@@ -2563,10 +2549,10 @@ mod tests {
        connect_peer_manager(p_d.clone(), p_c.clone()).await;

        // find the smallest peer_id, which should be a center node
-        let mut all_route = vec![r_a.clone(), r_b.clone(), r_c.clone(), r_d.clone()];
+        let mut all_route = [r_a.clone(), r_b.clone(), r_c.clone(), r_d.clone()];
        all_route.sort_by(|a, b| a.my_peer_id.cmp(&b.my_peer_id));
-        let mut all_peer_mgr = vec![p_a.clone(), p_b.clone(), p_c.clone(), p_d.clone()];
-        all_peer_mgr.sort_by(|a, b| a.my_peer_id().cmp(&b.my_peer_id()));
+        let mut all_peer_mgr = [p_a.clone(), p_b.clone(), p_c.clone(), p_d.clone()];
+        all_peer_mgr.sort_by_key(|a| a.my_peer_id());

        wait_for_condition(
            || async { all_route[0].service_impl.sessions.len() == 3 },
@@ -2664,7 +2650,7 @@ mod tests {
        let r_b = create_mock_route(p_b.clone()).await;
        let r_c = create_mock_route(p_c.clone()).await;

-        for r in vec![r_a.clone(), r_b.clone(), r_c.clone()].iter() {
+        for r in [r_a.clone(), r_b.clone(), r_c.clone()].iter() {
            wait_for_condition(
                || async { r.service_impl.synced_route_info.peer_infos.len() == 3 },
                Duration::from_secs(5),
@@ -2684,7 +2670,7 @@ mod tests {
        drop(r_c);
        drop(p_c);

-        for r in vec![r_a.clone(), r_b.clone()].iter() {
+        for r in [r_a.clone(), r_b.clone()].iter() {
            wait_for_condition(
                || async { r.list_routes().await.len() == 1 },
                Duration::from_secs(5),
@@ -2717,7 +2703,7 @@ mod tests {
            .await
            .unwrap();
        wait_for_condition(
-            || async { r_a.list_routes().await.len() == 0 },
+            || async { r_a.list_routes().await.is_empty() },
            Duration::from_secs(5),
        )
        .await;
@@ -2756,7 +2742,7 @@ mod tests {

        // in normal mode, packet from p_c should directly forward to p_a
        wait_for_condition(
-            || async { r_d.get_next_hop(p_a.my_peer_id()).await != None },
+            || async { (r_d.get_next_hop(p_a.my_peer_id()).await).is_some() },
            Duration::from_secs(5),
        )
        .await;