shkong/clash-verge-rev
1
0
Fork 0
mirror of https://github.com/clash-verge-rev/clash-verge-rev synced 2025-05-04 23:33:44 +08:00
Code Packages Projects Releases Activity

refactor(logging): replace log_err! with structured logging_error! calls

Browse Source 
refactor(cm-service): better error handling from Backend to Frontend
This commit is contained in:
Tunglies 2025-03-28 03:39:21 +08:00
parent 59caa22431
commit e8e16f7d57
18 changed files with 232 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src-tauri/src/cmd/app.rs
View File

@ -200,7 +200,7 @@ pub fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<String> {
} }
logging!( logging!(
info, info,
Type::CMD, Type::Cmd,
true, true,
"Copying icon file path: {:?} -> file dist: {:?}", "Copying icon file path: {:?} -> file dist: {:?}",
path, path,

24
src-tauri/src/cmd/profile.rs
View File

@ -1,8 +1,8 @@
use super::CmdResult; use super::CmdResult;
use crate::{ use crate::{
config::*, config::*,
core::*, core::{tray::Tray, *},
feat, log_err, logging, ret_err, feat, logging, logging_error, ret_err,
utils::{dirs, help, logging::Type}, utils::{dirs, help, logging::Type},
wrap_err, wrap_err,
}; };
@ -19,8 +19,8 @@ pub fn get_profiles() -> CmdResult<IProfiles> {
pub async fn enhance_profiles() -> CmdResult { pub async fn enhance_profiles() -> CmdResult {
match CoreManager::global().update_config().await { match CoreManager::global().update_config().await {
Ok((true, _)) => { Ok((true, _)) => {
println!("[enhance_profiles] 配置更新成功"); logging!(info, Type::Cmd, true, "配置更新成功");
log_err!(tray::Tray::global().update_tooltip()); logging_error!(Type::Tray, true, Tray::global().update_tooltip());
handle::Handle::refresh_clash(); handle::Handle::refresh_clash();
Ok(()) Ok(())
} }
@ -77,19 +77,19 @@ pub async fn delete_profile(index: String) -> CmdResult {
/// 修改profiles的配置 /// 修改profiles的配置
#[tauri::command] #[tauri::command]
pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> { pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
logging!(info, Type::CMD, true, "开始修改配置文件"); logging!(info, Type::Cmd, true, "开始修改配置文件");
// 保存当前配置，以便在验证失败时恢复 // 保存当前配置，以便在验证失败时恢复
let current_profile = Config::profiles().latest().current.clone(); let current_profile = Config::profiles().latest().current.clone();
logging!(info, Type::CMD, true, "当前配置: {:?}", current_profile); logging!(info, Type::Cmd, true, "当前配置: {:?}", current_profile);
// 更新profiles配置 // 更新profiles配置
logging!(info, Type::CMD, true, "正在更新配置草稿"); logging!(info, Type::Cmd, true, "正在更新配置草稿");
wrap_err!({ Config::profiles().draft().patch_config(profiles) })?; wrap_err!({ Config::profiles().draft().patch_config(profiles) })?;
// 更新配置并进行验证 // 更新配置并进行验证
match CoreManager::global().update_config().await { match CoreManager::global().update_config().await {
Ok((true, _)) => { Ok((true, _)) => {
logging!(info, Type::CMD, true, "配置更新成功"); logging!(info, Type::Cmd, true, "配置更新成功");
handle::Handle::refresh_clash(); handle::Handle::refresh_clash();
let _ = tray::Tray::global().update_tooltip(); let _ = tray::Tray::global().update_tooltip();
Config::profiles().apply(); Config::profiles().apply();
@ -97,13 +97,13 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
Ok(true) Ok(true)
} }
Ok((false, error_msg)) => { Ok((false, error_msg)) => {
logging!(warn, Type::CMD, true, "配置验证失败: {}", error_msg); logging!(warn, Type::Cmd, true, "配置验证失败: {}", error_msg);
Config::profiles().discard(); Config::profiles().discard();
// 如果验证失败，恢复到之前的配置 // 如果验证失败，恢复到之前的配置
if let Some(prev_profile) = current_profile { if let Some(prev_profile) = current_profile {
logging!( logging!(
info, info,
Type::CMD, Type::Cmd,
true, true,
"尝试恢复到之前的配置: {}", "尝试恢复到之前的配置: {}",
prev_profile prev_profile
@ -116,7 +116,7 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?; wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
Config::profiles().apply(); Config::profiles().apply();
wrap_err!(Config::profiles().data().save_file())?; wrap_err!(Config::profiles().data().save_file())?;
logging!(info, Type::CMD, true, "成功恢复到之前的配置"); logging!(info, Type::Cmd, true, "成功恢复到之前的配置");
} }
// 发送验证错误通知 // 发送验证错误通知
@ -124,7 +124,7 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
Ok(false) Ok(false)
} }
Err(e) => { Err(e) => {
logging!(warn, Type::CMD, true, "更新过程发生错误: {}", e); logging!(warn, Type::Cmd, true, "更新过程发生错误: {}", e);
Config::profiles().discard(); Config::profiles().discard();
handle::Handle::notice_message("config_validate::boot_error", e.to_string()); handle::Handle::notice_message("config_validate::boot_error", e.to_string());
Ok(false) Ok(false)

37
src-tauri/src/cmd/service.rs
View File

@ -5,34 +5,39 @@ use crate::{
utils::logging::Type, utils::logging::Type,
}; };
async fn execute_service_operation(
service_op: impl std::future::Future<Output = Result<(), impl ToString + std::fmt::Debug>>,
op_type: &str,
) -> CmdResult {
if let Err(e) = service_op.await {
let emsg = format!("{} {} failed: {:?}", op_type, "service", e);
logging_error!(Type::Service, true, "{}", emsg);
return Err(emsg);
}
if let Err(e) = CoreManager::global().restart_core().await {
let emsg = format!("{} {} failed: {:?}", op_type, "core", e);
logging_error!(Type::Core, true, "{}", emsg);
return Err(emsg);
}
Ok(())
}
#[tauri::command] #[tauri::command]
pub async fn install_service() -> CmdResult { pub async fn install_service() -> CmdResult {
logging_error!(Type::Service, true, service::install_service().await); execute_service_operation(service::install_service(), "Install").await
logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
Ok(())
} }
#[tauri::command] #[tauri::command]
pub async fn uninstall_service() -> CmdResult { pub async fn uninstall_service() -> CmdResult {
logging_error!(Type::Service, true, service::uninstall_service().await); execute_service_operation(service::uninstall_service(), "Uninstall").await
logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
Ok(())
} }
#[tauri::command] #[tauri::command]
pub async fn reinstall_service() -> CmdResult { pub async fn reinstall_service() -> CmdResult {
logging_error!(Type::Service, true, service::reinstall_service().await); execute_service_operation(service::reinstall_service(), "Reinstall").await
logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
Ok(())
} }
#[tauri::command] #[tauri::command]
pub async fn repair_service() -> CmdResult { pub async fn repair_service() -> CmdResult {
logging_error!( execute_service_operation(service::force_reinstall_service(), "Repair").await
Type::Service,
true,
service::force_reinstall_service().await
);
logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
Ok(())
} }

7
src-tauri/src/config/config.rs
View File

@ -66,9 +66,12 @@ impl Config {
let script_item = PrfItem::from_script(Some("Script".to_string()))?; let script_item = PrfItem::from_script(Some("Script".to_string()))?;
Self::profiles().data().append_item(script_item.clone())?; Self::profiles().data().append_item(script_item.clone())?;
} }
// 生成运行时配置 // 生成运行时配置
crate::log_err!(Self::generate().await); if let Err(err) = Self::generate().await {
logging!(error, Type::Config, true, "生成运行时配置失败: {}", err);
} else {
logging!(info, Type::Config, true, "生成运行时配置成功");
}
// 生成运行时配置文件并验证 // 生成运行时配置文件并验证
let config_result = Self::generate_file(ConfigType::Run); let config_result = Self::generate_file(ConfigType::Run);

27
src-tauri/src/core/handle.rs
View File

@ -1,9 +1,10 @@
use crate::log_err;
use once_cell::sync::OnceCell; use once_cell::sync::OnceCell;
use parking_lot::RwLock; use parking_lot::RwLock;
use std::sync::Arc; use std::sync::Arc;
use tauri::{AppHandle, Emitter, Manager, WebviewWindow}; use tauri::{AppHandle, Emitter, Manager, WebviewWindow};
use crate::{logging_error, utils::logging::Type};
#[derive(Debug, Default, Clone)] #[derive(Debug, Default, Clone)]
pub struct Handle { pub struct Handle {
pub app_handle: Arc<RwLock<Option<AppHandle>>>, pub app_handle: Arc<RwLock<Option<AppHandle>>>,
@ -40,26 +41,42 @@ impl Handle {
pub fn refresh_clash() { pub fn refresh_clash() {
if let Some(window) = Self::global().get_window() { if let Some(window) = Self::global().get_window() {
log_err!(window.emit("verge://refresh-clash-config", "yes")); logging_error!(
Type::Frontend,
true,
window.emit("verge://refresh-clash-config", "yes")
);
} }
} }
pub fn refresh_verge() { pub fn refresh_verge() {
if let Some(window) = Self::global().get_window() { if let Some(window) = Self::global().get_window() {
log_err!(window.emit("verge://refresh-verge-config", "yes")); logging_error!(
Type::Frontend,
true,
window.emit("verge://refresh-verge-config", "yes")
);
} }
} }
#[allow(unused)] #[allow(unused)]
pub fn refresh_profiles() { pub fn refresh_profiles() {
if let Some(window) = Self::global().get_window() { if let Some(window) = Self::global().get_window() {
log_err!(window.emit("verge://refresh-profiles-config", "yes")); logging_error!(
Type::Frontend,
true,
window.emit("verge://refresh-profiles-config", "yes")
);
} }
} }
pub fn notice_message<S: Into<String>, M: Into<String>>(status: S, msg: M) { pub fn notice_message<S: Into<String>, M: Into<String>>(status: S, msg: M) {
if let Some(window) = Self::global().get_window() { if let Some(window) = Self::global().get_window() {
log_err!(window.emit("verge://notice-message", (status.into(), msg.into()))); logging_error!(
Type::Frontend,
true,
window.emit("verge://notice-message", (status.into(), msg.into()))
);
} }
} }

4
src-tauri/src/core/hotkey.rs
View File

@ -1,7 +1,7 @@
use crate::{ use crate::{
config::Config, config::Config,
core::handle, core::handle,
feat, log_err, logging, feat, logging, logging_error,
module::lightweight::entry_lightweight_mode, module::lightweight::entry_lightweight_mode,
utils::{logging::Type, resolve}, utils::{logging::Type, resolve},
}; };
@ -285,7 +285,7 @@ impl Hotkey {
}); });
add.iter().for_each(|(key, func)| { add.iter().for_each(|(key, func)| {
log_err!(self.register(key, func)); logging_error!(Type::Hotkey, true, self.register(key, func));
}); });
*current = new_hotkeys; *current = new_hotkeys;

11
src-tauri/src/core/sysopt.rs
View File

@ -1,7 +1,8 @@
use crate::{ use crate::{
config::{Config, IVerge}, config::{Config, IVerge},
core::handle::Handle, core::handle::Handle,
log_err, logging_error,
utils::logging::Type,
}; };
use anyhow::Result; use anyhow::Result;
use once_cell::sync::OnceCell; use once_cell::sync::OnceCell;
@ -231,7 +232,7 @@ impl Sysopt {
} else { } else {
log::info!(target: "app", "Auto launch enabled successfully"); log::info!(target: "app", "Auto launch enabled successfully");
} }
log_err!(result) logging_error!(Type::System, true, result);
} }
false => { false => {
let result = autostart_manager.disable(); let result = autostart_manager.disable();
@ -240,7 +241,7 @@ impl Sysopt {
} else { } else {
log::info!(target: "app", "Auto launch disabled successfully"); log::info!(target: "app", "Auto launch disabled successfully");
} }
log_err!(result) logging_error!(Type::System, true, result);
} }
}; };
@ -323,7 +324,7 @@ impl Sysopt {
enable: true, enable: true,
url: format!("http://127.0.0.1:{pac_port}/commands/pac"), url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
}; };
log_err!(autoproxy.set_auto_proxy()); logging_error!(Type::System, true, autoproxy.set_auto_proxy());
} else { } else {
let sysproxy = Sysproxy { let sysproxy = Sysproxy {
enable: true, enable: true,
@ -332,7 +333,7 @@ impl Sysopt {
bypass: get_bypass(), bypass: get_bypass(),
}; };
log_err!(sysproxy.set_system_proxy()); logging_error!(Type::System, true, sysproxy.set_system_proxy());
} }
} }

8
src-tauri/src/core/tray/mod.rs
View File

@ -8,7 +8,7 @@ use crate::{
feat, feat,
module::{lightweight::entry_lightweight_mode, mihomo::Rate}, module::{lightweight::entry_lightweight_mode, mihomo::Rate},
resolve, resolve,
utils::{dirs::find_target_icons, i18n::t, resolve::VERSION}, utils::{dirs::find_target_icons, i18n::t, logging::Type, resolve::VERSION},
}; };
use anyhow::Result; use anyhow::Result;
@ -684,9 +684,9 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
"system_proxy" => feat::toggle_system_proxy(), "system_proxy" => feat::toggle_system_proxy(),
"tun_mode" => feat::toggle_tun_mode(None), "tun_mode" => feat::toggle_tun_mode(None),
"copy_env" => feat::copy_clash_env(), "copy_env" => feat::copy_clash_env(),
"open_app_dir" => crate::log_err!(cmd::open_app_dir()), "open_app_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_app_dir()),
"open_core_dir" => crate::log_err!(cmd::open_core_dir()), "open_core_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_core_dir()),
"open_logs_dir" => crate::log_err!(cmd::open_logs_dir()), "open_logs_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_logs_dir()),
"restart_clash" => feat::restart_clash_core(), "restart_clash" => feat::restart_clash_core(),
"restart_app" => feat::restart_app(), "restart_app" => feat::restart_app(),
"entry_lightweight_mode" => entry_lightweight_mode(), "entry_lightweight_mode" => entry_lightweight_mode(),

1
src-tauri/src/error/mod.rs Normal file
View File

@ -0,0 +1 @@
pub mod service;

1
src-tauri/src/error/service.rs Normal file
View File

@ -0,0 +1 @@

9
src-tauri/src/feat/backup.rs
View File

@ -1,8 +1,8 @@
use crate::{ use crate::{
config::{Config, IVerge}, config::{Config, IVerge},
core::backup, core::backup,
log_err, logging_error,
utils::dirs::app_home_dir, utils::{dirs::app_home_dir, logging::Type},
}; };
use anyhow::Result; use anyhow::Result;
use reqwest_dav::list_cmd::ListFile; use reqwest_dav::list_cmd::ListFile;
@ -69,8 +69,9 @@ pub async fn restore_webdav_backup(filename: String) -> Result<()> {
// extract zip file // extract zip file
let mut zip = zip::ZipArchive::new(fs::File::open(backup_storage_path.clone())?)?; let mut zip = zip::ZipArchive::new(fs::File::open(backup_storage_path.clone())?)?;
zip.extract(app_home_dir()?)?; zip.extract(app_home_dir()?)?;
logging_error!(
log_err!( Type::Backup,
true,
super::patch_verge( super::patch_verge(
IVerge { IVerge {
webdav_url, webdav_url,

10
src-tauri/src/feat/clash.rs
View File

@ -1,9 +1,9 @@
use crate::{ use crate::{
config::Config, config::Config,
core::{handle, tray, CoreManager}, core::{handle, tray, CoreManager},
log_err, logging_error,
module::mihomo::MihomoManager, module::mihomo::MihomoManager,
utils::resolve, utils::{logging::Type, resolve},
}; };
use serde_yaml::{Mapping, Value}; use serde_yaml::{Mapping, Value};
use tauri::Manager; use tauri::Manager;
@ -28,7 +28,7 @@ pub fn restart_clash_core() {
pub fn restart_app() { pub fn restart_app() {
tauri::async_runtime::spawn_blocking(|| { tauri::async_runtime::spawn_blocking(|| {
tauri::async_runtime::block_on(async { tauri::async_runtime::block_on(async {
log_err!(CoreManager::global().stop_core().await); logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
}); });
resolve::resolve_reset(); resolve::resolve_reset();
let app_handle = handle::Handle::global().app_handle().unwrap(); let app_handle = handle::Handle::global().app_handle().unwrap();
@ -54,8 +54,8 @@ pub fn change_clash_mode(mode: String) {
if Config::clash().data().save_config().is_ok() { if Config::clash().data().save_config().is_ok() {
handle::Handle::refresh_clash(); handle::Handle::refresh_clash();
log_err!(tray::Tray::global().update_menu()); logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
log_err!(tray::Tray::global().update_icon(None)); logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
} }
} }
Err(err) => println!("{err}"), Err(err) => println!("{err}"),

7
src-tauri/src/feat/config.rs
View File

@ -1,8 +1,9 @@
use crate::{ use crate::{
config::{Config, IVerge}, config::{Config, IVerge},
core::{handle, hotkey, sysopt, tray, CoreManager}, core::{handle, hotkey, sysopt, tray, CoreManager},
log_err, logging_error,
module::lightweight, module::lightweight,
utils::logging::Type,
}; };
use anyhow::Result; use anyhow::Result;
use serde_yaml::Mapping; use serde_yaml::Mapping;
@ -18,8 +19,8 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
CoreManager::global().restart_core().await?; CoreManager::global().restart_core().await?;
} else { } else {
if patch.get("mode").is_some() { if patch.get("mode").is_some() {
log_err!(tray::Tray::global().update_menu()); logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
log_err!(tray::Tray::global().update_icon(None)); logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
} }
Config::runtime().latest().patch_config(patch); Config::runtime().latest().patch_config(patch);
CoreManager::global().update_config().await?; CoreManager::global().update_config().await?;

64
src-tauri/src/lib.rs
View File

@ -2,6 +2,7 @@ mod cmd;
mod config; mod config;
mod core; mod core;
mod enhance; mod enhance;
mod error;
mod feat; mod feat;
mod module; mod module;
mod utils; mod utils;
@ -16,6 +17,7 @@ use tauri::AppHandle;
use tauri::Manager; use tauri::Manager;
use tauri_plugin_autostart::MacosLauncher; use tauri_plugin_autostart::MacosLauncher;
use tauri_plugin_deep_link::DeepLinkExt; use tauri_plugin_deep_link::DeepLinkExt;
use utils::logging::Type;
/// A global singleton handle to the application. /// A global singleton handle to the application.
pub struct AppHandleManager { pub struct AppHandleManager {
@ -119,13 +121,13 @@ pub fn run() {
#[cfg(any(target_os = "linux", all(debug_assertions, windows)))] #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
{ {
use tauri_plugin_deep_link::DeepLinkExt; use tauri_plugin_deep_link::DeepLinkExt;
log_err!(app.deep_link().register_all()); logging_error!(Type::System, true, app.deep_link().register_all());
} }
app.deep_link().on_open_url(|event| { app.deep_link().on_open_url(|event| {
tauri::async_runtime::spawn(async move { tauri::async_runtime::spawn(async move {
if let Some(url) = event.urls().first() { if let Some(url) = event.urls().first() {
log_err!(resolve_scheme(url.to_string()).await); logging_error!(Type::Setup, true, resolve_scheme(url.to_string()).await);
} }
}); });
}); });
@ -279,13 +281,25 @@ pub fn run() {
tauri::WindowEvent::Focused(true) => { tauri::WindowEvent::Focused(true) => {
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
{ {
log_err!(hotkey::Hotkey::global().register("CMD+Q", "quit")); logging_error!(
log_err!(hotkey::Hotkey::global().register("CMD+W", "hide")); Type::Hotkey,
true,
hotkey::Hotkey::global().register("CMD+Q", "quit")
);
logging_error!(
Type::Hotkey,
true,
hotkey::Hotkey::global().register("CMD+W", "hide")
);
} }
#[cfg(not(target_os = "macos"))] #[cfg(not(target_os = "macos"))]
{ {
log_err!(hotkey::Hotkey::global().register("Control+Q", "quit")); logging_error!(
Type::Hotkey,
true,
hotkey::Hotkey::global().register("Control+Q", "quit")
);
}; };
{ {
let is_enable_global_hotkey = Config::verge() let is_enable_global_hotkey = Config::verge()
@ -293,19 +307,31 @@ pub fn run() {
.enable_global_hotkey .enable_global_hotkey
.unwrap_or(true); .unwrap_or(true);
if !is_enable_global_hotkey { if !is_enable_global_hotkey {
log_err!(hotkey::Hotkey::global().init()) logging_error!(Type::Hotkey, true, hotkey::Hotkey::global().init())
} }
} }
} }
tauri::WindowEvent::Focused(false) => { tauri::WindowEvent::Focused(false) => {
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
{ {
log_err!(hotkey::Hotkey::global().unregister("CMD+Q")); logging_error!(
log_err!(hotkey::Hotkey::global().unregister("CMD+W")); Type::Hotkey,
true,
hotkey::Hotkey::global().unregister("CMD+Q")
);
logging_error!(
Type::Hotkey,
true,
hotkey::Hotkey::global().unregister("CMD+W")
);
} }
#[cfg(not(target_os = "macos"))] #[cfg(not(target_os = "macos"))]
{ {
log_err!(hotkey::Hotkey::global().unregister("Control+Q")); logging_error!(
Type::Hotkey,
true,
hotkey::Hotkey::global().unregister("Control+Q")
);
}; };
{ {
let is_enable_global_hotkey = Config::verge() let is_enable_global_hotkey = Config::verge()
@ -313,20 +339,32 @@ pub fn run() {
.enable_global_hotkey .enable_global_hotkey
.unwrap_or(true); .unwrap_or(true);
if !is_enable_global_hotkey { if !is_enable_global_hotkey {
log_err!(hotkey::Hotkey::global().reset()) logging_error!(Type::Hotkey, true, hotkey::Hotkey::global().reset())
} }
} }
} }
tauri::WindowEvent::Destroyed => { tauri::WindowEvent::Destroyed => {
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
{ {
log_err!(hotkey::Hotkey::global().unregister("CMD+Q")); logging_error!(
log_err!(hotkey::Hotkey::global().unregister("CMD+W")); Type::Hotkey,
true,
hotkey::Hotkey::global().unregister("CMD+Q")
);
logging_error!(
Type::Hotkey,
true,
hotkey::Hotkey::global().unregister("CMD+W")
);
} }
#[cfg(not(target_os = "macos"))] #[cfg(not(target_os = "macos"))]
{ {
log_err!(hotkey::Hotkey::global().unregister("Control+Q")); logging_error!(
Type::Hotkey,
true,
hotkey::Hotkey::global().unregister("Control+Q")
);
}; };
} }
_ => {} _ => {}

57
src-tauri/src/module/lightweight.rs
View File

@ -5,21 +5,21 @@ use tauri::{Listener, Manager};
use crate::{ use crate::{
config::Config, config::Config,
core::{handle, timer::Timer}, core::{handle, timer::Timer},
log_err, AppHandleManager, log_err, logging,
utils::logging::Type,
AppHandleManager,
}; };
const LIGHT_WEIGHT_TASK_UID: &str = "light_weight_task"; const LIGHT_WEIGHT_TASK_UID: &str = "light_weight_task";
pub fn enable_auto_light_weight_mode() { pub fn enable_auto_light_weight_mode() {
println!("[lightweight_mode] 开启自动轻量模式"); logging!(info, Type::Lightweight, True, "开启自动轻量模式");
log::info!(target: "app", "[lightweight_mode] 开启自动轻量模式");
setup_window_close_listener(); setup_window_close_listener();
setup_webview_focus_listener(); setup_webview_focus_listener();
} }
pub fn disable_auto_light_weight_mode() { pub fn disable_auto_light_weight_mode() {
println!("[lightweight_mode] 关闭自动轻量模式"); logging!(info, Type::Lightweight, True, "关闭自动轻量模式");
log::info!(target: "app", "[lightweight_mode] 关闭自动轻量模式");
let _ = cancel_light_weight_timer(); let _ = cancel_light_weight_timer();
cancel_window_close_listener(); cancel_window_close_listener();
} }
@ -34,8 +34,7 @@ pub fn entry_lightweight_mode() {
} }
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
AppHandleManager::global().set_activation_policy_accessory(); AppHandleManager::global().set_activation_policy_accessory();
println!("[lightweight_mode] 轻量模式已开启"); logging!(info, Type::Lightweight, True, "轻量模式已开启");
log::info!(target: "app", "[lightweight_mode] 轻量模式已开启");
} }
let _ = cancel_light_weight_timer(); let _ = cancel_light_weight_timer();
} }
@ -44,8 +43,12 @@ fn setup_window_close_listener() -> u32 {
if let Some(window) = handle::Handle::global().get_window() { if let Some(window) = handle::Handle::global().get_window() {
let handler = window.listen("tauri://close-requested", move |_event| { let handler = window.listen("tauri://close-requested", move |_event| {
let _ = setup_light_weight_timer(); let _ = setup_light_weight_timer();
println!("[lightweight_mode] 监听到关闭请求，开始轻量模式计时"); logging!(
log::info!(target: "app", "[lightweight_mode] 监听到关闭请求，开始轻量模式计时"); info,
Type::Lightweight,
True,
"监听到关闭请求，开始轻量模式计时"
);
}); });
return handler; return handler;
} }
@ -56,8 +59,12 @@ fn setup_webview_focus_listener() -> u32 {
if let Some(window) = handle::Handle::global().get_window() { if let Some(window) = handle::Handle::global().get_window() {
let handler = window.listen("tauri://focus", move |_event| { let handler = window.listen("tauri://focus", move |_event| {
log_err!(cancel_light_weight_timer()); log_err!(cancel_light_weight_timer());
println!("[lightweight_mode] 监听到窗口获得焦点，取消轻量模式计时"); logging!(
log::info!(target: "app", "[lightweight_mode] 监听到窗口获得焦点，取消轻量模式计时"); info,
Type::Lightweight,
True,
"监听到窗口获得焦点，取消轻量模式计时"
);
}); });
return handler; return handler;
} }
@ -67,8 +74,7 @@ fn setup_webview_focus_listener() -> u32 {
fn cancel_window_close_listener() { fn cancel_window_close_listener() {
if let Some(window) = handle::Handle::global().get_window() { if let Some(window) = handle::Handle::global().get_window() {
window.unlisten(setup_window_close_listener()); window.unlisten(setup_window_close_listener());
println!("[lightweight_mode] 取消了窗口关闭监听"); logging!(info, Type::Lightweight, True, "取消了窗口关闭监听");
log::info!(target: "app", "[lightweight_mode] 取消了窗口关闭监听");
} }
} }
@ -92,17 +98,14 @@ fn setup_light_weight_timer() -> Result<()> {
.set_maximum_parallel_runnable_num(1) .set_maximum_parallel_runnable_num(1)
.set_frequency_once_by_minutes(once_by_minutes) .set_frequency_once_by_minutes(once_by_minutes)
.spawn_async_routine(move || async move { .spawn_async_routine(move || async move {
println!("[lightweight_mode] 计时器到期，开始进入轻量模式"); logging!(info, Type::Timer, True, "计时器到期，开始进入轻量模式");
log::info!(target: "app",
"[lightweight_mode] 计时器到期，开始进入轻量模式"
);
entry_lightweight_mode(); entry_lightweight_mode();
}) })
.context("failed to create light weight timer task")?; .context("failed to create timer task")?;
delay_timer delay_timer
.add_task(task) .add_task(task)
.context("failed to add light weight timer task")?; .context("failed to add timer task")?;
let timer_task = crate::core::timer::TimerTask { let timer_task = crate::core::timer::TimerTask {
task_id, task_id,
@ -112,12 +115,11 @@ fn setup_light_weight_timer() -> Result<()> {
timer_map.insert(LIGHT_WEIGHT_TASK_UID.to_string(), timer_task); timer_map.insert(LIGHT_WEIGHT_TASK_UID.to_string(), timer_task);
println!( logging!(
"[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式", info,
once_by_minutes Type::Timer,
); True,
log::info!(target: "app", "计时器已设置，{} 分钟后将自动进入轻量模式",
"[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
once_by_minutes once_by_minutes
); );
@ -131,9 +133,8 @@ fn cancel_light_weight_timer() -> Result<()> {
if let Some(task) = timer_map.remove(LIGHT_WEIGHT_TASK_UID) { if let Some(task) = timer_map.remove(LIGHT_WEIGHT_TASK_UID) {
delay_timer delay_timer
.remove_task(task.task_id) .remove_task(task.task_id)
.context("failed to remove light weight timer task")?; .context("failed to remove timer task")?;
println!("[lightweight_mode] 轻量模式计时器已取消"); logging!(info, Type::Timer, True, "计时器已取消");
log::info!(target: "app", "[lightweight_mode] 轻量模式计时器已取消");
} }
Ok(()) Ok(())

22
src-tauri/src/utils/logging.rs
View File

@ -2,23 +2,37 @@ use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Type { pub enum Type {
Cmd,
Core, Core,
Config,
Setup,
System,
Service, Service,
Hotkey, Hotkey,
Window, Window,
Config, Tray,
CMD, Timer,
Frontend,
Backup,
Lightweight,
} }
impl fmt::Display for Type { impl fmt::Display for Type {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {
Type::Cmd => write!(f, "[Cmd]"),
Type::Core => write!(f, "[Core]"), Type::Core => write!(f, "[Core]"),
Type::Config => write!(f, "[Config]"),
Type::Setup => write!(f, "[Setup]"),
Type::System => write!(f, "[System]"),
Type::Service => write!(f, "[Service]"), Type::Service => write!(f, "[Service]"),
Type::Hotkey => write!(f, "[Hotkey]"), Type::Hotkey => write!(f, "[Hotkey]"),
Type::Window => write!(f, "[Window]"), Type::Window => write!(f, "[Window]"),
Type::Config => write!(f, "[Config]"), Type::Tray => write!(f, "[Tray]"),
Type::CMD => write!(f, "[CMD]"), Type::Timer => write!(f, "[Timer]"),
Type::Frontend => write!(f, "[Frontend]"),
Type::Backup => write!(f, "[Backup]"),
Type::Lightweight => write!(f, "[Lightweight]"),
} }
} }
} }

60
src-tauri/src/utils/resolve.rs
View File

@ -3,7 +3,7 @@ use crate::AppHandleManager;
use crate::{ use crate::{
config::{Config, IVerge, PrfItem}, config::{Config, IVerge, PrfItem},
core::*, core::*,
log_err, logging, logging, logging_error,
module::lightweight, module::lightweight,
utils::{error, init, logging::Type, server}, utils::{error, init, logging::Type, server},
wrap_err, wrap_err,
@ -51,15 +51,15 @@ pub async fn resolve_setup(app: &mut App) {
handle::Handle::global().init(app.app_handle()); handle::Handle::global().init(app.app_handle());
VERSION.get_or_init(|| version.clone()); VERSION.get_or_init(|| version.clone());
log_err!(init::init_config()); logging_error!(Type::Config, true, init::init_config());
log_err!(init::init_resources()); logging_error!(Type::Setup, true, init::init_resources());
log_err!(init::init_scheme()); logging_error!(Type::Setup, true, init::init_scheme());
log_err!(init::startup_script().await); logging_error!(Type::Setup, true, init::startup_script().await);
// 处理随机端口 // 处理随机端口
log_err!(resolve_random_port_config()); logging_error!(Type::System, true, resolve_random_port_config());
// 启动核心 // 启动核心
log::trace!(target:"app", "init config"); logging!(trace, Type::Config, true, "Initial config");
log_err!(Config::init_config().await); logging_error!(Type::Config, true, Config::init_config().await);
// if service::check_service().await.is_err() { // if service::check_service().await.is_err() {
// match service::install_service().await { // match service::install_service().await {
@ -90,31 +90,39 @@ pub async fn resolve_setup(app: &mut App) {
// } // }
// } // }
log::trace!(target: "app", "launch core"); logging!(trace, Type::Core, "Starting CoreManager");
log_err!(CoreManager::global().init().await); logging_error!(Type::Core, true, CoreManager::global().init().await);
// setup a simple http server for singleton // setup a simple http server for singleton
log::trace!(target: "app", "launch embed server"); log::trace!(target: "app", "launch embed server");
server::embed_server(); server::embed_server();
log::trace!(target: "app", "init system tray"); log::trace!(target: "app", "Initial system tray");
log_err!(tray::Tray::global().init()); logging_error!(Type::Tray, true, tray::Tray::global().init());
log_err!(tray::Tray::global().create_systray(app)); logging_error!(Type::Tray, true, tray::Tray::global().create_systray(app));
log_err!(sysopt::Sysopt::global().update_sysproxy().await); logging_error!(
log_err!(sysopt::Sysopt::global().init_guard_sysproxy()); Type::System,
true,
sysopt::Sysopt::global().update_sysproxy().await
);
logging_error!(
Type::System,
true,
sysopt::Sysopt::global().init_guard_sysproxy()
);
// 初始化热键 // 初始化热键
log::trace!(target: "app", "init hotkeys"); logging!(trace, Type::System, true, "Initial hotkeys");
log_err!(hotkey::Hotkey::global().init()); logging_error!(Type::System, true, hotkey::Hotkey::global().init());
let silent_start = { Config::verge().data().enable_silent_start }; let silent_start = { Config::verge().data().enable_silent_start };
if !silent_start.unwrap_or(false) { if !silent_start.unwrap_or(false) {
create_window(); create_window();
} }
log_err!(tray::Tray::global().update_part()); logging_error!(Type::Tray, true, tray::Tray::global().update_part());
log_err!(timer::Timer::global().init()); logging_error!(Type::System, true, timer::Timer::global().init());
let enable_auto_light_weight_mode = { Config::verge().data().enable_auto_light_weight_mode }; let enable_auto_light_weight_mode = { Config::verge().data().enable_auto_light_weight_mode };
if enable_auto_light_weight_mode.unwrap_or(false) { if enable_auto_light_weight_mode.unwrap_or(false) {
@ -126,12 +134,20 @@ pub async fn resolve_setup(app: &mut App) {
pub fn resolve_reset() { pub fn resolve_reset() {
tauri::async_runtime::block_on(async move { tauri::async_runtime::block_on(async move {
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
logging!(info, Type::Tray, true, "Unsubscribing from traffic updates");
tray::Tray::global().unsubscribe_traffic(); tray::Tray::global().unsubscribe_traffic();
log_err!(sysopt::Sysopt::global().reset_sysproxy().await); logging_error!(
log_err!(CoreManager::global().stop_core().await); Type::System,
true,
sysopt::Sysopt::global().reset_sysproxy().await
);
logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
restore_public_dns().await; {
logging!(info, Type::System, true, "Restoring system DNS settings");
restore_public_dns().await;
}
}); });
} }

9
src-tauri/src/utils/server.rs
View File

@ -3,7 +3,8 @@ extern crate warp;
use super::resolve; use super::resolve;
use crate::{ use crate::{
config::{Config, IVerge, DEFAULT_PAC}, config::{Config, IVerge, DEFAULT_PAC},
log_err, logging_error,
utils::logging::Type,
}; };
use anyhow::{bail, Result}; use anyhow::{bail, Result};
use port_scanner::local_port_available; use port_scanner::local_port_available;
@ -69,7 +70,11 @@ pub fn embed_server() {
.unwrap_or_default() .unwrap_or_default()
}); });
async fn scheme_handler(query: QueryParam) -> Result<impl warp::Reply, Infallible> { async fn scheme_handler(query: QueryParam) -> Result<impl warp::Reply, Infallible> {
log_err!(resolve::resolve_scheme(query.param).await); logging_error!(
Type::Setup,
true,
resolve::resolve_scheme(query.param).await
);
Ok("ok") Ok("ok")
} }