fix latency first route of public server (#1129)

easytier/src/peers/foreign_network_manager.rs

@@ -29,6 +29,7 @@ use crate::{
         token_bucket::TokenBucket,
         PeerId,
     },
+    peer_center::instance::{PeerCenterInstance, PeerMapWithPeerRpcManager},
     peers::route_trait::{Route, RouteInterface},
     proto::{
         cli::{ForeignNetworkEntryPb, ListForeignNetworkResponse, PeerInfo},
@@ -73,6 +74,8 @@ struct ForeignNetworkEntry {
 
     bps_limiter: Arc<TokenBucket>,
 
+    peer_center: Arc<PeerCenterInstance>,
+
     tasks: Mutex<JoinSet<()>>,
 
     pub lock: Mutex<()>,
@@ -116,6 +119,13 @@ impl ForeignNetworkEntry {
             .token_bucket_manager()
             .get_or_create(&network.network_name, limiter_config.into());
 
+        let peer_center = Arc::new(PeerCenterInstance::new(Arc::new(
+            PeerMapWithPeerRpcManager {
+                peer_map: peer_map.clone(),
+                rpc_mgr: peer_rpc.clone(),
+            },
+        )));
+
         Self {
             my_peer_id,
 
@@ -134,6 +144,8 @@ impl ForeignNetworkEntry {
 
             tasks: Mutex::new(JoinSet::new()),
 
+            peer_center,
+
             lock: Mutex::new(()),
         }
     }
@@ -270,6 +282,10 @@ impl ForeignNetworkEntry {
             .await
             .unwrap();
 
+        route
+            .set_route_cost_fn(self.peer_center.get_cost_calculator())
+            .await;
+
         self.peer_map.add_route(Arc::new(Box::new(route))).await;
     }
 
@@ -351,6 +367,7 @@ impl ForeignNetworkEntry {
         self.prepare_route(accessor).await;
         self.start_packet_recv().await;
         self.peer_rpc.run();
+        self.peer_center.init().await;
     }
 }
 

easytier/src/peers/peer.rs

@@ -201,14 +201,17 @@ impl Peer {
     }
 
     pub fn has_directly_connected_conn(&self) -> bool {
-        self.conns.iter().any(|entry|!(entry.value()).is_hole_punched())
+        self.conns
+            .iter()
+            .any(|entry| !(entry.value()).is_hole_punched())
     }
 
     pub fn get_directly_connections(&self) -> DashSet<uuid::Uuid> {
-        self.conns.iter()
-        .filter(|entry| !(entry.value()).is_hole_punched())
-        .map(|entry|(entry.value()).get_conn_id())
-        .collect()
+        self.conns
+            .iter()
+            .filter(|entry| !(entry.value()).is_hole_punched())
+            .map(|entry| (entry.value()).get_conn_id())
+            .collect()
     }
 
     pub fn get_default_conn_id(&self) -> PeerConnId {

easytier/src/peers/peer_manager.rs

@@ -8,7 +8,7 @@ use std::{
 use anyhow::Context;
 use async_trait::async_trait;
 
-use dashmap::{DashMap, DashSet};
+use dashmap::DashMap;
 
 use tokio::{
     sync::{
@@ -1184,14 +1184,6 @@ impl PeerManager {
         }
     }
 
-    pub fn get_directly_connections(&self, peer_id: PeerId) -> DashSet<uuid::Uuid> {
-        if let Some(peer) = self.peers.get_peer_by_id(peer_id) {
-            return peer.get_directly_connections();
-        }
-
-        DashSet::new()
-    }
-
     pub async fn clear_resources(&self) {
         let mut peer_pipeline = self.peer_packet_process_pipeline.write().await;
         peer_pipeline.clear();

easytier/src/peers/peer_map.rs

@@ -1,7 +1,10 @@
-use std::{net::{Ipv4Addr, Ipv6Addr}, sync::Arc};
+use std::{
+    net::{Ipv4Addr, Ipv6Addr},
+    sync::Arc,
+};
 
 use anyhow::Context;
-use dashmap::DashMap;
+use dashmap::{DashMap, DashSet};
 use tokio::sync::RwLock;
 
 use crate::{
@@ -10,7 +13,10 @@ use crate::{
         global_ctx::{ArcGlobalCtx, GlobalCtxEvent, NetworkIdentity},
         PeerId,
     },
-    proto::{cli::PeerConnInfo, peer_rpc::RoutePeerInfo},
+    proto::{
+        cli::{self, PeerConnInfo},
+        peer_rpc::RoutePeerInfo,
+    },
     tunnel::{packet_def::ZCPacket, TunnelError},
 };
 
@@ -91,6 +97,14 @@ impl PeerMap {
         self.peer_map.get(&peer_id).map(|v| v.clone())
     }
 
+    pub fn get_directly_connections_by_peer_id(&self, peer_id: PeerId) -> DashSet<uuid::Uuid> {
+        if let Some(peer) = self.get_peer_by_id(peer_id) {
+            return peer.get_directly_connections();
+        }
+
+        DashSet::new()
+    }
+
     pub fn has_peer(&self, peer_id: PeerId) -> bool {
         peer_id == self.my_peer_id || self.peer_map.contains_key(&peer_id)
     }
@@ -324,6 +338,13 @@ impl PeerMap {
         route_map
     }
 
+    pub async fn list_route_infos(&self) -> Vec<cli::Route> {
+        for route in self.routes.read().await.iter() {
+            return route.list_routes().await;
+        }
+        vec![]
+    }
+
     pub async fn need_relay_by_foreign_network(&self, dst_peer_id: PeerId) -> Result<bool, Error> {
         // if gateway_peer_id is not connected to me, means need relay by foreign network
         let gateway_id = self
@@ -343,6 +364,14 @@ impl PeerMap {
             .map(|v| (v.key().clone(), v.value().clone()))
             .collect()
     }
+
+    pub fn my_peer_id(&self) -> PeerId {
+        self.my_peer_id
+    }
+
+    pub fn get_global_ctx(&self) -> ArcGlobalCtx {
+        self.global_ctx.clone()
+    }
 }
 
 impl Drop for PeerMap {

easytier/src/peers/peer_ospf_route.rs

@@ -2264,7 +2264,7 @@ impl Route for PeerRoute {
 
             route.next_hop_peer_id_latency_first =
                 next_hop_peer_latency_first.map(|x| x.next_hop_peer_id);
-            route.cost_latency_first = next_hop_peer_latency_first.map(|x| x.path_latency);
+            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();

easytier/src/peers/rpc_service.rs

@@ -22,17 +22,17 @@ impl PeerManagerRpcService {
         PeerManagerRpcService { peer_manager }
     }
 
-    pub async fn list_peers(&self) -> Vec<PeerInfo> {
-        let mut peers = self.peer_manager.get_peer_map().list_peers().await;
+    pub async fn list_peers(peer_manager: &PeerManager) -> Vec<PeerInfo> {
+        let mut peers = peer_manager.get_peer_map().list_peers().await;
         peers.extend(
-            self.peer_manager
+            peer_manager
                 .get_foreign_network_client()
                 .get_peer_map()
                 .list_peers()
                 .await
                 .iter(),
         );
-        let peer_map = self.peer_manager.get_peer_map();
+        let peer_map = peer_manager.get_peer_map();
         let mut peer_infos = Vec::new();
         for peer in peers {
             let mut peer_info = PeerInfo::default();
@@ -41,17 +41,15 @@ impl PeerManagerRpcService {
                 .get_peer_default_conn_id(peer)
                 .await
                 .map(Into::into);
-            peer_info.directly_connected_conns = self
-                .peer_manager
-                .get_directly_connections(peer)
+            peer_info.directly_connected_conns = peer_map
+                .get_directly_connections_by_peer_id(peer)
                 .into_iter()
                 .map(Into::into)
                 .collect();
 
             if let Some(conns) = peer_map.list_peer_conns(peer).await {
                 peer_info.conns = conns;
-            } else if let Some(conns) = self
-                .peer_manager
+            } else if let Some(conns) = peer_manager
                 .get_foreign_network_client()
                 .get_peer_map()
                 .list_peer_conns(peer)
@@ -77,7 +75,7 @@ impl PeerManageRpc for PeerManagerRpcService {
     ) -> Result<ListPeerResponse, rpc_types::error::Error> {
         let mut reply = ListPeerResponse::default();
 
-        let peers = self.list_peers().await;
+        let peers = PeerManagerRpcService::list_peers(&self.peer_manager).await;
         for peer in peers {
             reply.peer_infos.push(peer);
         }