feat: maintain automatic node pool

Author: DiscoverBox

src-tauri/src/core.rs

@@ -190,21 +190,25 @@ pub fn choose_node<'a>(nodes: &'a [(NodeDefinition, HealthSummary)]) -> Option<&
     let mut candidates: Vec<_> = nodes
         .iter()
         .filter(|(node, health)| {
-            node.enabled && matches!(health.status, NodeStatus::Available | NodeStatus::Slow)
+            node.enabled
+                && health.in_auto_pool
+                && matches!(health.status, NodeStatus::Available | NodeStatus::Slow)
         })
         .collect();
-    candidates.sort_by_key(|(_, health)| {
-        let failure_penalty = u64::from(health.consecutive_failures) * 100_000;
-        let success_rate_penalty = if health.attempt_count == 0 {
-            100_000
-        } else {
-            100_000 - (u64::from(health.success_count) * 100_000 / u64::from(health.attempt_count))
-        };
-        failure_penalty + success_rate_penalty + health.median_latency_ms.unwrap_or(u64::MAX / 4)
-    });
+    candidates.sort_by_key(|(_, health)| health_score(health));
     candidates.first().map(|(node, _)| node)
 }
 
+pub fn health_score(health: &HealthSummary) -> u64 {
+    let failure_penalty = u64::from(health.consecutive_failures) * 100_000;
+    let success_rate_penalty = if health.attempt_count == 0 {
+        100_000
+    } else {
+        100_000 - (u64::from(health.success_count) * 100_000 / u64::from(health.attempt_count))
+    };
+    failure_penalty + success_rate_penalty + health.median_latency_ms.unwrap_or(u64::MAX / 4)
+}
+
 pub fn build_config(
     settings: &Settings,
     node: Option<&NodeDefinition>,

src-tauri/src/git.rs

@@ -9,7 +9,7 @@ mod usage;
 use crate::{core::AppCore, models::*};
 use std::{
     path::{Path, PathBuf},
-    sync::atomic::{AtomicU64, Ordering},
+    sync::atomic::{AtomicBool, AtomicU64, Ordering},
     time::{Duration, Instant},
 };
 use tauri::{
@@ -80,7 +80,25 @@ where
 }
 
 fn emit_node_test_progress(app: &tauri::AppHandle, completed: usize, total: usize) {
-    let _ = app.emit("node-test-progress", NodeTestProgress { completed, total });
+    let _ = app.emit(
+        "node-test-progress",
+        NodeTestProgress {
+            completed,
+            total,
+            finished: false,
+        },
+    );
+}
+
+fn emit_node_test_finished(app: &tauri::AppHandle) {
+    let _ = app.emit(
+        "node-test-progress",
+        NodeTestProgress {
+            completed: 0,
+            total: 0,
+            finished: true,
+        },
+    );
 }
 
 #[tauri::command]
@@ -122,23 +140,18 @@ async fn test_all_nodes(app: tauri::AppHandle) -> CommandResult<Vec<NodeEntry>>
                 emit_node_test_progress(&progress_app, completed, total);
             })
     })
-    .await?;
+    .await;
+    emit_node_test_finished(&app);
+    let result = result?;
     refresh_tray_from_core(&app);
     Ok(result)
 }
 
 #[tauri::command]
 async fn refresh_system_nodes(app: tauri::AppHandle) -> CommandResult<bool> {
-    let progress_app = app.clone();
     let worker_app = app.clone();
-    let result = run_node_test(move || {
-        worker_app
-            .state::<AppCore>()
-            .refresh_system_nodes_with_progress(|completed, total| {
-                emit_node_test_progress(&progress_app, completed, total);
-            })
-    })
-    .await?;
+    let result =
+        run_node_test(move || worker_app.state::<AppCore>().refresh_system_nodes()).await?;
     refresh_tray_from_core(&app);
     Ok(result)
 }
