From 2db27b5ffdcf231b87b5e01181cd3984e6db0ea2 Mon Sep 17 00:00:00 2001 From: zhom <2717306+zhom@users.noreply.github.com> Date: Tue, 17 Jun 2025 17:52:28 +0400 Subject: [PATCH] refactor: only use is_browser_version_nightly for release checks --- src-tauri/src/auto_updater.rs | 121 ++++++++++++++---------- src-tauri/src/version_updater.rs | 155 ++++++++++++------------------- 2 files changed, 129 insertions(+), 147 deletions(-) diff --git a/src-tauri/src/auto_updater.rs b/src-tauri/src/auto_updater.rs index d2bb408..0af246c 100644 --- a/src-tauri/src/auto_updater.rs +++ b/src-tauri/src/auto_updater.rs @@ -1,3 +1,4 @@ +use crate::api_client::is_browser_version_nightly; use crate::browser_runner::{BrowserProfile, BrowserRunner}; use crate::browser_version_service::{BrowserVersionInfo, BrowserVersionService}; use crate::settings_manager::SettingsManager; @@ -101,16 +102,19 @@ impl AutoUpdater { // Apply chromium threshold logic if browser == "chromium" { // For chromium, only show notifications if there are 50+ new versions - // Count how many versions are newer than the current profile version - let newer_versions_count = versions - .iter() - .filter(|v| self.is_version_newer(&v.version, &profile.version)) - .count(); + let current_version = &profile.version.parse::().unwrap(); + let new_version = &update.new_version.parse::().unwrap(); - if newer_versions_count >= 50 { + let result = new_version - current_version; + println!( + "Current version: {current_version}, New version: {new_version}, Result: {result}" + ); + if result > 50 { notifications.push(update); } else { - println!("Skipping chromium update notification: only {newer_versions_count} new versions (need 50+)"); + println!( + "Skipping chromium update notification: only {result} new versions (need 50+)" + ); } } else { notifications.push(update); @@ -123,6 +127,8 @@ impl AutoUpdater { } pub async fn check_for_updates_with_progress(&self, app_handle: &tauri::AppHandle) { + println!("Starting auto-update check with progress..."); + // Check for browser updates and trigger auto-downloads match self.check_for_updates().await { Ok(update_notifications) => { @@ -139,22 +145,63 @@ impl AutoUpdater { notification.browser, notification.new_version ); - // Emit a custom event to trigger auto-download - let auto_update_event = serde_json::json!({ - "browser": notification.browser, - "new_version": notification.new_version, - "notification_id": notification.id, - "affected_profiles": notification.affected_profiles - }); + // Clone app_handle for the async task + let app_handle_clone = app_handle.clone(); + let browser = notification.browser.clone(); + let new_version = notification.new_version.clone(); + let notification_id = notification.id.clone(); + let affected_profiles = notification.affected_profiles.clone(); - if let Err(e) = app_handle.emit("browser-auto-update-available", &auto_update_event) { - eprintln!( - "Failed to emit auto-update event for {}: {e}", - notification.browser - ); - } else { - println!("Emitted auto-update event for {}", notification.browser); - } + // Spawn async task to handle the download and auto-update + tokio::spawn(async move { + // First, check if browser already exists + match crate::browser_runner::is_browser_downloaded( + browser.clone(), + new_version.clone(), + ) { + true => { + println!("Browser {browser} {new_version} already downloaded, proceeding to auto-update profiles"); + + // Browser already exists, go straight to profile update + match crate::auto_updater::complete_browser_update_with_auto_update( + browser.clone(), + new_version.clone(), + ) + .await + { + Ok(updated_profiles) => { + println!( + "Auto-update completed for {} profiles: {:?}", + updated_profiles.len(), + updated_profiles + ); + } + Err(e) => { + eprintln!("Failed to complete auto-update for {browser}: {e}"); + } + } + } + false => { + println!("Downloading browser {browser} version {new_version}..."); + + // Emit the auto-update event to trigger frontend handling + let auto_update_event = serde_json::json!({ + "browser": browser, + "new_version": new_version, + "notification_id": notification_id, + "affected_profiles": affected_profiles + }); + + if let Err(e) = + app_handle_clone.emit("browser-auto-update-available", &auto_update_event) + { + eprintln!("Failed to emit auto-update event for {browser}: {e}"); + } else { + println!("Emitted auto-update event for {browser}"); + } + } + } + }); } } else { println!("No browser updates needed"); @@ -173,16 +220,15 @@ impl AutoUpdater { available_versions: &[BrowserVersionInfo], ) -> Result, Box> { let current_version = &profile.version; - let is_current_stable = !self.is_nightly_version(current_version); + let is_current_nightly = is_browser_version_nightly(&profile.browser, current_version, None); // Find the best available update let best_update = available_versions .iter() .filter(|v| { // Only consider versions newer than current - self.is_version_newer(&v.version, current_version) && - // Respect version type preference - is_current_stable != v.is_prerelease + self.is_version_newer(&v.version, current_version) + && is_browser_version_nightly(&profile.browser, &v.version, None) == is_current_nightly }) .max_by(|a, b| self.compare_versions(&a.version, &b.version)); @@ -367,14 +413,6 @@ impl AutoUpdater { Ok(()) } - // Helper methods - - fn is_nightly_version(&self, version: &str) -> bool { - // Use the centralized nightly detection function - // Since we don't have browser context here, use the general fallback - crate::api_client::is_nightly_version(version) - } - fn is_version_newer(&self, version1: &str, version2: &str) -> bool { self.compare_versions(version1, version2) == std::cmp::Ordering::Greater } @@ -502,21 +540,6 @@ mod tests { } } - #[test] - fn test_is_nightly_version() { - let updater = AutoUpdater::new(); - - assert!(updater.is_nightly_version("1.0.0-alpha")); - assert!(updater.is_nightly_version("1.0.0-beta")); - assert!(updater.is_nightly_version("1.0.0-rc")); - assert!(updater.is_nightly_version("1.0.0a1")); - assert!(updater.is_nightly_version("1.0.0b1")); - assert!(updater.is_nightly_version("1.0.0-dev")); - - assert!(!updater.is_nightly_version("1.0.0")); - assert!(!updater.is_nightly_version("1.2.3")); - } - #[test] fn test_compare_versions() { let updater = AutoUpdater::new(); diff --git a/src-tauri/src/version_updater.rs b/src-tauri/src/version_updater.rs index 5f2e7f3..fa673bb 100644 --- a/src-tauri/src/version_updater.rs +++ b/src-tauri/src/version_updater.rs @@ -263,149 +263,108 @@ impl VersionUpdater { &self, app_handle: &tauri::AppHandle, ) -> Result, Box> { - println!("Starting background version update for all browsers"); - - let all_browsers = [ - "firefox", - "firefox-developer", - "mullvad-browser", - "zen", - "brave", - "chromium", - "tor-browser", - ]; - - // Filter browsers to only include those supported on the current platform - let browsers: Vec<&str> = all_browsers - .iter() - .filter(|browser| { - self - .version_service - .is_browser_supported(browser) - .unwrap_or(false) - }) - .copied() - .collect(); - - let total_browsers = browsers.len(); + let supported_browsers = self.version_service.get_supported_browsers(); + let total_browsers = supported_browsers.len(); let mut results = Vec::new(); let mut total_new_versions = 0; - println!( - "Updating {} supported browsers (filtered from {} total)", - browsers.len(), - all_browsers.len() - ); - - // Emit start event - let progress = VersionUpdateProgress { - current_browser: "".to_string(), + // Emit initial progress + let initial_progress = VersionUpdateProgress { + current_browser: String::new(), total_browsers, completed_browsers: 0, new_versions_found: 0, browser_new_versions: 0, status: "updating".to_string(), }; - if let Err(e) = app_handle.emit("version-update-progress", &progress) { - eprintln!("Failed to emit start progress: {e}"); - } else { - println!("Emitted start progress event"); + + if let Err(e) = app_handle.emit("version-update-progress", &initial_progress) { + eprintln!("Failed to emit initial progress: {e}"); } - for (index, browser) in browsers.iter().enumerate() { - println!( - "Processing browser {} ({}/{}): {}", - browser, - index + 1, - total_browsers, - browser - ); + for (index, browser) in supported_browsers.iter().enumerate() { + println!("Updating browser versions for: {browser}"); - // Emit progress for current browser + // Emit progress update for current browser let progress = VersionUpdateProgress { - current_browser: browser.to_string(), + current_browser: browser.clone(), total_browsers, completed_browsers: index, new_versions_found: total_new_versions, browser_new_versions: 0, status: "updating".to_string(), }; + if let Err(e) = app_handle.emit("version-update-progress", &progress) { eprintln!("Failed to emit progress for {browser}: {e}"); - } else { - println!("Emitted progress event for browser: {browser}"); } - if !self.version_service.should_update_cache(browser) { - println!("Skipping {browser} - cache is still fresh"); - - let browser_result = BackgroundUpdateResult { - browser: browser.to_string(), - new_versions_count: 0, - total_versions_count: 0, - updated_successfully: true, - error: None, - }; - results.push(browser_result); - continue; - } - - println!("Fetching new versions for browser: {browser}"); - - let result = self.update_browser_versions(browser).await; - - match result { - Ok(new_count) => { - total_new_versions += new_count; - let browser_result = BackgroundUpdateResult { - browser: browser.to_string(), - new_versions_count: new_count, - total_versions_count: 0, // We'll update this if needed + match self.update_browser_versions(browser).await { + Ok(new_versions_count) => { + results.push(BackgroundUpdateResult { + browser: browser.clone(), + new_versions_count, + total_versions_count: 0, // We don't track total for background updates updated_successfully: true, error: None, - }; - results.push(browser_result); + }); - println!("Found {new_count} new versions for {browser}"); + total_new_versions += new_versions_count; + + // Emit progress update with new versions found + let progress = VersionUpdateProgress { + current_browser: browser.clone(), + total_browsers, + completed_browsers: index, + new_versions_found: total_new_versions, + browser_new_versions: new_versions_count, + status: "updating".to_string(), + }; + + if let Err(e) = app_handle.emit("version-update-progress", &progress) { + eprintln!("Failed to emit progress with versions for {browser}: {e}"); + } } Err(e) => { - eprintln!("Failed to update versions for {browser}: {e}"); - let browser_result = BackgroundUpdateResult { - browser: browser.to_string(), + results.push(BackgroundUpdateResult { + browser: browser.clone(), new_versions_count: 0, total_versions_count: 0, updated_successfully: false, error: Some(e.to_string()), - }; - results.push(browser_result); + }); } } - - // Small delay between browsers to avoid overwhelming APIs - tokio::time::sleep(Duration::from_millis(200)).await; } - self - .auto_updater - .check_for_updates_with_progress(app_handle) - .await; - - // Emit completion event - let progress = VersionUpdateProgress { - current_browser: "".to_string(), + // Emit completion + let final_progress = VersionUpdateProgress { + current_browser: String::new(), total_browsers, completed_browsers: total_browsers, new_versions_found: total_new_versions, browser_new_versions: 0, status: "completed".to_string(), }; - if let Err(e) = app_handle.emit("version-update-progress", &progress) { + + if let Err(e) = app_handle.emit("version-update-progress", &final_progress) { eprintln!("Failed to emit completion progress: {e}"); - } else { - println!("Emitted completion progress event"); } - println!("Version update completed. Found {total_new_versions} new versions total"); + // After all version updates are complete, trigger auto-update check + if total_new_versions > 0 { + println!( + "Found {total_new_versions} new versions across all browsers. Checking for auto-updates..." + ); + + // Trigger auto-update check which will automatically download browsers + self + .auto_updater + .check_for_updates_with_progress(app_handle) + .await; + } else { + println!("No new versions found, skipping auto-update check"); + } Ok(results) }