refactor: streamline SWR configuration and improve error handling in AppDataProvider

src-tauri/src/core/manager/config.rs

@@ -0,0 +1,152 @@
+use super::CoreManager;
+use crate::{
+    config::*,
+    constants::timing,
+    core::{handle, validate::CoreConfigValidator},
+    logging,
+    utils::{dirs, help, logging::Type},
+};
+use anyhow::{Result, anyhow};
+use std::{path::PathBuf, time::Instant};
+use tauri_plugin_mihomo::Error as MihomoError;
+use tokio::time::sleep;
+
+impl CoreManager {
+    pub async fn use_default_config(&self, error_key: &str, error_msg: &str) -> Result<()> {
+        use crate::constants::files::RUNTIME_CONFIG;
+        
+        let runtime_path = dirs::app_home_dir()?.join(RUNTIME_CONFIG);
+        let clash_config = Config::clash().await.latest_ref().0.clone();
+
+        *Config::runtime().await.draft_mut() = Box::new(IRuntime {
+            config: Some(clash_config.clone()),
+            exists_keys: vec![],
+            chain_logs: Default::default(),
+        });
+        
+        help::save_yaml(&runtime_path, &clash_config, Some("# Clash Verge Runtime")).await?;
+        handle::Handle::notice_message(error_key, error_msg);
+        Ok(())
+    }
+
+    pub async fn update_config(&self) -> Result<(bool, String)> {
+        if handle::Handle::global().is_exiting() {
+            return Ok((true, String::new()));
+        }
+
+        if !self.should_update_config()? {
+            return Ok((true, String::new()));
+        }
+
+        let _permit = self.update_semaphore.try_acquire()
+            .map_err(|_| anyhow!("Config update already in progress"))?;
+
+        self.perform_config_update().await
+    }
+
+    fn should_update_config(&self) -> Result<bool> {
+        let now = Instant::now();
+        let mut last = self.last_update.lock();
+        
+        if let Some(last_time) = *last {
+            if now.duration_since(last_time) < timing::CONFIG_UPDATE_DEBOUNCE {
+                return Ok(false);
+            }
+        }
+        
+        *last = Some(now);
+        Ok(true)
+    }
+
+    async fn perform_config_update(&self) -> Result<(bool, String)> {
+        Config::generate().await?;
+
+        match CoreConfigValidator::global().validate_config().await {
+            Ok((true, _)) => {
+                let run_path = Config::generate_file(ConfigType::Run).await?;
+                self.apply_config(run_path).await?;
+                Ok((true, String::new()))
+            }
+            Ok((false, error_msg)) => {
+                Config::runtime().await.discard();
+                Ok((false, error_msg))
+            }
+            Err(e) => {
+                Config::runtime().await.discard();
+                Err(e)
+            }
+        }
+    }
+
+    pub async fn put_configs_force(&self, path: PathBuf) -> Result<()> {
+        self.apply_config(path).await
+    }
+
+    pub(super) async fn apply_config(&self, path: PathBuf) -> Result<()> {
+        let path_str = dirs::path_to_str(&path)?;
+        
+        match self.reload_config(path_str).await {
+            Ok(_) => {
+                Config::runtime().await.apply();
+                logging!(info, Type::Core, "Configuration applied");
+                Ok(())
+            }
+            Err(err) if Self::should_restart_on_error(&err) => {
+                self.retry_with_restart(path_str).await
+            }
+            Err(err) => {
+                Config::runtime().await.discard();
+                Err(anyhow!("Failed to apply config: {}", err))
+            }
+        }
+    }
+
+    async fn retry_with_restart(&self, config_path: &str) -> Result<()> {
+        if handle::Handle::global().is_exiting() {
+            return Err(anyhow!("Application exiting"));
+        }
+
+        logging!(warn, Type::Core, "Restarting core for config reload");
+        self.restart_core().await?;
+        sleep(timing::CONFIG_RELOAD_DELAY).await;
+
+        self.reload_config(config_path).await?;
+        Config::runtime().await.apply();
+        logging!(info, Type::Core, "Configuration applied after restart");
+        Ok(())
+    }
+
+    async fn reload_config(&self, path: &str) -> Result<(), MihomoError> {
+        handle::Handle::mihomo().await.reload_config(true, path).await
+    }
+
+    fn should_restart_on_error(err: &MihomoError) -> bool {
+        match err {
+            MihomoError::ConnectionFailed | MihomoError::ConnectionLost => true,
+            MihomoError::Io(io_err) => Self::is_connection_io_error(io_err.kind()),
+            MihomoError::Reqwest(req_err) => {
+                req_err.is_connect() 
+                    || req_err.is_timeout()
+                    || Self::contains_error_pattern(&req_err.to_string())
+            }
+            MihomoError::FailedResponse(msg) => Self::contains_error_pattern(msg),
+            _ => false,
+        }
+    }
+
+    fn is_connection_io_error(kind: std::io::ErrorKind) -> bool {
+        matches!(
+            kind,
+            std::io::ErrorKind::ConnectionAborted
+                | std::io::ErrorKind::ConnectionRefused
+                | std::io::ErrorKind::ConnectionReset
+                | std::io::ErrorKind::NotFound
+        )
+    }
+
+    fn contains_error_pattern(text: &str) -> bool {
+        use crate::constants::error_patterns::CONNECTION_ERRORS;
+        CONNECTION_ERRORS.iter().any(|p| text.contains(p))
+    }
+}
+