@@ -347,6 +360,7 @@ fn install_tray(app: &tauri::App) -> tauri::Result<()> {
                         .test_all_nodes_or_join_with_progress(|completed, total| {
                             emit_node_test_progress(&handle, completed, total)
                         });
+                    emit_node_test_finished(&handle);
                     match result {
                         Ok(_) => {
                             if let Ok(state) = handle.state::<AppCore>().snapshot() {
@@ -372,33 +386,45 @@ fn install_tray(app: &tauri::App) -> tauri::Result<()> {
 fn start_health_monitor(app: tauri::AppHandle) {
     tauri::async_runtime::spawn(async move {
         let mut last_check = Instant::now();
+        let mut initial_discovery_pending = true;
         loop {
             tokio::time::sleep(Duration::from_secs(60)).await;
-            let minutes = app
-                .state::<AppCore>()
+            let core = app.state::<AppCore>();
+            let minutes = core
                 .snapshot()
                 .map(|state| state.settings.health_check_minutes)
                 .unwrap_or(0);
-            if minutes == 0 || last_check.elapsed() < Duration::from_secs(u64::from(minutes) * 60) {
+            let needs_initial_discovery = initial_discovery_pending
+                && core.needs_background_node_discovery().unwrap_or(false);
+            if !health_check_due(minutes, last_check.elapsed(), needs_initial_discovery) {
                 continue;
             }
-            last_check = Instant::now();
             let handle = app.clone();
-            let _ = tauri::async_runtime::spawn_blocking(move || {
-                if handle
+            let succeeded = tauri::async_runtime::spawn_blocking(move || {
+                let started = AtomicBool::new(false);
+                let result = handle
                     .state::<AppCore>()
-                    .test_all_nodes_with_progress(|completed, total| {
+                    .test_background_nodes_with_progress(|completed, total| {
+                        started.store(true, Ordering::Relaxed);
                         emit_node_test_progress(&handle, completed, total);
-                    })
-                    .is_ok()
-                {
+                    });
+                if started.load(Ordering::Relaxed) {
+                    emit_node_test_finished(&handle);
+                }
+                if result.is_ok() {
                     if let Ok(state) = handle.state::<AppCore>().snapshot() {
                         refresh_tray(&handle, &state);
                         let _ = handle.emit("snapshot-updated", state);
                     }
                 }
+                result.is_ok()
             })
-            .await;
+            .await
+            .unwrap_or(false);
+            if succeeded {
+                last_check = Instant::now();
+                initial_discovery_pending = false;
+            }
         }
     });
 }
@@ -409,9 +435,7 @@ fn start_system_node_monitor(app: tauri::AppHandle) {
             let handle = app.clone();
             let _ = tauri::async_runtime::spawn_blocking(move || {
                 let core = handle.state::<AppCore>();
-                if let Err(error) = core.refresh_system_nodes_with_progress(|completed, total| {
-                    emit_node_test_progress(&handle, completed, total);
-                }) {
+                if let Err(error) = core.refresh_system_nodes() {
                     core.system_node_refresh_failed(&error);
                 }
                 if let Ok(state) = core.snapshot() {
@@ -425,6 +449,11 @@ fn start_system_node_monitor(app: tauri::AppHandle) {
     });
 }
 
+fn health_check_due(minutes: u32, elapsed: Duration, needs_initial_discovery: bool) -> bool {
+    minutes != 0
+        && (needs_initial_discovery || elapsed >= Duration::from_secs(u64::from(minutes) * 60))
+}
+
 pub fn run() {
     let autostart = tauri_plugin_autostart::Builder::new();
     #[cfg(target_os = "macos")]
@@ -488,8 +517,9 @@ pub fn run() {
 
 #[cfg(test)]
 mod tests {
-    use super::{run_node_test, tray_labels};
+    use super::{health_check_due, run_node_test, tray_labels};
     use crate::models::{HealthSummary, NodeDefinition, NodeEntry, Settings};
+    use std::time::Duration;
 
     #[test]
     fn node_tests_run_off_the_calling_thread() {
@@ -529,4 +559,20 @@ mod tests {
             ("当前线路：GitHub 直连".into(), "开启加速")
         );
     }
+
+    #[test]
+    fn health_check_schedule_honors_interval_and_disabled_setting() {
+        assert!(!health_check_due(0, Duration::from_secs(86_400), true));
+        assert!(!health_check_due(
+            24 * 60,
+            Duration::from_secs(6 * 60 * 60),
+            false
+        ));
+        assert!(health_check_due(
+            8 * 60,
+            Duration::from_secs(8 * 60 * 60),
+            false
+        ));
+        assert!(health_check_due(24 * 60, Duration::from_secs(60), true));
+    }
 }

src-tauri/src/lib.rs

@@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize};
 pub const SCHEMA_VERSION: u32 = 1;
 pub const FASTGIT_REWRITE_BASE: &str = "https://fastgit.cc/https://github.com/";
 pub const TEST_REPOSITORY: &str = "https://github.com/octocat/Hello-World.git";
+pub const DEFAULT_HEALTH_CHECK_MINUTES: u32 = 8 * 60;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -35,7 +36,7 @@ impl Default for Settings {
             line_mode: LineMode::Automatic,
             fixed_node_id: None,
             current_node_id: None,
-            health_check_minutes: 30,
+            health_check_minutes: DEFAULT_HEALTH_CHECK_MINUTES,
             launch_at_login: false,
             log_level: "info".into(),
             usage_logging_enabled: true,
@@ -96,6 +97,7 @@ impl NodeDefinition {
 #[serde(rename_all = "camelCase")]
 pub struct HealthSummary {
     pub status: NodeStatus,
+    pub in_auto_pool: bool,
     pub success_count: u32,
     pub attempt_count: u32,
     pub median_latency_ms: Option<u64>,
@@ -110,6 +112,7 @@ impl Default for HealthSummary {
     fn default() -> Self {
         Self {
             status: NodeStatus::Untested,
+            in_auto_pool: false,
             success_count: 0,
             attempt_count: 0,
             median_latency_ms: None,
@@ -134,6 +137,7 @@ pub struct NodeEntry {
 pub struct NodeTestProgress {
     pub completed: usize,
     pub total: usize,
+    pub finished: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]