feat: probe autoupdate (#88)

* feat: autoupdate * chore: bump version * feat: publish installer * fix: standalone builds * ci: release docs * fix: windows icmp socket * docs: windows notice * docs: remove line breaks
2026-10-11 16:48:15 +03:00 · 2026-08-29 00:22:08 +05:00
parent 0c43f470cd
commit 63dff075c0
29 changed files with 1734 additions and 203 deletions
@@ -0,0 +1,555 @@
+use anyhow::{Context, Result, bail};
+use reqwest::{Client, Url};
+use semver::Version;
+use serde::Deserialize;
+use std::env;
+#[cfg(unix)]
+use std::fs::{File, OpenOptions};
+use std::path::Path;
+use std::process::{Command, Output, Stdio};
+use std::time::Duration;
+use tempfile::TempDir;
+
+const DEFAULT_REPOSITORY: &str = "LowderPlay/cheburcheck";
+const DEFAULT_API_BASE_URL: &str = "https://api.github.com";
+
+#[derive(Debug, Deserialize)]
+struct Release {
+    assets: Vec<Asset>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Asset {
+    name: String,
+    browser_download_url: String,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum PackageKind {
+    Debian,
+    Apk,
+    Opkg,
+    Linux,
+    #[cfg_attr(not(windows), allow(dead_code))]
+    Windows,
+}
+
+#[cfg(unix)]
+struct UpdateLock {
+    _file: File,
+}
+
+#[cfg(unix)]
+impl UpdateLock {
+    fn acquire() -> Result<Option<Self>> {
+        let lock_path = env::temp_dir().join(format!(
+            "cheburprobe-update-{}.lock",
+            rustix::process::getuid().as_raw()
+        ));
+        let file = OpenOptions::new()
+            .create(true)
+            .truncate(false)
+            .read(true)
+            .write(true)
+            .open(&lock_path)
+            .with_context(|| format!("failed to open update lock {}", lock_path.display()))?;
+
+        match rustix::fs::flock(&file, rustix::fs::FlockOperation::NonBlockingLockExclusive) {
+            Ok(()) => Ok(Some(Self { _file: file })),
+            Err(rustix::io::Errno::WOULDBLOCK) => Ok(None),
+            Err(error) => Err(error).context("failed to lock updater"),
+        }
+    }
+}
+
+#[cfg(windows)]
+struct UpdateLock;
+
+#[cfg(windows)]
+impl UpdateLock {
+    fn acquire() -> Result<Option<Self>> {
+        Ok(Some(Self))
+    }
+}
+
+pub async fn run() -> Result<()> {
+    let Some(_lock) = UpdateLock::acquire()? else {
+        println!("another cheburprobe update check is already running");
+        return Ok(());
+    };
+
+    update().await
+}
+
+async fn update() -> Result<()> {
+    let repository =
+        env::var("CHEBURPROBE_UPDATE_REPOSITORY").unwrap_or_else(|_| DEFAULT_REPOSITORY.to_owned());
+    validate_repository(&repository)?;
+
+    let current = Version::parse(env!("CARGO_PKG_VERSION"))
+        .context("the installed cheburprobe version is invalid")?;
+    let client = Client::builder()
+        .user_agent(concat!("cheburprobe-update/", env!("CARGO_PKG_VERSION")))
+        .timeout(Duration::from_secs(60))
+        .build()
+        .context("failed to create HTTP client")?;
+    let api_base_url = env::var("CHEBURPROBE_UPDATE_API_BASE_URL")
+        .unwrap_or_else(|_| DEFAULT_API_BASE_URL.to_owned());
+    let api_url = format!(
+        "{}/repos/{repository}/releases/latest",
+        api_base_url.trim_end_matches('/')
+    );
+    let release = fetch_release(&client, &api_url).await?;
+    let (kind, architecture, luci_installed) = detect_platform()?;
+    let (asset, latest) = select_asset(&release.assets, kind, &architecture)?;
+
+    if latest <= current {
+        if latest == current {
+            println!("cheburprobe is current ({current})");
+        } else {
+            println!(
+                "installed cheburprobe {current} is newer than packaged version {latest}; not downgrading"
+            );
+        }
+        return Ok(());
+    }
+
+    let luci_asset = luci_installed
+        .then(|| select_luci_asset(&release.assets, kind, &latest))
+        .transpose()?;
+
+    let temp_dir = TempDir::with_prefix("cheburprobe-update.")
+        .context("failed to create a temporary update directory")?;
+    let package = download_asset(&client, asset, temp_dir.path()).await?;
+    let luci_package = match luci_asset {
+        Some(asset) => Some(download_asset(&client, asset, temp_dir.path()).await?),
+        None => None,
+    };
+    install(kind, &package, luci_package.as_deref())?;
+
+    println!("updated cheburprobe from {current} to {latest}");
+    Ok(())
+}
+
+async fn fetch_release(client: &Client, api_url: &str) -> Result<Release> {
+    client
+        .get(api_url)
+        .header("Accept", "application/vnd.github+json")
+        .send()
+        .await
+        .context("failed to query the latest GitHub release")?
+        .error_for_status()
+        .context("GitHub rejected the latest-release request")?
+        .json::<Release>()
+        .await
+        .context("GitHub returned an invalid release document")
+}
+
+fn validate_repository(repository: &str) -> Result<()> {
+    let mut parts = repository.split('/');
+    let valid_part = |part: &str| {
+        !part.is_empty()
+            && part
+                .bytes()
+                .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.'))
+    };
+    match (parts.next(), parts.next(), parts.next()) {
+        (Some(owner), Some(repo), None) if valid_part(owner) && valid_part(repo) => Ok(()),
+        _ => bail!("invalid GitHub repository {repository:?}; expected owner/name"),
+    }
+}
+
+fn command_exists(command: &str) -> bool {
+    env::var_os("PATH").is_some_and(|path| {
+        env::split_paths(&path).any(|directory| directory.join(command).is_file())
+    })
+}
+
+fn command_output(command: &str, arguments: &[&str]) -> Result<Output> {
+    let output = Command::new(command)
+        .args(arguments)
+        .output()
+        .with_context(|| format!("failed to execute {command}"))?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_owned();
+        bail!("{command} exited with {}: {stderr}", output.status);
+    }
+    Ok(output)
+}
+
+fn output_text(command: &str, arguments: &[&str]) -> Result<String> {
+    let output = command_output(command, arguments)?;
+    String::from_utf8(output.stdout).with_context(|| format!("{command} returned non-UTF-8 output"))
+}
+
+fn command_succeeds(command: &str, arguments: &[&str]) -> Result<bool> {
+    let status = Command::new(command)
+        .args(arguments)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .with_context(|| format!("failed to execute {command}"))?;
+    Ok(status.success())
+}
+
+fn detect_platform() -> Result<(PackageKind, String, bool)> {
+    #[cfg(windows)]
+    {
+        let architecture = match env::consts::ARCH {
+            "x86_64" => "x86_64",
+            architecture => bail!("unsupported Windows architecture: {architecture}"),
+        };
+        return Ok((PackageKind::Windows, architecture.to_owned(), false));
+    }
+
+    #[cfg(target_os = "linux")]
+    if command_exists("dpkg") && command_succeeds("dpkg-query", &["-W", "cheburprobe"])? {
+        let architecture = output_text("dpkg", &["--print-architecture"])?;
+        let architecture = architecture.trim();
+        if !matches!(architecture, "amd64" | "arm64") {
+            bail!("unsupported Debian architecture: {architecture}");
+        }
+        Ok((PackageKind::Debian, architecture.to_owned(), false))
+    } else if command_exists("apk")
+        && command_succeeds("apk", &["info", "--exists", "cheburprobe"])?
+    {
+        let architecture = output_text("apk", &["--print-arch"])?;
+        let luci_installed =
+            command_succeeds("apk", &["info", "--exists", "luci-app-cheburprobe"])?;
+        Ok((
+            PackageKind::Apk,
+            architecture.trim().to_owned(),
+            luci_installed,
+        ))
+    } else if command_exists("opkg")
+        && output_text("opkg", &["list-installed", "cheburprobe"])?
+            .lines()
+            .any(|line| line.split_whitespace().next() == Some("cheburprobe"))
+    {
+        let architectures = output_text("opkg", &["print-architecture"])?;
+        let architecture = architectures
+            .lines()
+            .filter_map(|line| line.split_whitespace().nth(1))
+            .rfind(|architecture| *architecture != "all")
+            .context("opkg did not report a package architecture")?;
+        let luci_installed = output_text("opkg", &["list-installed", "luci-app-cheburprobe"])?
+            .lines()
+            .any(|line| line.split_whitespace().next() == Some("luci-app-cheburprobe"));
+        Ok((PackageKind::Opkg, architecture.to_owned(), luci_installed))
+    } else {
+        let architecture = match env::consts::ARCH {
+            "x86_64" => "amd64",
+            "aarch64" => "arm64",
+            architecture => bail!("unsupported standalone Linux architecture: {architecture}"),
+        };
+        Ok((PackageKind::Linux, architecture.to_owned(), false))
+    }
+
+    #[cfg(not(any(target_os = "linux", windows)))]
+    bail!("updates are not supported on this operating system")
+}
+
+fn select_luci_asset<'a>(
+    assets: &'a [Asset],
+    kind: PackageKind,
+    version: &Version,
+) -> Result<&'a Asset> {
+    let (prefix, suffix) = match kind {
+        PackageKind::Apk => (format!("luci-app-cheburprobe-{version}-r"), ".apk"),
+        PackageKind::Opkg => (format!("luci-app-cheburprobe_{version}-"), "_all.ipk"),
+        PackageKind::Debian | PackageKind::Linux | PackageKind::Windows => {
+            bail!("LuCI packages are only supported on OpenWrt")
+        }
+    };
+    let matches: Vec<_> = assets
+        .iter()
+        .filter(|asset| asset.name.starts_with(&prefix) && asset.name.ends_with(suffix))
+        .collect();
+    match matches.as_slice() {
+        [asset] => Ok(asset),
+        [] => bail!("LuCI package for v{version} not found"),
+        _ => bail!("multiple LuCI packages for v{version} found"),
+    }
+}
+
+fn package_version(name: &str, kind: PackageKind, architecture: &str) -> Option<Version> {
+    let (prefix, suffix) = match kind {
+        PackageKind::Debian => ("cheburprobe_", format!("_{architecture}.deb")),
+        PackageKind::Apk => ("cheburprobe-", format!("_{architecture}.apk")),
+        PackageKind::Opkg => ("cheburprobe_", format!("_{architecture}.ipk")),
+        PackageKind::Linux => ("cheburprobe-", format!("-linux-{architecture}")),
+        PackageKind::Windows => ("cheburprobe-", format!("-windows-{architecture}.exe")),
+    };
+    let version_with_revision = name.strip_prefix(prefix)?.strip_suffix(&suffix)?;
+    let version = match kind {
+        PackageKind::Apk => version_with_revision.rsplit_once("-r")?.0,
+        PackageKind::Debian | PackageKind::Opkg => version_with_revision.rsplit_once('-')?.0,
+        PackageKind::Linux | PackageKind::Windows => version_with_revision,
+    };
+    Version::parse(version).ok()
+}
+
+fn select_asset<'a>(
+    assets: &'a [Asset],
+    kind: PackageKind,
+    architecture: &str,
+) -> Result<(&'a Asset, Version)> {
+    let mut matches: Vec<_> = assets
+        .iter()
+        .filter_map(|asset| {
+            package_version(&asset.name, kind, architecture).map(|version| (asset, version))
+        })
+        .collect();
+    matches.sort_by(|(_, left), (_, right)| left.cmp(right));
+    let Some((asset, version)) = matches.pop() else {
+        bail!("Cheburprobe package for architecture {architecture} not found");
+    };
+    if matches.last().is_some_and(|(_, other)| other == &version) {
+        bail!("multiple Cheburprobe {version} packages for architecture {architecture} found");
+    }
+    Ok((asset, version))
+}
+
+async fn download(client: &Client, url: Url, destination: &Path) -> Result<()> {
+    let bytes = client
+        .get(url)
+        .send()
+        .await
+        .context("failed to download the update package")?
+        .error_for_status()
+        .context("GitHub rejected the package download")?
+        .bytes()
+        .await
+        .context("failed to read the update package")?;
+    std::fs::write(destination, bytes)
+        .with_context(|| format!("failed to write {}", destination.display()))
+}
+
+async fn download_asset(
+    client: &Client,
+    asset: &Asset,
+    directory: &Path,
+) -> Result<std::path::PathBuf> {
+    if Path::new(&asset.name)
+        .file_name()
+        .and_then(|name| name.to_str())
+        != Some(&asset.name)
+    {
+        bail!("invalid release asset name: {:?}", asset.name);
+    }
+    let url = Url::parse(&asset.browser_download_url)
+        .context("GitHub returned an invalid release asset URL")?;
+    let destination = directory.join(&asset.name);
+    download(client, url, &destination).await?;
+    Ok(destination)
+}
+
+fn run_paths(command: &str, arguments: &[&Path]) -> Result<()> {
+    let status = Command::new(command)
+        .args(arguments)
+        .status()
+        .with_context(|| format!("failed to execute {command}"))?;
+    if !status.success() {
+        bail!("{command} exited with {status}");
+    }
+    Ok(())
+}
+
+fn run_args(command: &str, arguments: &[&str]) -> Result<()> {
+    let status = Command::new(command)
+        .args(arguments)
+        .status()
+        .with_context(|| format!("failed to execute {command}"))?;
+    if !status.success() {
+        bail!("{command} exited with {status}");
+    }
+    Ok(())
+}
+
+fn install(kind: PackageKind, package: &Path, luci_package: Option<&Path>) -> Result<()> {
+    match kind {
+        PackageKind::Debian => {
+            run_paths("dpkg-deb", &[Path::new("--info"), package])?;
+            run_paths("dpkg", &[Path::new("-i"), package])?;
+            run_args("systemctl", &["try-restart", "cheburprobe.service"])
+        }
+        PackageKind::Apk => {
+            let mut arguments = vec![Path::new("add"), Path::new("--allow-untrusted"), package];
+            arguments.extend(luci_package);
+            run_paths("apk", &arguments)?;
+            run_args("/etc/init.d/cheburprobe", &["restart"])
+        }
+        PackageKind::Opkg => {
+            let mut arguments = vec![Path::new("install"), package];
+            arguments.extend(luci_package);
+            run_paths("opkg", &arguments)?;
+            run_args("/etc/init.d/cheburprobe", &["restart"])
+        }
+        PackageKind::Linux => replace_linux_executable(package),
+        PackageKind::Windows => replace_windows_executable(package),
+    }
+}
+
+#[cfg(unix)]
+fn replace_linux_executable(package: &Path) -> Result<()> {
+    use std::os::unix::fs::PermissionsExt;
+
+    let executable = env::current_exe().context("failed to locate the running executable")?;
+    let replacement = executable.with_extension("new");
+    let mode = std::fs::metadata(&executable)
+        .context("failed to inspect the running executable")?
+        .permissions()
+        .mode();
+    std::fs::copy(package, &replacement)
+        .context("failed to copy the new Linux executable beside the current one")?;
+    std::fs::set_permissions(&replacement, std::fs::Permissions::from_mode(mode))
+        .context("failed to set permissions on the new Linux executable")?;
+    if let Err(error) = std::fs::rename(&replacement, &executable) {
+        let _ = std::fs::remove_file(&replacement);
+        return Err(error).context("failed to replace the Linux executable");
+    }
+    Ok(())
+}
+
+#[cfg(not(unix))]
+fn replace_linux_executable(_package: &Path) -> Result<()> {
+    bail!("Linux executable replacement is unavailable on this platform")
+}
+
+#[cfg(windows)]
+fn replace_windows_executable(package: &Path) -> Result<()> {
+    let executable = env::current_exe().context("failed to locate the running executable")?;
+    let backup = executable.with_extension("old.exe");
+    match std::fs::remove_file(&backup) {
+        Ok(()) => {}
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+        Err(error) => return Err(error).context("failed to remove the previous executable backup"),
+    }
+
+    std::fs::rename(&executable, &backup)
+        .context("failed to move the running executable to its backup path")?;
+    if let Err(error) = std::fs::copy(package, &executable) {
+        let _ = std::fs::rename(&backup, &executable);
+        return Err(error).context("failed to install the new Windows executable");
+    }
+
+    // The renamed executable may stay locked until this process exits. A later
+    // update removes the backup if it cannot be deleted immediately.
+    let _ = std::fs::remove_file(backup);
+    Ok(())
+}
+
+#[cfg(not(windows))]
+fn replace_windows_executable(_package: &Path) -> Result<()> {
+    bail!("Windows executable replacement is unavailable on this platform")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn asset(name: &str) -> Asset {
+        Asset {
+            name: name.to_owned(),
+            browser_download_url: format!(
+                "https://github.com/LowderPlay/cheburcheck/releases/download/v0.5.0/{name}"
+            ),
+        }
+    }
+
+    #[test]
+    fn parses_versions_from_package_names() {
+        assert_eq!(
+            package_version(
+                "cheburprobe_1.2.3-1_arm64.deb",
+                PackageKind::Debian,
+                "arm64"
+            ),
+            Some(Version::new(1, 2, 3))
+        );
+        assert_eq!(
+            package_version(
+                "cheburprobe-1.2.3-r1_aarch64_generic.apk",
+                PackageKind::Apk,
+                "aarch64_generic"
+            ),
+            Some(Version::new(1, 2, 3))
+        );
+        assert_eq!(
+            package_version(
+                "cheburprobe_1.2.3-1_aarch64_generic.ipk",
+                PackageKind::Opkg,
+                "aarch64_generic"
+            ),
+            Some(Version::new(1, 2, 3))
+        );
+    }
+
+    #[test]
+    fn validates_repository_names() {
+        assert!(validate_repository("LowderPlay/cheburcheck").is_ok());
+        assert!(validate_repository("owner/repo/extra").is_err());
+        assert!(validate_repository("owner?x/repo").is_err());
+    }
+
+    #[test]
+    fn selects_each_package_format() {
+        let assets = vec![
+            asset("cheburprobe_0.5.0-1_arm64.deb"),
+            asset("cheburprobe-0.5.0-r1_aarch64_generic.apk"),
+            asset("cheburprobe_0.5.0-1_aarch64_generic.ipk"),
+            asset("luci-app-cheburprobe-0.5.0-r1.apk"),
+            asset("luci-app-cheburprobe_0.5.0-1_all.ipk"),
+            asset("cheburprobe-0.5.0-windows-x86_64.exe"),
+            asset("cheburprobe-0.5.0-linux-amd64"),
+        ];
+        let version = Version::new(0, 5, 0);
+        assert_eq!(
+            select_asset(&assets, PackageKind::Debian, "arm64")
+                .unwrap()
+                .0
+                .name,
+            "cheburprobe_0.5.0-1_arm64.deb"
+        );
+        assert_eq!(
+            select_asset(&assets, PackageKind::Apk, "aarch64_generic")
+                .unwrap()
+                .0
+                .name,
+            "cheburprobe-0.5.0-r1_aarch64_generic.apk"
+        );
+        assert_eq!(
+            select_asset(&assets, PackageKind::Opkg, "aarch64_generic")
+                .unwrap()
+                .0
+                .name,
+            "cheburprobe_0.5.0-1_aarch64_generic.ipk"
+        );
+        assert_eq!(
+            select_luci_asset(&assets, PackageKind::Apk, &version)
+                .unwrap()
+                .name,
+            "luci-app-cheburprobe-0.5.0-r1.apk"
+        );
+        assert_eq!(
+            select_luci_asset(&assets, PackageKind::Opkg, &version)
+                .unwrap()
+                .name,
+            "luci-app-cheburprobe_0.5.0-1_all.ipk"
+        );
+        assert_eq!(
+            select_asset(&assets, PackageKind::Windows, "x86_64")
+                .unwrap()
+                .0
+                .name,
+            "cheburprobe-0.5.0-windows-x86_64.exe"
+        );
+        assert_eq!(
+            select_asset(&assets, PackageKind::Linux, "amd64")
+                .unwrap()
+                .0
+                .name,
+            "cheburprobe-0.5.0-linux-amd64"
+        );
+    }
+}