From f03d0a20bdbae9705ec8a116bd3b5dd446933289 Mon Sep 17 00:00:00 2001 From: raykholo Date: Thu, 29 Oct 2026 13:29:43 +0000 Subject: [PATCH] Update now installs the newest release, checked when pressed (#7724) (#7725) * claim: #7724 * Update now installs the newest release, checked when pressed (#7724) * Update: close the unmanaged-install test after the rebase (#7724) * Update: the refresh messages in Arabic, Hebrew and Vietnamese too (#7724) --- .../pending/update-refresh-latest.json | 42 ++++++++++++ crates/ui-egui/src/update.rs | 56 +++++++++++----- crates/ui-egui/src/update/install.rs | 37 ++++++++++- crates/ui-egui/src/update/install_tests.rs | 64 +++++++++++++++++++ crates/ui-egui/src/update/tests.rs | 64 +++++++++++++++++++ 5 files changed, 245 insertions(+), 18 deletions(-) create mode 100644 assets/locales/pending/update-refresh-latest.json diff --git a/assets/locales/pending/update-refresh-latest.json b/assets/locales/pending/update-refresh-latest.json new file mode 100644 index 000000000..e81f4fdd8 --- /dev/null +++ b/assets/locales/pending/update-refresh-latest.json @@ -0,0 +1,42 @@ +{ + "en": { + "update.refresh_checking": "Checking for the newest release…", + "update.refresh_fallback": "Could not check for a newer release; updating to {version}, found earlier.", + "update.refresh_selected": "Updating to {version}." + }, + "ar": { + "update.refresh_checking": "جارٍ البحث عن أحدث إصدار…", + "update.refresh_fallback": "تعذّر البحث عن إصدار أحدث؛ سيتم التحديث إلى {version} الذي عُثر عليه سابقًا.", + "update.refresh_selected": "جارٍ التحديث إلى {version}." + }, + "de": { + "update.refresh_checking": "Neueste Version wird gesucht…", + "update.refresh_fallback": "Die Suche nach einer neueren Version ist fehlgeschlagen; die zuvor gefundene Version {version} wird installiert.", + "update.refresh_selected": "Version {version} wird installiert." + }, + "he": { + "update.refresh_checking": "בודק אם יש גרסה חדשה יותר…", + "update.refresh_fallback": "לא ניתן היה לבדוק אם יש גרסה חדשה יותר; מעדכן לגרסה {version} שנמצאה קודם.", + "update.refresh_selected": "מעדכן לגרסה {version}." + }, + "ja": { + "update.refresh_checking": "最新のリリースを確認中…", + "update.refresh_fallback": "新しいリリースを確認できませんでした。以前見つかった {version} に更新します。", + "update.refresh_selected": "{version} に更新中。" + }, + "ko": { + "update.refresh_checking": "최신 릴리스 확인 중…", + "update.refresh_fallback": "새 릴리스를 확인하지 못했습니다. 이전에 찾은 {version}(으)로 업데이트합니다.", + "update.refresh_selected": "{version}(으)로 업데이트 중." + }, + "vi": { + "update.refresh_checking": "Đang kiểm tra bản phát hành mới nhất…", + "update.refresh_fallback": "Không thể kiểm tra bản phát hành mới hơn; đang cập nhật lên {version} đã tìm thấy trước đó.", + "update.refresh_selected": "Đang cập nhật lên {version}." + }, + "zh": { + "update.refresh_checking": "正在检查最新版本…", + "update.refresh_fallback": "无法检查更新的版本;将更新至先前找到的 {version}。", + "update.refresh_selected": "正在更新至 {version}。" + } +} diff --git a/crates/ui-egui/src/update.rs b/crates/ui-egui/src/update.rs index 3a134a1d3..fc302f532 100644 --- a/crates/ui-egui/src/update.rs +++ b/crates/ui-egui/src/update.rs @@ -55,6 +55,7 @@ pub const MANUAL_COOLDOWN_S: f64 = 30.0; pub const RETRY_AFTER_FAILURE_S: f64 = 3600.0; /// Caps on what a release response may hold (it comes from the network). const MAX_NOTES: usize = 64 * 1024; +const MAX_RELEASE_BYTES: usize = 4 * 1024 * 1024; const MAX_ASSETS: usize = 400; /// The room the Update pill's long label leaves for the document tabs. const TAB_ROOM: f32 = 300.0; @@ -493,6 +494,9 @@ impl Release { /// A `releases/latest` answer. Drafts and prereleases are refused (GitHub never returns them /// there, but the answer comes from the network). pub fn parse(json: &[u8]) -> Result { + if json.len() > MAX_RELEASE_BYTES { + return Err(FetchError::Failed("release response is too large".into())); + } let v: Value = serde_json::from_slice(json).map_err(|e| FetchError::Failed(format!("unexpected answer from GitHub: {e}")))?; let s = |k: &str| v.get(k).and_then(Value::as_str).unwrap_or_default().to_string(); if v.get("draft").and_then(Value::as_bool).unwrap_or(false) || v.get("prerelease").and_then(Value::as_bool).unwrap_or(false) { @@ -713,7 +717,12 @@ pub fn tick(app: &mut SolveApp, ctx: &egui::Context) { poll(app); let now = unix_now(); let launch = !app.updater.launch_checked; - if app.updater.rx.is_none() && app.preferences.check_updates && app.preferences.update.due(now, launch) && available(app) { + if app.updater.job.is_none() + && app.updater.rx.is_none() + && app.preferences.check_updates + && app.preferences.update.due(now, launch) + && available(app) + { app.updater.launch_checked = true; start(app, ctx, false); } @@ -734,20 +743,29 @@ pub fn check_now(app: &mut SolveApp, ctx: &egui::Context) { start(app, ctx, true); } +/// Fetch the same bounded feed for automatic checks and an explicit installation. +fn fetch_latest(feed: Option<&Path>, http: Option<&HttpGet>) -> Result { + use std::io::Read; + let body = match (feed, http) { + (Some(path), _) => { + let file = std::fs::File::open(path).map_err(|e| FetchError::Failed(e.to_string()))?; + let mut body = Vec::new(); + file.take(MAX_RELEASE_BYTES as u64 + 1).read_to_end(&mut body).map_err(|e| FetchError::Failed(e.to_string()))?; + body + } + (None, Some(get)) => get(LATEST_API)?, + (None, None) => return Err(FetchError::Failed("no network client".into())), + }; + Release::parse(&body) +} + fn start(app: &mut SolveApp, ctx: &egui::Context, manual: bool) { let (tx, rx) = std::sync::mpsc::channel(); app.updater.status = Status::Checking; app.updater.rx = Some((rx, manual)); let feed = app.updater.feed.clone(); let http = app.services.http_get.clone(); - let fetch = move || -> Result { - let body = match (&feed, &http) { - (Some(path), _) => std::fs::read(path).map_err(|e| FetchError::Failed(format!("{}: {e}", path.display())))?, - (None, Some(get)) => get(LATEST_API)?, - (None, None) => return Err(FetchError::Failed("no network client".into())), - }; - Release::parse(&body) - }; + let fetch = move || fetch_latest(feed.as_deref(), http.as_ref()); #[cfg(not(target_arch = "wasm32"))] { let ctx = ctx.clone(); @@ -788,7 +806,9 @@ fn poll(app: &mut SolveApp) { app.preferences.update.remind_after = 0.0; app.updater.open = true; } - app.updater.release = Some(release); + if app.updater.job.is_none() && app.updater.release.as_ref().is_none_or(|known| !is_newer(&known.tag, &release.tag)) { + app.updater.release = Some(release); + } } Err(e) => { log::info!("update check: {e}"); @@ -819,7 +839,7 @@ pub fn install_method(app: &mut SolveApp) -> Option { } } -/// Download, verify and apply the release found (Update now). +/// Re-check the feed, then download, verify and apply the newest release (Update now). pub fn start_install(app: &mut SolveApp, ctx: &egui::Context) { let (Some(release), Some(method), Some(get), Some(download)) = (app.updater.release.clone(), install_method(app), app.services.http_get.clone(), app.services.http_download.clone()) @@ -830,6 +850,7 @@ pub fn start_install(app: &mut SolveApp, ctx: &egui::Context) { return; } let kind = app.updater.kind().clone(); + let feed = app.updater.feed.clone(); let progress = Arc::new(install::Progress::default()); let (tx, rx) = std::sync::mpsc::channel(); app.updater.installed = None; @@ -838,7 +859,7 @@ pub fn start_install(app: &mut SolveApp, ctx: &egui::Context) { { let ctx = ctx.clone(); let staging = std::env::temp_dir().join("solidcraft-update"); - let net = install::Net { get, download }; + let net = install::Net { get, download, feed }; let spawned = std::thread::Builder::new().name("update-install".into()).spawn(move || { let result = install::run(&release, &kind, &method, std::env::consts::ARCH, &net, &staging, &progress); let _ = tx.send(result); @@ -851,14 +872,18 @@ pub fn start_install(app: &mut SolveApp, ctx: &egui::Context) { } #[cfg(target_arch = "wasm32")] { - let _ = (ctx, tx, release, method, get, download, kind); + let _ = (ctx, tx, release, method, get, download, kind, feed); app.updater.job = None; } } fn poll_install(app: &mut SolveApp) { - let Some((rx, _)) = &app.updater.job else { return }; - let result = match rx.try_recv() { + let Some((rx, progress)) = &app.updater.job else { return }; + let received = rx.try_recv(); + if let Some((release, _)) = progress.selection() { + app.updater.release = Some(release); + } + let result = match received { Ok(r) => r, Err(TryRecvError::Empty) => return, Err(TryRecvError::Disconnected) => Err("the update stopped".into()), @@ -991,6 +1016,7 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) { } match (&state, &app.updater.installed, &app.updater.job) { (State::Downloading, _, Some((_, progress))) => { + ui_kit::text(ui, &progress.message(), ui_kit::Text::Report("selection", false)); let done = progress.done.load(std::sync::atomic::Ordering::Relaxed); let total = progress.total.load(std::sync::atomic::Ordering::Relaxed).max(1); let mb = |b: u64| format!("{:.1}", b as f64 / 1_048_576.0); diff --git a/crates/ui-egui/src/update/install.rs b/crates/ui-egui/src/update/install.rs index b954475e9..4eee68916 100644 --- a/crates/ui-egui/src/update/install.rs +++ b/crates/ui-egui/src/update/install.rs @@ -20,8 +20,8 @@ use std::io::{Read, Write}; use std::path::{Path, PathBuf}; -use std::sync::Arc; use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; +use std::sync::{Arc, Mutex}; use sha2::{Digest, Sha256}; @@ -145,16 +145,36 @@ pub struct Progress { pub done: AtomicU64, pub total: AtomicU64, pub cancel: AtomicBool, + /// Final release and whether the refresh failed; absent while checking. + selected: Mutex>, +} + +impl Progress { + pub fn selection(&self) -> Option<(Release, bool)> { + self.selected.lock().unwrap_or_else(|e| e.into_inner()).clone() + } + + pub fn message(&self) -> String { + let selected = self.selected.lock().unwrap_or_else(|e| e.into_inner()); + match selected.as_ref() { + None => crate::i18n::tr("update.refresh_checking").to_string(), + Some((release, fallback)) => { + crate::i18n::format(if *fallback { "update.refresh_fallback" } else { "update.refresh_selected" }, &[("version", release.version())]) + } + } + } } /// What the update needs from the host. pub struct Net { pub get: super::HttpGet, pub download: HttpDownload, + pub feed: Option, } -/// Download, verify and apply `release` for `method`. Runs on a background thread. `staging` is -/// a folder for downloads that aren't written next to their target (the `.msi`, the `.dmg`). +/// Refresh the feed, then download, verify and apply the newest release for `method`, falling +/// back to `release` when the check fails. Runs on a background thread. `staging` holds downloads +/// that are not written next to their target (the `.msi`, the `.dmg`). pub fn run( release: &Release, kind: &InstallKind, @@ -164,6 +184,17 @@ pub fn run( staging: &Path, progress: &Progress, ) -> Result { + // The release shown may be stale by now: install the newest one the feed names, or the one + // shown when the feed can't be read. + let (release, fallback) = match super::fetch_latest(net.feed.as_deref(), Some(&net.get)) { + Ok(latest) if super::is_newer(&latest.tag, &release.tag) => (latest, false), + Ok(_) => (release.clone(), false), + Err(_) => (release.clone(), true), + }; + *progress.selected.lock().unwrap_or_else(|e| e.into_inner()) = Some((release.clone(), fallback)); + if progress.cancel.load(Ordering::Relaxed) { + return Err("cancelled".into()); + } let asset = release.asset_for(kind, arch).ok_or_else(|| format!("this release has no package for a {} on {arch}", kind.label()))?; if asset.size > MAX_PACKAGE { return Err(format!("{} is too large ({} bytes)", asset.name, asset.size)); diff --git a/crates/ui-egui/src/update/install_tests.rs b/crates/ui-egui/src/update/install_tests.rs index bacef38c4..2fa03c85c 100644 --- a/crates/ui-egui/src/update/install_tests.rs +++ b/crates/ui-egui/src/update/install_tests.rs @@ -87,6 +87,7 @@ fn net(files: Vec<(String, Vec)>) -> Net { let find = move |files: &[(String, Vec)], url: &str| files.iter().find(|(n, _)| url == format!("{BASE}{n}")).map(|(_, b)| b.clone()); let find2 = find; Net { + feed: None, get: Arc::new(move |url: &str| find(&files, url).ok_or_else(|| FetchError::Failed(format!("404 {url}")))), download: Arc::new(move |url: &str, to: &Path, progress: &dyn Fn(u64, Option) -> bool| { let body = find2(&f2, url).ok_or_else(|| FetchError::Failed(format!("404 {url}")))?; @@ -246,3 +247,66 @@ fn an_updated_appimage_takes_the_release_file_name() { assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 1, "nothing else is left behind"); let _ = std::fs::remove_dir_all(&dir); } + +#[test] +fn installation_refreshes_the_release_and_verifies_the_final_package() { + let dir = scratch("refresh"); + let target = dir.join("SolidCraft.AppImage"); + let name = "solidcraft-linux-x86_64.AppImage"; + let shown = release_with(&[(name, 3), (SUMS, 100)]); + let base = "https://github.com/tangency-labs/solidcraft/releases/download/v10.0.0/"; + let feed = serde_json::json!({ + "tag_name": "v10.0.0", + "assets": [ + {"name": name, "browser_download_url": format!("{base}{name}"), "size": 3}, + {"name": SUMS, "browser_download_url": format!("{base}{SUMS}")} + ] + }) + .to_string() + .into_bytes(); + for (case, answer, corrupt, expected, fallback) in [ + ("newest", Ok(feed.clone()), false, "10.0.0", false), + ("corrupt newest", Ok(feed), true, "10.0.0", false), + ("offline", Err(FetchError::Failed("offline".into())), false, "9.9.9", true), + ("rate limited", Err(FetchError::RateLimited { retry_after_s: 60 }), false, "9.9.9", true), + ("oversized", Ok(vec![b' '; super::MAX_RELEASE_BYTES + 1]), false, "9.9.9", true), + ("older", Ok(br#"{"tag_name":"v9.9.8"}"#.to_vec()), false, "9.9.9", false), + ] { + std::fs::write(&target, b"old").unwrap(); + let chosen_base = if expected == "10.0.0" { base } else { BASE }; + let n = Net { + feed: None, + get: Arc::new(move |url| { + if url == super::LATEST_API { + return answer.clone(); + } + assert_eq!(url, format!("{chosen_base}{SUMS}"), "checksums from the chosen release"); + Ok(format!("{} {name}\n", hex(if corrupt { b"bad" } else { b"new" })).into_bytes()) + }), + download: Arc::new(move |url, to, report| { + assert_eq!(url, format!("{chosen_base}{name}"), "package from the chosen release"); + std::fs::write(to, b"new").unwrap(); + assert!(report(3, Some(3))); + Ok(()) + }), + }; + let p = Progress::default(); + let result = run(&shown, &InstallKind::AppImage(target.clone()), &Method::AppImage(target.clone()), "x86_64", &n, &dir, &p); + let (selected, used_fallback) = p.selection().unwrap(); + assert_eq!(selected.version(), expected, "{case}"); + assert_eq!(used_fallback, fallback, "{case}"); + assert_eq!( + p.message(), + crate::i18n::format(if fallback { "update.refresh_fallback" } else { "update.refresh_selected" }, &[("version", expected)]), + "{case}" + ); + if corrupt { + assert!(result.unwrap_err().contains("doesn't match")); + assert_eq!(std::fs::read(&target).unwrap(), b"old"); + } else { + assert_eq!(result.unwrap(), Outcome::Restart(target.clone()), "{case}"); + assert_eq!(std::fs::read(&target).unwrap(), b"new"); + } + } + let _ = std::fs::remove_dir_all(dir); +} diff --git a/crates/ui-egui/src/update/tests.rs b/crates/ui-egui/src/update/tests.rs index dc250a1be..e192fdaee 100644 --- a/crates/ui-egui/src/update/tests.rs +++ b/crates/ui-egui/src/update/tests.rs @@ -686,3 +686,67 @@ fn an_unmanaged_install_updates_itself_as_before() { assert!(h.widget("Download").is_some()); assert!(h.widget("Update available: update SolidCraft in ArtCraft Launcher").is_none()); } + +#[test] +fn periodic_checks_refresh_the_offered_label() { + let dir = scratch(); + let (feed, first) = next_release_feed(&dir.0); + let mut h = crate::scenario::Harness::new(); + h.app.updater.feed = Some(feed.clone()); + h.frame(); + wait_for_check(&mut h); + h.frames(2); + assert!(h.widget(&format!("Update to {first}")).is_some()); + h.app.updater.installed = Some(Ok(install::Outcome::Restart(dir.0.join("SolidCraft.AppImage")))); + let v = parse_version(&first).unwrap(); + let next = format!("{}.{}.0", v.major, v.minor + 1); + std::fs::write(feed, json!({"tag_name": format!("v{next}")}).to_string()).unwrap(); + h.app.preferences.update.next_check = 0.0; + h.frame(); + wait_for_check(&mut h); + h.frames(2); + assert!(h.widget(&format!("Update to {next}")).is_some()); + assert!(h.widget(&format!("Update to {first}")).is_none()); +} + +#[test] +fn install_selection_refreshes_the_button_and_progress_before_completion() { + let dir = scratch(); + let target = dir.0.join("SolidCraft.AppImage"); + let name = asset_name(&InstallKind::AppImage(target.clone()), std::env::consts::ARCH, "999.1.0").unwrap(); + let mut h = crate::scenario::Harness::new(); + h.app.preferences.check_updates = false; + let mut shown = release(); + shown.tag = "v999.0.0".into(); + h.app.updater.release = Some(shown); + h.app.updater.kind = Some(InstallKind::AppImage(target)); + h.app.updater.open = true; + h.app.services.http_get = Some(Arc::new(move |url| { + if url == LATEST_API { + return Ok(json!({"tag_name":"v999.1.0", "assets":[ + {"name": name, "browser_download_url":format!("https://github.com/tangency-labs/solidcraft/releases/download/v999.1.0/{name}")}, + {"name": install::SUMS, "browser_download_url":"https://github.com/tangency-labs/solidcraft/releases/download/v999.1.0/SHA256SUMS.txt"} + ]}).to_string().into_bytes()); + } + Ok(format!("{} {name}\n", "a".repeat(64)).into_bytes()) + })); + let (tx, rx) = std::sync::mpsc::channel(); + let rx = std::sync::Mutex::new(rx); + h.app.services.http_download = Some(Arc::new(move |_, _, _| { + rx.lock().unwrap().recv().unwrap(); + Err(FetchError::Failed("download stopped".into())) + })); + start_install(&mut h.app, &egui::Context::default()); + for _ in 0..500 { + poll_install(&mut h.app); + if h.app.updater.release.as_ref().unwrap().version() == "999.1.0" { + break; + } + std::thread::sleep(std::time::Duration::from_millis(2)); + } + h.frames(2); + assert!(h.widget("Update to 999.1.0").is_some()); + assert!(h.widget("Updating to 999.1.0.").is_some()); + assert!(h.app.updater.installed.is_none()); + tx.send(()).unwrap(); +}