refactor: retry with backoff

src-tauri/src/core/core.rs

@@ -17,12 +17,23 @@ use crate::{
     },
 };
 use anyhow::{Result, anyhow};
+use backoff::backoff::Backoff;
+use backoff::{Error as BackoffError, ExponentialBackoff};
 use compact_str::CompactString;
 use flexi_logger::DeferredNow;
 use log::Level;
 use parking_lot::Mutex;
 use std::collections::VecDeque;
-use std::{error::Error, fmt, path::PathBuf, sync::Arc, time::Duration};
+use std::{
+    error::Error,
+    fmt,
+    path::PathBuf,
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::{Duration, Instant},
+};
 use tauri_plugin_mihomo::Error as MihomoError;
 use tauri_plugin_shell::ShellExt;
 use tokio::time::sleep;
@@ -956,10 +967,25 @@ impl CoreManager {
             return;
         }
 
-        const MAX_ATTEMPTS: usize = 15;
+        let max_wait = Duration::from_millis(3000);
-        const WAIT_INTERVAL_MS: u64 = 200;
+        let mut backoff_strategy = ExponentialBackoff {
+            initial_interval: Duration::from_millis(200),
+            max_interval: Duration::from_millis(200),
+            max_elapsed_time: Some(max_wait),
+            multiplier: 1.0,
+            randomization_factor: 0.0,
+            ..Default::default()
+        };
+        backoff_strategy.reset();
 
-        for attempt in 0..MAX_ATTEMPTS {
+        let attempts = Arc::new(AtomicUsize::new(0));
+        let attempts_for_retry = Arc::clone(&attempts);
+
+        let operation = || {
+            let attempts = Arc::clone(&attempts_for_retry);
+
+            async move {
+                let attempt = attempts.fetch_add(1, Ordering::Relaxed);
                 let mut manager = SERVICE_MANAGER.lock().await;
 
                 if matches!(manager.current(), ServiceStatus::Ready) {
@@ -968,10 +994,10 @@ impl CoreManager {
                             info,
                             Type::Core,
                             "Service became ready for TUN after {} attempt(s)",
-                        attempt
+                            attempt + 1
                         );
                     }
-                return;
+                    return Ok(());
                 }
 
                 if attempt == 0 {
@@ -994,6 +1020,7 @@ impl CoreManager {
                             attempt + 1,
                             err
                         );
+                        return Err(BackoffError::transient(err));
                     }
                 }
 
@@ -1004,23 +1031,33 @@ impl CoreManager {
                         "Service became ready for TUN after {} attempt(s)",
                         attempt + 1
                     );
-                return;
+                    return Ok(());
                 }
 
-            drop(manager);
+                logging!(
+                    debug,
+                    Type::Core,
+                    "Service not ready after attempt {}; retrying with backoff",
+                    attempt + 1
+                );
 
-            if attempt + 1 == MAX_ATTEMPTS {
+                Err(BackoffError::transient(anyhow!("Service not ready yet")))
-                let total_wait_ms = (MAX_ATTEMPTS as u64) * WAIT_INTERVAL_MS;
+            }
+        };
+
+        let wait_started = Instant::now();
+
+        if let Err(err) = backoff::future::retry(backoff_strategy, operation).await {
+            let total_attempts = attempts.load(Ordering::Relaxed);
+            let waited_ms = wait_started.elapsed().as_millis();
             logging!(
                 warn,
                 Type::Core,
-                    "Service still not ready after waiting approximately {} ms; falling back to sidecar mode",
+                "Service still not ready after waiting approximately {} ms ({} attempt(s)); falling back to sidecar mode: {}",
-                    total_wait_ms
+                waited_ms,
+                total_attempts,
+                err
             );
-                break;
-            }
-
-            sleep(Duration::from_millis(WAIT_INTERVAL_MS)).await;
         }
     }