fix #14740: faster update retries and release safety checks

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
hauke
2026-11-06 11:50:43 +01:00
co-authored by Claude Opus 5.5
parent bda584deda
commit c7811b75ae
4 changed files with 232 additions and 22 deletions
+23 -7
View File
@@ -95,10 +95,16 @@ with `404`, which falls through as intended.
## Releasing a version ## Releasing a version
Example: version `0.1.1`. Versions are semantic versions and must be higher than the Example: version `0.1.1`. Versions are semantic versions and must be greater than the
installed one. installed one. The script refuses a version that is not greater than the committed
one. The committed version itself is allowed while there is no tag `v<version>` yet,
e.g. for the first release `0.1.0`.
1. Start from a clean `master` with the tests passing (`cargo test --workspace`). 1. Start from `master` with no uncommitted changes to tracked files (the script
refuses otherwise; untracked files do not matter) and the tests passing
(`cargo test --workspace`). If a build failed after the script had set the version,
reset that first:
`git checkout src-tauri/tauri.conf.json src-tauri/Cargo.toml Cargo.lock ui/package.json`.
2. Build (works in fish and bash; without `TAURI_SIGNING_PRIVATE_KEY_PASSWORD` the 2. Build (works in fish and bash; without `TAURI_SIGNING_PRIVATE_KEY_PASSWORD` the
script asks for the password): script asks for the password):
@@ -108,6 +114,7 @@ installed one.
``` ```
The script: The script:
- checks that the tree is clean and the version is greater (see above),
- checks the key and password by signing a probe file, and stops if the key does - checks the key and password by signing a probe file, and stops if the key does
not belong to `plugins.updater.pubkey`, not belong to `plugins.updater.pubkey`,
- sets the version in `src-tauri/tauri.conf.json`, `src-tauri/Cargo.toml` and - sets the version in `src-tauri/tauri.conf.json`, `src-tauri/Cargo.toml` and
@@ -148,10 +155,12 @@ installed one.
<https://gitea.euvino.eu/public/call-recorder/releases/new>. Do not mark it as a <https://gitea.euvino.eu/public/call-recorder/releases/new>. Do not mark it as a
draft or a pre-release, otherwise it is not the "latest" release. draft or a pre-release, otherwise it is not the "latest" release.
7. Upload **every** file from `dist-release/0.1.1/` as a release asset, including the 7. Upload every file from `dist-release/0.1.1/` as a release asset, keeping the file
`.sig` files and `latest.json`. Keep the file names: `latest.json` points to them. names (`latest.json` points to them). Upload the installers, packages and `.sig`
files first and **`latest.json` last**. As soon as `latest.json` is visible,
installed apps may try to download the files it lists.
8. Once the assets are uploaded, publish the feed for URL 2 as well: 8. Only after all assets are uploaded, publish the feed for URL 2 as well:
```sh ```sh
cp dist-release/0.1.1/latest.json latest.json cp dist-release/0.1.1/latest.json latest.json
@@ -184,7 +193,11 @@ After publishing 0.1.0 and then 0.1.1:
progress bar, asks for no admin rights, and the app restarts as 0.1.1. The banner progress bar, asks for no admin rights, and the app restarts as 0.1.1. The banner
is gone. is gone.
Failed checks (offline, no release yet) are not shown. The log The app also shows its main window on the first start of a new version, even if it
was started with `--autostart` (the installer restarts it with its old arguments).
Failed checks (offline, no release yet) are not shown. They are retried after 1, 5
and 30 minutes, then every 6 hours. The log
(`%LOCALAPPDATA%\eu.euvino.callrecorder\logs`) has an Info line `update check failed: (`%LOCALAPPDATA%\eu.euvino.callrecorder\logs`) has an Info line `update check failed:
…`. …`.
@@ -192,6 +205,9 @@ Failed checks (offline, no release yet) are not shown. The log
- `scripts/build-windows.sh` alone builds an unsigned test installer without updater - `scripts/build-windows.sh` alone builds an unsigned test installer without updater
artifacts when no signing key is set. artifacts when no signing key is set.
- `RELEASE_ALLOW_DIRTY=1` lets `build-release.sh` build with uncommitted changes to
tracked files, and `RELEASE_ALLOW_NOT_NEWER=1` lets it build a version that is not
greater than the committed one. Use them only for test builds; never publish one.
- `RELEASE_ALLOW_KEY_MISMATCH=1` lets `build-release.sh` build with a key that does - `RELEASE_ALLOW_KEY_MISMATCH=1` lets `build-release.sh` build with a key that does
not match `plugins.updater.pubkey`. Use it only to test the pipeline with a throwaway not match `plugins.updater.pubkey`. Use it only to test the pipeline with a throwaway
key. Installed apps reject such a release, so never publish it. key. Installed apps reject such a release, so never publish it.
+46
View File
@@ -38,6 +38,52 @@ command -v jq >/dev/null 2>&1 || die "jq not found on PATH"
# shellcheck source=release.env # shellcheck source=release.env
source "${SCRIPT_DIR}/release.env" source "${SCRIPT_DIR}/release.env"
# --- Safety checks ----------------------------------------------------------
# The release must be built from committed sources, and the version bump this
# script makes must be the only change to commit afterwards. Untracked files
# are ignored.
if [ -n "$(git -C "${REPO_ROOT}" status --porcelain --untracked-files=no)" ]; then
if [ "${RELEASE_ALLOW_DIRTY:-}" = "1" ]; then
echo "WARNING: building from uncommitted changes (RELEASE_ALLOW_DIRTY=1)." >&2
else
die "uncommitted changes to tracked files; commit them first (or reset a version bump left by a failed build):
$(git -C "${REPO_ROOT}" status --short --untracked-files=no)"
fi
fi
# Whether semantic version $1 is greater than $2 (build metadata ignored).
version_gt() {
local a="${1%%+*}" b="${2%%+*}"
local a_pre="" b_pre="" i
[[ "${a}" == *-* ]] && a_pre="${a#*-}"
[[ "${b}" == *-* ]] && b_pre="${b#*-}"
local -a a_core b_core
IFS=. read -ra a_core <<<"${a%%-*}"
IFS=. read -ra b_core <<<"${b%%-*}"
for i in 0 1 2; do
((10#${a_core[i]} > 10#${b_core[i]})) && return 0
((10#${a_core[i]} < 10#${b_core[i]})) && return 1
done
# Same core: a release is greater than its pre-releases.
[ -z "${a_pre}" ] && [ -n "${b_pre}" ] && return 0
[ -z "${a_pre}" ] || [ -z "${b_pre}" ] && return 1
[ "${a_pre}" != "${b_pre}" ] &&
[ "$(printf '%s\n%s\n' "${a_pre}" "${b_pre}" | sort -V | tail -n 1)" = "${a_pre}" ]
}
# Installed apps only update to a greater version. The committed version may
# be built again as long as it has not been released (no tag v<version>),
# e.g. for the first release.
CURRENT="$(git -C "${REPO_ROOT}" show HEAD:src-tauri/tauri.conf.json | jq -r .version)"
if ! version_gt "${VERSION}" "${CURRENT}" &&
! { [ "${VERSION}" = "${CURRENT}" ] && [ -z "$(git -C "${REPO_ROOT}" tag -l "v${CURRENT}")" ]; }; then
if [ "${RELEASE_ALLOW_NOT_NEWER:-}" = "1" ]; then
echo "WARNING: ${VERSION} is not greater than the current version ${CURRENT} (RELEASE_ALLOW_NOT_NEWER=1); installed apps will not update to it." >&2
else
die "${VERSION} is not greater than the current version ${CURRENT}"
fi
fi
# --- Updater signing key --------------------------------------------------- # --- Updater signing key ---------------------------------------------------
# `cargo tauri build` reads only TAURI_SIGNING_PRIVATE_KEY (key or path). # `cargo tauri build` reads only TAURI_SIGNING_PRIVATE_KEY (key or path).
if [ -n "${TAURI_SIGNING_PRIVATE_KEY_PATH:-}" ]; then if [ -n "${TAURI_SIGNING_PRIVATE_KEY_PATH:-}" ]; then
+14 -1
View File
@@ -48,6 +48,13 @@ pub fn run() {
.level(log::LevelFilter::Info) .level(log::LevelFilter::Info)
// flacenc logs per-encode statistics at Info. // flacenc logs per-encode statistics at Info.
.level_for("flacenc", log::LevelFilter::Warn) .level_for("flacenc", log::LevelFilter::Warn)
// The updater plugin logs an Error for every endpoint
// that fails, also for the expected 404 of a feed URL
// that is not served while the other one is. Every
// check and install result reaches `updater`, which
// logs it (failed checks at Info, failed installs at
// Error), so the plugin's own lines are dropped.
.level_for("tauri_plugin_updater", log::LevelFilter::Off)
.max_file_size(LOG_FILE_SIZE) .max_file_size(LOG_FILE_SIZE)
.rotation_strategy(RotationStrategy::KeepSome(2)) .rotation_strategy(RotationStrategy::KeepSome(2))
.timezone_strategy(TimezoneStrategy::UseLocal) .timezone_strategy(TimezoneStrategy::UseLocal)
@@ -72,6 +79,10 @@ pub fn run() {
Vec::new() Vec::new()
}); });
let autostart = state.settings().autostart; let autostart = state.settings().autostart;
let new_version = updater::first_start_of_version(
&config_dir.join("last-version"),
&app.package_info().version.to_string(),
);
// Before anything can start a run. // Before anything can start a run.
processing::clear_upload_dir(app.handle()); processing::clear_upload_dir(app.handle());
app.manage(state); app.manage(state);
@@ -88,7 +99,9 @@ pub fn run() {
tray::create(app.handle())?; tray::create(app.handle())?;
detection::spawn(app.handle().clone()); detection::spawn(app.handle().clone());
updater::spawn(app.handle().clone()); updater::spawn(app.handle().clone());
if !std::env::args().any(|arg| arg == AUTOSTART_ARG) { // After an update the installer restarts the app with its old
// arguments; the main window shows the new version even then.
if new_version || !std::env::args().any(|arg| arg == AUTOSTART_ARG) {
commands::show_main(app.handle()); commands::show_main(app.handle());
} }
Ok(()) Ok(())
+149 -14
View File
@@ -1,15 +1,18 @@
//! Self-update (Windows only): checks the release feed (`plugins.updater` //! Self-update (Windows only): checks the release feed (`plugins.updater`
//! in `tauri.conf.json`) at startup and every 6 h, tells the main window //! in `tauri.conf.json`) at startup and every 6 h (sooner after a failed
//! about a newer version and installs it when the user asks, but never while //! check), tells the main window about a newer version and installs it when
//! a recording runs or a call is being processed. //! the user asks, but never while a recording runs or a call is being
//! processed.
//! //!
//! On Windows the NSIS installer runs in passive mode for the current user //! On Windows the NSIS installer runs in passive mode for the current user
//! (no admin rights) and restarts the app; installing ends this process. //! (no admin rights) and restarts the app; installing ends this process.
use std::fs;
use std::path::Path;
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Mutex; use std::sync::Mutex;
use std::thread; use std::thread;
use std::time::Duration; use std::time::{Duration, SystemTime};
use serde::Serialize; use serde::Serialize;
use tauri::{AppHandle, Emitter, Manager}; use tauri::{AppHandle, Emitter, Manager};
@@ -17,7 +20,24 @@ use tauri_plugin_updater::{Update, UpdaterExt};
use crate::state::AppState; use crate::state::AppState;
/// Time between checks once a check succeeded (whether or not it found an
/// update).
const CHECK_INTERVAL: Duration = Duration::from_secs(6 * 60 * 60); const CHECK_INTERVAL: Duration = Duration::from_secs(6 * 60 * 60);
/// Waits after the 1st, 2nd and 3rd failed check in a row; from the 4th
/// failure on, [`CHECK_INTERVAL`].
const RETRY_DELAYS: [Duration; 3] = [
Duration::from_secs(60),
Duration::from_secs(5 * 60),
Duration::from_secs(30 * 60),
];
/// How often the check loop looks at the wall clock. Shorter than the first
/// retry delay, so retries are on time; checks are scheduled by wall-clock
/// time, so a PC that slept through a due check checks soon after waking.
const WAKE_INTERVAL: Duration = Duration::from_secs(30);
/// Limit for asking the feed for a new version.
const CHECK_TIMEOUT: Duration = Duration::from_secs(30);
/// Limit for downloading the installer.
const DOWNLOAD_TIMEOUT: Duration = Duration::from_secs(15 * 60);
/// Progress steps while the download size is unknown. /// Progress steps while the download size is unknown.
const MIB: u64 = 1024 * 1024; const MIB: u64 = 1024 * 1024;
/// Why the banner cannot install yet; the banner shows the same hint. /// Why the banner cannot install yet; the banner shows the same hint.
@@ -53,16 +73,47 @@ pub fn spawn(app: AppHandle) {
log::info!("update check disabled on this platform"); log::info!("update check disabled on this platform");
return; return;
} }
thread::spawn(move || loop { thread::spawn(move || {
tauri::async_runtime::block_on(check(&app)); let mut last_attempt = None;
thread::sleep(CHECK_INTERVAL); let mut failures = 0;
loop {
let now = SystemTime::now();
if check_due(last_attempt, failures, now) {
last_attempt = Some(now);
if tauri::async_runtime::block_on(check(&app)) {
failures = 0;
} else {
failures = failures.saturating_add(1);
}
}
thread::sleep(WAKE_INTERVAL);
}
}); });
} }
/// Asks the release feed for a newer version. Failures (offline, no release /// Whether the next update check is due at `now`, given when the last one
/// yet) are expected and only logged. /// started (`None`: none yet) and how many checks in a row failed. Uses the
async fn check(app: &AppHandle) { /// wall clock, which keeps running in standby; a clock that went back makes
let result = match app.updater() { /// the check due.
fn check_due(last_attempt: Option<SystemTime>, failures: u32, now: SystemTime) -> bool {
let Some(last) = last_attempt else {
return true;
};
let wait = match failures {
0 => CHECK_INTERVAL,
n => RETRY_DELAYS
.get(n as usize - 1)
.copied()
.unwrap_or(CHECK_INTERVAL),
};
now.duration_since(last)
.map_or(true, |elapsed| elapsed >= wait)
}
/// Asks the release feed for a newer version; `false` if the check failed.
/// Failures (offline, no release yet) are expected and only logged.
async fn check(app: &AppHandle) -> bool {
let result = match app.updater_builder().timeout(CHECK_TIMEOUT).build() {
Ok(updater) => updater.check().await, Ok(updater) => updater.check().await,
Err(e) => Err(e), Err(e) => Err(e),
}; };
@@ -72,12 +123,37 @@ async fn check(app: &AppHandle) {
let version = update.version.clone(); let version = update.version.clone();
*lock(&app.state::<PendingUpdate>().update) = Some(update); *lock(&app.state::<PendingUpdate>().update) = Some(update);
let _ = app.emit("update-available", info(app, version)); let _ = app.emit("update-available", info(app, version));
true
}
Ok(None) => {
log::info!("no update available");
true
}
Err(e) => {
log::info!("update check failed: {e}");
false
} }
Ok(None) => log::info!("no update available"),
Err(e) => log::info!("update check failed: {e}"),
} }
} }
/// Whether this is the first start of `version` (e.g. right after an
/// update), going by the version remembered in `path`; remembers `version`
/// for the next start.
pub fn first_start_of_version(path: &Path, version: &str) -> bool {
let previous = fs::read_to_string(path).ok();
if previous.as_deref().map(str::trim) == Some(version) {
return false;
}
let written = path
.parent()
.map_or(Ok(()), fs::create_dir_all)
.and_then(|()| fs::write(path, version));
if let Err(e) = written {
log::warn!("could not remember the app version: {e}");
}
true
}
fn info(app: &AppHandle, version: String) -> UpdateInfo { fn info(app: &AppHandle, version: String) -> UpdateInfo {
UpdateInfo { UpdateInfo {
version, version,
@@ -111,9 +187,10 @@ pub async fn install_update(app: AppHandle) -> Result<(), String> {
} }
async fn download_and_install(app: &AppHandle) -> Result<(), String> { async fn download_and_install(app: &AppHandle) -> Result<(), String> {
let update = lock(&app.state::<PendingUpdate>().update) let mut update = lock(&app.state::<PendingUpdate>().update)
.clone() .clone()
.ok_or_else(|| "Kein Update verfügbar".to_string())?; .ok_or_else(|| "Kein Update verfügbar".to_string())?;
update.timeout = Some(DOWNLOAD_TIMEOUT);
let state = app.state::<AppState>(); let state = app.state::<AppState>();
if state.recording_or_processing() { if state.recording_or_processing() {
return Err(BUSY.to_string()); return Err(BUSY.to_string());
@@ -180,6 +257,64 @@ fn lock<T>(mutex: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
mod tests { mod tests {
use super::*; use super::*;
const MIN: Duration = Duration::from_secs(60);
const HOUR: Duration = Duration::from_secs(60 * 60);
fn t0() -> SystemTime {
SystemTime::UNIX_EPOCH + Duration::from_secs(1_800_000_000)
}
#[test]
fn the_first_check_is_due_at_once() {
assert!(check_due(None, 0, t0()));
}
#[test]
fn after_a_successful_check_the_next_is_due_in_6_hours() {
assert!(!check_due(Some(t0()), 0, t0() + 6 * HOUR - MIN));
assert!(check_due(Some(t0()), 0, t0() + 6 * HOUR));
}
#[test]
fn failed_checks_are_retried_after_1_5_and_30_minutes_then_6_hours() {
for (failures, wait) in [
(1, MIN),
(2, 5 * MIN),
(3, 30 * MIN),
(4, 6 * HOUR),
(9, 6 * HOUR),
] {
let last = Some(t0());
assert!(
!check_due(last, failures, t0() + wait - Duration::from_secs(1)),
"{failures}"
);
assert!(check_due(last, failures, t0() + wait), "{failures}");
}
}
#[test]
fn a_check_is_due_after_standby_by_the_wall_clock() {
// Days in standby: whatever the interval, the check is due on wake-up.
assert!(check_due(Some(t0()), 0, t0() + 48 * HOUR));
}
#[test]
fn a_check_is_due_when_the_clock_went_back() {
assert!(check_due(Some(t0()), 0, t0() - HOUR));
}
#[test]
fn the_first_start_of_a_version_is_noticed_once() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config").join("last-version");
assert!(first_start_of_version(&path, "0.1.0"));
assert!(!first_start_of_version(&path, "0.1.0"));
assert!(first_start_of_version(&path, "0.1.1"));
assert!(!first_start_of_version(&path, "0.1.1"));
assert_eq!(fs::read_to_string(&path).unwrap(), "0.1.1");
}
fn reported(meter: &mut ProgressMeter, chunks: &[usize], total: Option<u64>) -> Vec<u64> { fn reported(meter: &mut ProgressMeter, chunks: &[usize], total: Option<u64>) -> Vec<u64> {
chunks chunks
.iter() .iter()