Revert "perf: Improve kernel management logic & add more dev mode logs"

This reverts commit 18c7ed1ccc15b98e4873a276ac75e27276ab9d65.

package.json

@@ -3,7 +3,7 @@
   "version": "2.0.4-alpha",
   "license": "GPL-3.0-only",
   "scripts": {
-    "dev": "cross-env RUST_BACKTRACE=1 tauri dev --features verge-dev",
+    "dev": "cross-env RUST_BACKTRACE=1 tauri dev",
     "dev:diff": "cross-env RUST_BACKTRACE=1 tauri dev -f verge-dev",
     "build": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tauri build",
     "tauri": "tauri",

src-tauri/src/core/core.rs

@@ -10,14 +10,10 @@ use std::{sync::Arc, time::Duration};
 use tauri_plugin_shell::ShellExt;
 use tokio::sync::Mutex;
 use tokio::time::sleep;
-use super::process_lock::ProcessLock;
-use super::health_check::HealthChecker;
 
 #[derive(Debug)]
 pub struct CoreManager {
     running: Arc<Mutex<bool>>,
-    process_lock: Arc<Mutex<Option<ProcessLock>>>,
-    health_checker: HealthChecker,
 }
 
 impl CoreManager {
@@ -25,19 +21,11 @@ impl CoreManager {
         static CORE_MANAGER: OnceCell<CoreManager> = OnceCell::new();
         CORE_MANAGER.get_or_init(|| CoreManager {
             running: Arc::new(Mutex::new(false)),
-            process_lock: Arc::new(Mutex::new(None)),
-            health_checker: HealthChecker::new(),
         })
     }
 
     pub async fn init(&self) -> Result<()> {
         log::trace!("run core start");
-        
-        // 初始化进程锁
-        let process_lock = ProcessLock::new()?;
-        process_lock.acquire()?;
-        *self.process_lock.lock().await = Some(process_lock);
-
         // 启动clash
         log_err!(Self::global().start_core().await);
         log::trace!("run core end");
@@ -68,39 +56,37 @@ impl CoreManager {
 
     /// 停止核心运行
     pub async fn stop_core(&self) -> Result<()> {
-        log::info!(target: "app", "Stopping core");
+        let mut running = self.running.lock().await;
+
+        if !*running {
+            log::debug!("core is not running");
+            return Ok(());
+        }
 
         // 关闭tun模式
         let mut disable = Mapping::new();
         let mut tun = Mapping::new();
         tun.insert("enable".into(), false.into());
         disable.insert("tun".into(), tun.into());
-        log::debug!(target: "app", "Disabling TUN mode");
+        log::debug!(target: "app", "disable tun mode");
-        let _ = clash_api::patch_configs(&disable).await;
+        log_err!(clash_api::patch_configs(&disable).await);
 
-        // 直接尝试停止服务，不预先检查状态
+        // 服务模式
-        log::info!(target: "app", "Attempting to stop service");
+        if service::check_service().await.is_ok() {
-        let _ = service::stop_core_by_service().await;
+            log::info!(target: "app", "stop the core by service");
-
+            service::stop_core_by_service().await?;
-        // 设置运行状态
-        *self.running.lock().await = false;
-
-        // 释放进程锁
-        let mut process_lock = self.process_lock.lock().await;
-        if let Some(lock) = process_lock.take() {
-            log::info!(target: "app", "Releasing process lock");
-            let _ = lock.release();
         }
-
+        *running = false;
-        log::info!(target: "app", "Core stopped successfully");
         Ok(())
     }
 
     /// 启动核心
     pub async fn start_core(&self) -> Result<()> {
-        #[cfg(not(target_os = "macos"))]
+        let mut running = self.running.lock().await;
-        // 检查端口占用
+        if *running {
-        self.health_checker.check_ports().await?;
+            log::info!("core is running");
+            return Ok(());
+        }
 
         let config_path = Config::generate_file(ConfigType::Run)?;
 
@@ -109,23 +95,12 @@ impl CoreManager {
             log::info!(target: "app", "try to run core in service mode");
             service::run_core_by_service(&config_path).await?;
         }
-
-        // 启动健康检查
-        let checker = Arc::new(self.health_checker.clone());
-        tokio::spawn(async move {
-            loop {
-                sleep(Duration::from_secs(30)).await;
-                if let Err(e) = checker.check_service_health().await {
-                    log::error!(target: "app", "Health check failed: {}", e);
-                }
-            }
-        });
-
         // 流量订阅
         #[cfg(target_os = "macos")]
         log_err!(Tray::global().subscribe_traffic().await);
 
-        *self.running.lock().await = true;
+        *running = true;
+
         Ok(())
     }
 

src-tauri/src/core/mod.rs

@@ -9,6 +9,5 @@ pub mod sysopt;
 pub mod timer;
 pub mod tray;
 pub mod win_uwp;
-pub mod process_lock;
+
-pub mod health_check;
 pub use self::core::*;

src-tauri/src/core/service.rs

@@ -161,49 +161,20 @@ pub async fn reinstall_service() -> Result<()> {
 
 /// check the windows service status
 pub async fn check_service() -> Result<JsonResponse> {
-    log::info!(target: "app", "Checking service status");
-    println!("Checking service status");
-    
     let url = format!("{SERVICE_URL}/get_clash");
-    log::debug!(target: "app", "Sending request to {}", url);
+    let response = reqwest::ClientBuilder::new()
-    println!("Sending request to {}", url);
-    
-    let client = reqwest::ClientBuilder::new()
         .no_proxy()
         .timeout(Duration::from_secs(3))
-        .build()?;
+        .build()?
-    
+        .get(url)
-    // 重试3次
+        .send()
-    for i in 0..3 {
+        .await
-        match client.get(&url).send().await {
+        .context("failed to connect to the Clash Verge Service")?
-            Ok(resp) => {
+        .json::<JsonResponse>()
-                match resp.json::<JsonResponse>().await {
+        .await
-                    Ok(json) => {
+        .context("failed to parse the Clash Verge Service response")?;
-                        log::info!(target: "app", "Service check response: {:?}", json);
+
-                        println!("Service check response: {:?}", json);
+    Ok(response)
-                        return Ok(json);
-                    }
-                    Err(e) => {
-                        log::error!(target: "app", "Failed to parse service response (attempt {}): {}", i + 1, e);
-                        println!("Failed to parse service response (attempt {}): {}", i + 1, e);
-                        if i == 2 {
-                            return Err(e.into());
-                        }
-                    }
-                }
-            }
-            Err(e) => {
-                log::error!(target: "app", "Failed to connect to service (attempt {}): {}", i + 1, e);
-                println!("Failed to connect to service (attempt {}): {}", i + 1, e);
-                if i == 2 {
-                    return Err(e.into());
-                }
-            }
-        }
-        tokio::time::sleep(Duration::from_millis(500)).await;
-    }
-    
-    bail!("Failed to check service after 3 attempts")
 }
 
 /// start the clash by service
@@ -248,32 +219,14 @@ pub(super) async fn run_core_by_service(config_file: &PathBuf) -> Result<()> {
 
 /// stop the clash by service
 pub(super) async fn stop_core_by_service() -> Result<()> {
-    log::info!(target: "app", "Attempting to stop core through service");
-    
     let url = format!("{SERVICE_URL}/stop_clash");
-    let client = reqwest::ClientBuilder::new()
+    let _ = reqwest::ClientBuilder::new()
         .no_proxy()
-        .timeout(Duration::from_secs(3))
+        .build()?
-        .build()?;
+        .post(url)
-    
+        .send()
-    // 重试2次
+        .await
-    for i in 0..2 {
+        .context("failed to connect to the Clash Verge Service")?;
-        match client.post(&url).send().await {
+
-            Ok(_) => {
+    Ok(())
-                log::info!(target: "app", "Successfully sent stop request to service");
-                // 等待服务停止
-                tokio::time::sleep(Duration::from_millis(500)).await;
-                return Ok(());
-            }
-            Err(e) => {
-                log::error!(target: "app", "Failed to send stop request (attempt {}): {}", i + 1, e);
-                if i == 1 {
-                    return Err(e.into());
-                }
-            }
-        }
-        tokio::time::sleep(Duration::from_millis(500)).await;
-    }
-    
-    bail!("Failed to stop service after 2 attempts")
 }

src-tauri/src/feat.rs

@@ -162,41 +162,10 @@ pub fn toggle_tun_mode() {
 }
 
 pub fn quit(code: Option<i32>) {
-    println!("Starting application quit process");
-    log::info!(target: "app", "Starting application quit process");
-    
     let app_handle = handle::Handle::global().app_handle().unwrap();
     handle::Handle::global().set_is_exiting();
-    
+    resolve::resolve_reset();
-    // 立即关闭窗口，让用户感知到退出开始
+    log_err!(handle::Handle::global().get_window().unwrap().close());
-    if let Some(window) = handle::Handle::global().get_window() {
-        let _ = window.close();
-    }
-    
-    // 移除系统托盘图标
-    if let Some(tray) = app_handle.tray_by_id("main") {
-        let _ = tray.set_icon(None);
-    }
-    
-    // 后台执行所有清理工作
-    let app_handle_clone = app_handle.clone();
-    tauri::async_runtime::block_on(async move {
-        // 1. 发送停止内核指令
-        let _ = CoreManager::global().stop_core().await;
-        
-        // 2. 重置系统代理
-        resolve::resolve_reset();
-        
-        // 3. 保存窗口状态
-        let _ = app_handle_clone.save_window_state(StateFlags::default());
-        
-        println!("Cleanup tasks completed in background");
-        log::info!(target: "app", "Cleanup tasks completed in background");
-    });
-    
-    // 主线程退出
-    println!("Exiting application with code: {:?}", code);
-    log::info!(target: "app", "Exiting application with code: {:?}", code);
     app_handle.exit(code.unwrap_or(0));
 }
 

src-tauri/src/utils/init.rs

@@ -15,67 +15,47 @@ use tauri_plugin_shell::ShellExt;
 
 /// initialize this instance's log file
 fn init_log() -> Result<()> {
-    println!("Starting log initialization...");
-
     let log_dir = dirs::app_logs_dir()?;
     if !log_dir.exists() {
-        println!("Creating log directory: {:?}", log_dir);
         let _ = fs::create_dir_all(&log_dir);
     }
 
     let log_level = Config::verge().data().get_log_level();
-    println!("Current log level: {:?}", log_level);
-    
     if log_level == LevelFilter::Off {
-        println!("Logging is disabled");
         return Ok(());
     }
 
+    let local_time = Local::now().format("%Y-%m-%d-%H%M").to_string();
+    let log_file = format!("{}.log", local_time);
+    let log_file = log_dir.join(log_file);
+
     let log_pattern = match log_level {
         LevelFilter::Trace => "{d(%Y-%m-%d %H:%M:%S)} {l} [{M}] - {m}{n}",
         _ => "{d(%Y-%m-%d %H:%M:%S)} {l} - {m}{n}",
     };
 
     let encode = Box::new(PatternEncoder::new(log_pattern));
-    let stdout = ConsoleAppender::builder().encoder(encode.clone()).build();
 
-    let local_time = Local::now().format("%Y-%m-%d-%H%M").to_string();
+    let stdout = ConsoleAppender::builder().encoder(encode.clone()).build();
-    let log_file = format!("{}.log", local_time);
-    let log_file = log_dir.join(log_file);
-    println!("Log file path: {:?}", log_file);
-    
     let tofile = FileAppender::builder().encoder(encode).build(log_file)?;
 
     let mut logger_builder = Logger::builder();
     let mut root_builder = Root::builder();
 
     let log_more = log_level == LevelFilter::Trace || log_level == LevelFilter::Debug;
-    logger_builder = logger_builder.appenders(["stdout", "file"]);
+
-    root_builder = root_builder.appender("stdout");
+    logger_builder = logger_builder.appenders(["file"]);
     if log_more {
-        root_builder = root_builder.appender("file");
+        root_builder = root_builder.appenders(["file"]);
     }
 
-    println!("Building log config...");
+    let (config, _) = log4rs::config::Config::builder()
-    let config = log4rs::config::Config::builder()
         .appender(Appender::builder().build("stdout", Box::new(stdout)))
         .appender(Appender::builder().build("file", Box::new(tofile)))
         .logger(logger_builder.additive(false).build("app", log_level))
-        .build(root_builder.build(log_level))
+        .build_lossy(root_builder.build(log_level));
-        .map_err(|e| anyhow::anyhow!("Failed to build log config: {}", e))?;
 
-    println!("Initializing log config...");
+    log4rs::init_config(config)?;
-    match log4rs::init_config(config) {
-        Ok(_) => println!("Log system initialized successfully"),
-        Err(e) => println!("Failed to initialize log system: {}", e),
-    }
-
-    // 测试日志系统
-    log::error!(target: "app", "Test error log message");
-    log::warn!(target: "app", "Test warning log message");
-    log::info!(target: "app", "Test info log message");
-    log::debug!(target: "app", "Test debug log message");
-    log::trace!(target: "app", "Test trace log message");
 
     Ok(())
 }