[OHOS] fix: 修复内存泄露问题，并重构日志管理，预防性修复数据库初始化异常问题 (#2328)

* fix: leak memory
feat: new log manager

* fix: fail to init db

* fix: fail to init db

* fix: cargo format

easytier-contrib/easytier-ohrs/src/kernel_bridge/protocol.rs

@@ -48,3 +48,37 @@ pub(crate) fn broadcast_local_socket_message(
     *clients = active_clients;
     delivered
 }
+
+pub(crate) fn send_local_socket_json_payload_message(
+    stream: &mut UnixStream,
+    message_type: &str,
+    payload_json: &str,
+) -> std::io::Result<()> {
+    let message_type_json = serde_json::to_string(message_type)
+        .map_err(|err| Error::new(ErrorKind::InvalidData, err.to_string()))?;
+    let mut raw = Vec::with_capacity(message_type_json.len() + payload_json.len() + 38);
+    raw.extend_from_slice(b"{\"messageType\":");
+    raw.extend_from_slice(message_type_json.as_bytes());
+    raw.extend_from_slice(b",\"payloadJson\":");
+    raw.extend_from_slice(payload_json.as_bytes());
+    raw.extend_from_slice(b"}\n");
+    stream.write_all(&raw)?;
+    Ok(())
+}
+
+pub(crate) fn broadcast_local_socket_json_payload_message(
+    clients: &mut Vec<UnixStream>,
+    message_type: &str,
+    payload_json: &str,
+) -> bool {
+    let mut active_clients = Vec::with_capacity(clients.len());
+    let mut delivered = false;
+    for mut client in clients.drain(..) {
+        if send_local_socket_json_payload_message(&mut client, message_type, payload_json).is_ok() {
+            delivered = true;
+            active_clients.push(client);
+        }
+    }
+    *clients = active_clients;
+    delivered
+}

easytier-contrib/easytier-ohrs/src/kernel_bridge/routing.rs

@@ -1,20 +1,12 @@
-use crate::config::repository::load_config_json;
+use crate::config::repository::get_runtime_config_route_overrides;
 use crate::runtime::state::runtime_state::RuntimeInstanceState;
-use easytier::proto::api::manage::NetworkConfig;
 use ipnet::IpNet;
-use ohos_hilog_binding::hilog_debug;
 use std::collections::HashSet;
 use std::net::IpAddr;
 
-pub(crate) fn load_manual_routes(config_id: &str) -> Vec<String> {
-    load_config_json(config_id)
-        .and_then(|raw| serde_json::from_str::<NetworkConfig>(&raw).ok())
-        .map(|config| config.routes)
-        .unwrap_or_default()
-}
-
 fn normalize_route_cidr(route: &str) -> Option<String> {
-    route
+    let normalized = route.split("->").next().unwrap_or(route).trim();
+    normalized
         .parse::<IpNet>()
         .ok()
         .map(|network| match network {
@@ -22,7 +14,7 @@ fn normalize_route_cidr(route: &str) -> Option<String> {
             IpNet::V6(net) => net.trunc().to_string(),
         })
         .or_else(|| {
-            route.parse::<IpAddr>().ok().map(|addr| match addr {
+            normalized.parse::<IpAddr>().ok().map(|addr| match addr {
                 IpAddr::V4(ip) => format!("{}/32", ip),
                 IpAddr::V6(ip) => format!("{}/128", ip),
             })
@@ -67,8 +59,9 @@ pub(crate) fn aggregate_tun_routes(instance: &RuntimeInstanceState) -> Vec<Strin
         .my_node_info
         .as_ref()
         .and_then(|info| info.virtual_ipv4_cidr.clone());
-    let manual_routes = load_manual_routes(&instance.config_id);
-    let proxy_cidrs = instance
+    let (manual_routes, config_proxy_cidrs) =
+        get_runtime_config_route_overrides(&instance.config_id);
+    let runtime_proxy_cidrs = instance
         .routes
         .iter()
         .flat_map(|route| route.proxy_cidrs.iter().cloned())
@@ -80,15 +73,9 @@ pub(crate) fn aggregate_tun_routes(instance: &RuntimeInstanceState) -> Vec<Strin
     }
 
     raw_routes.extend(manual_routes.iter().cloned());
-    raw_routes.extend(proxy_cidrs.iter().cloned());
-    let aggregated_routes = simplify_routes(raw_routes);
-    hilog_debug!(
-        "[Rust] aggregate_tun_routes instance={} proxy_cidrs={:?} aggregated_routes={:?}",
-        instance.instance_id,
-        proxy_cidrs,
-        aggregated_routes
-    );
-    aggregated_routes
+    raw_routes.extend(config_proxy_cidrs.iter().cloned());
+    raw_routes.extend(runtime_proxy_cidrs.iter().cloned());
+    simplify_routes(raw_routes)
 }
 
 pub(crate) fn aggregate_requested_tun_routes(instances: &[RuntimeInstanceState]) -> Vec<String> {

easytier-contrib/easytier-ohrs/src/kernel_bridge/socket_server.rs

@@ -1,8 +1,11 @@
-use super::protocol::{TunRequestPayload, broadcast_local_socket_message};
+use super::protocol::{
+    TunRequestPayload, broadcast_local_socket_json_payload_message, broadcast_local_socket_message,
+};
+use crate::INSTANCE_MANAGER;
 use crate::config::repository::kernel_socket_path;
 use crate::get_runtime_snapshot_inner;
 use crate::kernel_bridge::routing::aggregate_tun_routes;
-use ohos_hilog_binding::{hilog_error, hilog_info};
+use easytier::common::global_ctx::{EventBusSubscriber, GlobalCtxEvent};
 use once_cell::sync::Lazy;
 use std::collections::{HashMap, HashSet};
 use std::io::ErrorKind;
@@ -11,7 +14,7 @@ use std::path::PathBuf;
 use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread::{self, JoinHandle};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 struct LocalSocketState {
     stop_flag: std::sync::Arc<AtomicBool>,
@@ -20,12 +23,77 @@ struct LocalSocketState {
 }
 
 static LOCAL_SOCKET_STATE: Lazy<Mutex<Option<LocalSocketState>>> = Lazy::new(|| Mutex::new(None));
+static SNAPSHOT_BROADCAST_ENABLED: AtomicBool = AtomicBool::new(true);
+const SOCKET_TICK_INTERVAL: Duration = Duration::from_millis(250);
+const TUN_FAST_CHECK_WINDOW: Duration = Duration::from_secs(8);
+const EVENT_RECEIVER_SYNC_INTERVAL: Duration = Duration::from_secs(1);
+
+pub fn set_snapshot_broadcast_enabled(enabled: bool) {
+    SNAPSHOT_BROADCAST_ENABLED.store(enabled, Ordering::Relaxed);
+}
+
+fn sync_tun_event_receivers(receivers: &mut HashMap<String, EventBusSubscriber>) {
+    let mut active_instance_ids = HashSet::new();
+    for instance in INSTANCE_MANAGER.iter() {
+        let instance_id = instance.key().to_string();
+        active_instance_ids.insert(instance_id.clone());
+        if !receivers.contains_key(&instance_id)
+            && let Some(receiver) = instance.value().subscribe_event()
+        {
+            receivers.insert(instance_id, receiver);
+        }
+    }
+    receivers.retain(|instance_id, _| active_instance_ids.contains(instance_id));
+}
+
+fn event_needs_tun_refresh(event: &GlobalCtxEvent) -> bool {
+    matches!(
+        event,
+        GlobalCtxEvent::DhcpIpv4Changed(_, _)
+            | GlobalCtxEvent::DhcpIpv4Conflicted(_)
+            | GlobalCtxEvent::PublicIpv6Changed(_, _)
+            | GlobalCtxEvent::PublicIpv6RoutesUpdated(_, _)
+            | GlobalCtxEvent::ProxyCidrsUpdated(_, _)
+            | GlobalCtxEvent::ConfigPatched(_)
+            | GlobalCtxEvent::PeerAdded(_)
+            | GlobalCtxEvent::PeerRemoved(_)
+            | GlobalCtxEvent::PeerConnAdded(_)
+            | GlobalCtxEvent::PeerConnRemoved(_)
+    )
+}
+
+fn drain_tun_refresh_events(receivers: &mut HashMap<String, EventBusSubscriber>) -> bool {
+    let mut refresh_needed = false;
+    let mut closed_receivers = Vec::new();
+    for (instance_id, receiver) in receivers.iter_mut() {
+        loop {
+            match receiver.try_recv() {
+                Ok(event) => {
+                    refresh_needed = event_needs_tun_refresh(&event) || refresh_needed;
+                }
+                Err(tokio::sync::broadcast::error::TryRecvError::Empty) => break,
+                Err(tokio::sync::broadcast::error::TryRecvError::Lagged(_)) => {
+                    refresh_needed = true;
+                    continue;
+                }
+                Err(tokio::sync::broadcast::error::TryRecvError::Closed) => {
+                    closed_receivers.push(instance_id.clone());
+                    break;
+                }
+            }
+        }
+    }
+    for instance_id in closed_receivers {
+        receivers.remove(&instance_id);
+    }
+    refresh_needed
+}
 
 pub fn start_local_socket_server() -> bool {
     let socket_path = match kernel_socket_path() {
         Some(path) => path,
         None => {
-            hilog_error!("[Rust] kernel socket path unavailable");
+            ohrs_log_error!("[Rust] kernel socket path unavailable");
             return false;
         }
     };
@@ -34,7 +102,7 @@ pub fn start_local_socket_server() -> bool {
         Ok(guard) if guard.is_some() => return true,
         Ok(_) => {}
         Err(err) => {
-            hilog_error!("[Rust] lock localsocket state failed: {}", err);
+            ohrs_log_error!("[Rust] lock localsocket state failed: {}", err);
             return false;
         }
     }
@@ -46,7 +114,7 @@ pub fn start_local_socket_server() -> bool {
     let listener = match UnixListener::bind(&socket_path) {
         Ok(listener) => listener,
         Err(err) => {
-            hilog_error!(
+            ohrs_log_error!(
                 "[Rust] bind localsocket failed {}: {}",
                 socket_path.display(),
                 err
@@ -55,7 +123,7 @@ pub fn start_local_socket_server() -> bool {
         }
     };
     if let Err(err) = listener.set_nonblocking(true) {
-        hilog_error!("[Rust] set localsocket nonblocking failed: {}", err);
+        ohrs_log_error!("[Rust] set localsocket nonblocking failed: {}", err);
         let _ = std::fs::remove_file(&socket_path);
         return false;
     }
@@ -66,6 +134,10 @@ pub fn start_local_socket_server() -> bool {
         let mut last_snapshot_json = String::new();
         let mut delivered_tun_requests = HashSet::new();
         let mut last_tun_route_signatures = HashMap::<String, String>::new();
+        let mut tun_fast_until = Instant::now() + TUN_FAST_CHECK_WINDOW;
+        let mut tun_bootstrap_done = false;
+        let mut last_event_receiver_sync_at: Option<Instant> = None;
+        let mut tun_event_receivers = HashMap::<String, EventBusSubscriber>::new();
         let mut clients = Vec::<UnixStream>::new();
 
         while !worker_stop_flag.load(Ordering::Relaxed) {
@@ -75,36 +147,86 @@ pub fn start_local_socket_server() -> bool {
                     Ok((stream, _addr)) => {
                         accepted_client = true;
                         clients.push(stream);
+                        tun_fast_until = Instant::now() + TUN_FAST_CHECK_WINDOW;
+                        tun_bootstrap_done = false;
                     }
                     Err(err) if err.kind() == ErrorKind::WouldBlock => break,
                     Err(err) => {
-                        hilog_error!("[Rust] accept localsocket failed: {}", err);
+                        ohrs_log_error!("[Rust] accept localsocket failed: {}", err);
                         break;
                     }
                 }
             }
 
-            let snapshot = get_runtime_snapshot_inner();
-            let snapshot_json = match serde_json::to_string(&snapshot) {
-                Ok(json) => json,
-                Err(err) => {
-                    hilog_error!("[Rust] serialize runtime snapshot failed: {}", err);
-                    thread::sleep(Duration::from_millis(250));
-                    continue;
+            let snapshot_enabled = SNAPSHOT_BROADCAST_ENABLED.load(Ordering::Relaxed);
+            if clients.is_empty() {
+                if !last_snapshot_json.is_empty() {
+                    last_snapshot_json.clear();
                 }
-            };
-
-            if accepted_client || snapshot_json != last_snapshot_json {
-                let _ = broadcast_local_socket_message(
-                    &mut clients,
-                    "runtime_snapshot",
-                    &snapshot_json,
-                );
-                last_snapshot_json = snapshot_json;
+                delivered_tun_requests.clear();
+                last_tun_route_signatures.clear();
+                tun_event_receivers.clear();
+                last_event_receiver_sync_at = None;
+                tun_bootstrap_done = false;
+                thread::sleep(SOCKET_TICK_INTERVAL);
+                continue;
             }
 
+            let now = Instant::now();
+            let should_sync_event_receivers = accepted_client
+                || last_event_receiver_sync_at
+                    .map(|last| now.duration_since(last) >= EVENT_RECEIVER_SYNC_INTERVAL)
+                    .unwrap_or(true);
+            if should_sync_event_receivers {
+                sync_tun_event_receivers(&mut tun_event_receivers);
+                last_event_receiver_sync_at = Some(now);
+            }
+            if drain_tun_refresh_events(&mut tun_event_receivers) {
+                tun_bootstrap_done = false;
+                tun_fast_until = now + TUN_FAST_CHECK_WINDOW;
+            }
+            let should_collect_snapshot = snapshot_enabled
+                || accepted_client
+                || (!tun_bootstrap_done && now < tun_fast_until);
+            if !should_collect_snapshot {
+                if !last_snapshot_json.is_empty() {
+                    last_snapshot_json.clear();
+                }
+                thread::sleep(SOCKET_TICK_INTERVAL);
+                continue;
+            }
+
+            let snapshot = get_runtime_snapshot_inner();
+            if snapshot_enabled {
+                let snapshot_json = match serde_json::to_string(&snapshot) {
+                    Ok(json) => json,
+                    Err(err) => {
+                        ohrs_log_error!("[Rust] serialize runtime snapshot failed: {}", err);
+                        thread::sleep(SOCKET_TICK_INTERVAL);
+                        continue;
+                    }
+                };
+
+                if accepted_client || snapshot_json != last_snapshot_json {
+                    let _ = broadcast_local_socket_json_payload_message(
+                        &mut clients,
+                        "runtime_snapshot",
+                        &snapshot_json,
+                    );
+                    last_snapshot_json = snapshot_json;
+                }
+            } else if !last_snapshot_json.is_empty() {
+                last_snapshot_json.clear();
+            }
+
+            let mut saw_running_instance = false;
+            let mut saw_tun_candidate = false;
             for instance in snapshot.instances.iter() {
+                if instance.running {
+                    saw_running_instance = true;
+                }
                 if instance.running && instance.tun_required {
+                    saw_tun_candidate = true;
                     let virtual_ipv4 = instance
                         .my_node_info
                         .as_ref()
@@ -120,9 +242,16 @@ pub fn start_local_socket_server() -> bool {
                         continue;
                     }
                     let aggregated_routes = aggregate_tun_routes(instance);
-                    let route_signature = serde_json::to_string(&aggregated_routes)
-                        .unwrap_or_else(|_| "[]".to_string());
-                    let should_send = !delivered_tun_requests.contains(&instance.instance_id)
+                    let route_signature = serde_json::to_string(&(
+                        &virtual_ipv4,
+                        &virtual_ipv4_cidr,
+                        &aggregated_routes,
+                        instance.magic_dns_enabled,
+                        instance.need_exit_node,
+                    ))
+                    .unwrap_or_else(|_| "[]".to_string());
+                    let should_send = accepted_client
+                        || !delivered_tun_requests.contains(&instance.instance_id)
                         || last_tun_route_signatures
                             .get(&instance.instance_id)
                             .map(|value| value != &route_signature)
@@ -143,7 +272,7 @@ pub fn start_local_socket_server() -> bool {
                     let payload_json = match serde_json::to_string(&payload) {
                         Ok(json) => json,
                         Err(err) => {
-                            hilog_error!("[Rust] serialize tun request failed: {}", err);
+                            ohrs_log_error!("[Rust] serialize tun request failed: {}", err);
                             continue;
                         }
                     };
@@ -157,8 +286,15 @@ pub fn start_local_socket_server() -> bool {
                     last_tun_route_signatures.remove(&instance.instance_id);
                 }
             }
+            if !snapshot_enabled
+                && (!delivered_tun_requests.is_empty()
+                    || (saw_running_instance && !saw_tun_candidate)
+                    || now >= tun_fast_until)
+            {
+                tun_bootstrap_done = true;
+            }
 
-            thread::sleep(Duration::from_millis(250));
+            thread::sleep(SOCKET_TICK_INTERVAL);
         }
     });
 
@@ -172,7 +308,7 @@ pub fn start_local_socket_server() -> bool {
             true
         }
         Err(err) => {
-            hilog_error!("[Rust] lock localsocket state failed: {}", err);
+            ohrs_log_error!("[Rust] lock localsocket state failed: {}", err);
             false
         }
     }
@@ -182,7 +318,7 @@ pub fn stop_local_socket_server() -> bool {
     let state = match LOCAL_SOCKET_STATE.lock() {
         Ok(mut guard) => guard.take(),
         Err(err) => {
-            hilog_error!("[Rust] lock localsocket state failed: {}", err);
+            ohrs_log_error!("[Rust] lock localsocket state failed: {}", err);
             return false;
         }
     };