add feature flag to ospf route

easytier/src/peers/foreign_network_manager.rs

@@ -28,6 +28,7 @@ use crate::{
     proto::{
         cli::{ForeignNetworkEntryPb, ListForeignNetworkResponse, PeerInfo},
         common::NatType,
+        peer_rpc::DirectConnectorRpcServer,
     },
     tunnel::packet_def::{PacketType, ZCPacket},
 };
@@ -37,6 +38,7 @@ use super::{
     peer_map::PeerMap,
     peer_ospf_route::PeerRoute,
     peer_rpc::{PeerRpcManager, PeerRpcManagerTransport},
+    peer_rpc_service::DirectConnectorManagerRpcServer,
     route_trait::{ArcRoute, NextHopPolicy},
     PacketRecvChan, PacketRecvChanReceiver,
 };
@@ -47,6 +49,7 @@ struct ForeignNetworkEntry {
     peer_map: Arc<PeerMap>,
     relay_data: bool,
     route: ArcRoute,
+    peer_rpc: Weak<PeerRpcManager>,
 }
 
 impl ForeignNetworkEntry {
@@ -65,6 +68,9 @@ impl ForeignNetworkEntry {
         foreign_global_ctx.replace_stun_info_collector(Box::new(MockStunInfoCollector {
             udp_nat_type: NatType::Unknown,
         }));
+        let mut feature_flag = global_ctx.get_feature_flags();
+        feature_flag.is_public_server = true;
+        global_ctx.set_feature_flags(feature_flag);
 
         let peer_map = Arc::new(PeerMap::new(
             packet_sender,
@@ -72,7 +78,17 @@ impl ForeignNetworkEntry {
             my_peer_id,
         ));
 
-        let route = PeerRoute::new(my_peer_id, foreign_global_ctx.clone(), peer_rpc);
+        let route = PeerRoute::new(my_peer_id, foreign_global_ctx.clone(), peer_rpc.clone());
+
+        for u in global_ctx.get_running_listeners().into_iter() {
+            foreign_global_ctx.add_running_listener(u);
+        }
+        peer_rpc.rpc_server().registry().register(
+            DirectConnectorRpcServer::new(DirectConnectorManagerRpcServer::new(
+                foreign_global_ctx.clone(),
+            )),
+            &network.network_name,
+        );
 
         Self {
             global_ctx: foreign_global_ctx,
@@ -80,6 +96,7 @@ impl ForeignNetworkEntry {
             peer_map,
             relay_data,
             route: Arc::new(Box::new(route)),
+            peer_rpc: Arc::downgrade(&peer_rpc),
         }
     }
 
@@ -116,6 +133,17 @@ impl ForeignNetworkEntry {
     }
 }
 
+impl Drop for ForeignNetworkEntry {
+    fn drop(&mut self) {
+        if let Some(peer_rpc) = self.peer_rpc.upgrade() {
+            peer_rpc
+                .rpc_server()
+                .registry()
+                .unregister_by_domain(&self.network.network_name);
+        }
+    }
+}
+
 struct ForeignNetworkManagerData {
     network_peer_maps: DashMap<String, Arc<ForeignNetworkEntry>>,
     peer_network_map: DashMap<PeerId, String>,

easytier/src/peers/mod.rs

@@ -6,6 +6,7 @@ pub mod peer_manager;
 pub mod peer_map;
 pub mod peer_ospf_route;
 pub mod peer_rpc;
+pub mod peer_rpc_service;
 pub mod route_trait;
 pub mod rpc_service;
 

easytier/src/peers/peer_manager.rs

@@ -750,6 +750,7 @@ impl PeerManager {
                 .collect(),
             config: self.global_ctx.config.dump(),
             version: EASYTIER_VERSION.to_string(),
+            feature_flag: Some(self.global_ctx.get_feature_flags()),
         }
     }
 

easytier/src/peers/peer_ospf_route.rs

@@ -102,6 +102,7 @@ impl RoutePeerInfo {
             last_update: Some(SystemTime::now().into()),
             version: 0,
             easytier_version: EASYTIER_VERSION.to_string(),
+            feature_flag: None,
         }
     }
 
@@ -127,6 +128,7 @@ impl RoutePeerInfo {
             version: self.version,
 
             easytier_version: EASYTIER_VERSION.to_string(),
+            feature_flag: Some(global_ctx.get_feature_flags()),
         };
 
         let need_update_periodically = if let Ok(Ok(d)) =
@@ -168,6 +170,7 @@ impl Into<crate::proto::cli::Route> for RoutePeerInfo {
             },
             inst_id: self.inst_id.map(|x| x.to_string()).unwrap_or_default(),
             version: self.easytier_version,
+            feature_flag: self.feature_flag,
         }
     }
 }

easytier/src/peers/peer_rpc_service.rs

@@ -0,0 +1,39 @@
+use crate::{
+    common::global_ctx::ArcGlobalCtx,
+    proto::{
+        peer_rpc::{DirectConnectorRpc, GetIpListRequest, GetIpListResponse},
+        rpc_types::{self, controller::BaseController},
+    },
+};
+
+#[derive(Clone)]
+pub struct DirectConnectorManagerRpcServer {
+    // TODO: this only cache for one src peer, should make it global
+    global_ctx: ArcGlobalCtx,
+}
+
+#[async_trait::async_trait]
+impl DirectConnectorRpc for DirectConnectorManagerRpcServer {
+    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()
+            .into_iter()
+            .map(Into::into)
+            .collect();
+        Ok(ret)
+    }
+}
+
+impl DirectConnectorManagerRpcServer {
+    pub fn new(global_ctx: ArcGlobalCtx) -> Self {
+        Self { global_ctx }
+    }
+}