Add lazy P2P demand tracking and need_p2p override (#2003)

- add lazy_p2p so nodes only start background P2P for peers that actually have recent business traffic
- add need_p2p so specific peers can still request eager background P2P even when other nodes enable lazy mode
- cover the new behavior with focused connector/peer-manager tests plus three-node integration tests that verify relay-to-direct route transition

easytier/src/common/global_ctx.rs

@@ -202,10 +202,7 @@ pub struct GlobalCtx {
 
     running_listeners: Mutex<Vec<url::Url>>,
 
-    enable_exit_node: bool,
-    proxy_forward_by_system: bool,
-    no_tun: bool,
-    p2p_only: bool,
+    flags: ArcSwap<Flags>,
 
     feature_flags: AtomicCell<PeerFeatureFlag>,
 
@@ -237,6 +234,17 @@ impl std::fmt::Debug for GlobalCtx {
 pub type ArcGlobalCtx = std::sync::Arc<GlobalCtx>;
 
 impl GlobalCtx {
+    fn derive_feature_flags(flags: &Flags, current: Option<PeerFeatureFlag>) -> PeerFeatureFlag {
+        let mut feature_flags = current.unwrap_or_default();
+        feature_flags.kcp_input = !flags.disable_kcp_input;
+        feature_flags.no_relay_kcp = flags.disable_relay_kcp;
+        feature_flags.support_conn_list_sync = true;
+        feature_flags.quic_input = !flags.disable_quic_input;
+        feature_flags.no_relay_quic = flags.disable_relay_quic;
+        feature_flags.need_p2p = flags.need_p2p;
+        feature_flags
+    }
+
     pub fn new(config_fs: impl ConfigLoader + 'static) -> Self {
         let id = config_fs.get_id();
         let network = config_fs.get_network_identity();
@@ -261,19 +269,9 @@ impl GlobalCtx {
 
         let stun_info_collector = Arc::new(stun_info_collector);
 
-        let enable_exit_node = config_fs.get_flags().enable_exit_node || cfg!(target_env = "ohos");
-        let proxy_forward_by_system = config_fs.get_flags().proxy_forward_by_system;
-        let no_tun = config_fs.get_flags().no_tun;
-        let p2p_only = config_fs.get_flags().p2p_only;
+        let flags = config_fs.get_flags();
 
-        let feature_flags = PeerFeatureFlag {
-            kcp_input: !config_fs.get_flags().disable_kcp_input,
-            no_relay_kcp: config_fs.get_flags().disable_relay_kcp,
-            support_conn_list_sync: true, // Enable selective peer list sync by default
-            quic_input: !config_fs.get_flags().disable_quic_input,
-            no_relay_quic: config_fs.get_flags().disable_relay_quic,
-            ..Default::default()
-        };
+        let feature_flags = Self::derive_feature_flags(&flags, None);
 
         let credential_storage_path = config_fs.get_credential_file();
         let credential_manager = Arc::new(CredentialManager::new(credential_storage_path));
@@ -301,10 +299,7 @@ impl GlobalCtx {
 
             running_listeners: Mutex::new(Vec::new()),
 
-            enable_exit_node,
-            proxy_forward_by_system,
-            no_tun,
-            p2p_only,
+            flags: ArcSwap::new(Arc::new(flags)),
 
             feature_flags: AtomicCell::new(feature_flags),
 
@@ -455,11 +450,20 @@ impl GlobalCtx {
     }
 
     pub fn get_flags(&self) -> Flags {
-        self.config.get_flags()
+        self.flags.load().as_ref().clone()
     }
 
     pub fn set_flags(&self, flags: Flags) {
-        self.config.set_flags(flags);
+        self.config.set_flags(flags.clone());
+        self.feature_flags.store(Self::derive_feature_flags(
+            &flags,
+            Some(self.feature_flags.load()),
+        ));
+        self.flags.store(Arc::new(flags));
+    }
+
+    pub fn flags_arc(&self) -> Arc<Flags> {
+        self.flags.load_full()
     }
 
     pub fn get_128_key(&self) -> [u8; 16] {
@@ -503,15 +507,15 @@ impl GlobalCtx {
     }
 
     pub fn enable_exit_node(&self) -> bool {
-        self.enable_exit_node
+        self.flags.load().enable_exit_node || cfg!(target_env = "ohos")
     }
 
     pub fn proxy_forward_by_system(&self) -> bool {
-        self.proxy_forward_by_system
+        self.flags.load().proxy_forward_by_system
     }
 
     pub fn no_tun(&self) -> bool {
-        self.no_tun
+        self.flags.load().no_tun
     }
 
     pub fn get_feature_flags(&self) -> PeerFeatureFlag {
@@ -611,12 +615,13 @@ impl GlobalCtx {
     }
 
     pub fn p2p_only(&self) -> bool {
-        self.p2p_only
+        self.flags.load().p2p_only
     }
 
     pub fn latency_first(&self) -> bool {
         // NOTICE: p2p only is conflict with latency first
-        self.config.get_flags().latency_first && !self.p2p_only
+        let flags = self.flags.load();
+        flags.latency_first && !flags.p2p_only
     }
 
     fn is_port_in_running_listeners(&self, port: u16, is_udp: bool) -> bool {
@@ -730,6 +735,35 @@ pub mod tests {
         ));
     }
 
+    #[tokio::test]
+    async fn set_flags_keeps_derived_feature_flags_in_sync() {
+        let config = TomlConfigLoader::default();
+        let global_ctx = GlobalCtx::new(config);
+
+        let mut feature_flags = global_ctx.get_feature_flags();
+        feature_flags.avoid_relay_data = true;
+        feature_flags.is_public_server = true;
+        global_ctx.set_feature_flags(feature_flags);
+
+        let mut flags = global_ctx.get_flags();
+        flags.disable_kcp_input = true;
+        flags.disable_relay_kcp = true;
+        flags.disable_quic_input = true;
+        flags.disable_relay_quic = true;
+        flags.need_p2p = true;
+        global_ctx.set_flags(flags);
+
+        let feature_flags = global_ctx.get_feature_flags();
+        assert!(!feature_flags.kcp_input);
+        assert!(feature_flags.no_relay_kcp);
+        assert!(!feature_flags.quic_input);
+        assert!(feature_flags.no_relay_quic);
+        assert!(feature_flags.need_p2p);
+        assert!(feature_flags.support_conn_list_sync);
+        assert!(feature_flags.avoid_relay_data);
+        assert!(feature_flags.is_public_server);
+    }
+
     pub fn get_mock_global_ctx_with_network(
         network_identy: Option<NetworkIdentity>,
     ) -> ArcGlobalCtx {