feat: Auto-update network launcher after updating icp-cli (#401)

Author: adamspofford-dfinity

Cargo.lock

@@ -73,6 +73,7 @@ pkcs8 = { version = "0.10.2", features = ["encryption", "std"] }
 rand = "0.9.1"
 scrypt = "0.11.0"
 sec1 = { version = "0.7.3", features = ["pkcs8"] }
+semver = "1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_yaml = "0.9.34"

Cargo.toml

@@ -7,7 +7,7 @@ use icp::{
     identity::manifest::IdentityList,
     network::{
         Configuration,
-        managed::cache::{download_launcher_version, get_cached_launcher_version},
+        managed::cache::{download_launcher_version, get_cached_launcher_version_if_fresh},
         run_network,
     },
     settings::Settings,
@@ -127,7 +127,7 @@ pub(crate) async fn exec(ctx: &Context, args: &StartArgs) -> Result<(), anyhow::
         ctx.dirs
             .package_cache()?
             .with_write(async |pkg| {
-                if let Some(path) = get_cached_launcher_version(pkg.read(), version)? {
+                if let Some(path) = get_cached_launcher_version_if_fresh(pkg.read(), version)? {
                     anyhow::Ok(Some(path))
                 } else {
                     debug!("Downloading icp-cli-network-launcher version `{version}`");

crates/icp-cli/src/commands/network/start.rs

@@ -136,7 +136,7 @@ impl TestContext {
                 .into_write()
                 .await
                 .unwrap();
-            if let Some(path) = icp::network::managed::cache::get_cached_launcher_version(
+            if let Some(path) = icp::network::managed::cache::get_cached_launcher_version_if_fresh(
                 cache.as_ref().read(),
                 "latest",
             )

crates/icp-cli/tests/common/context.rs

@@ -51,6 +51,7 @@ rand = { workspace = true }
 reqwest = { workspace = true }
 schemars = { workspace = true }
 scrypt = { workspace = true }
+semver = { workspace = true }
 sec1 = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

crates/icp/Cargo.toml

@@ -7,17 +7,17 @@ use snafu::{ResultExt, Snafu};
 use tar::Archive;
 
 use crate::fs::lock::{LRead, LWrite};
-use crate::package::{PackageCachePaths, get_tag, set_tag};
+use crate::package::{PackageCachePaths, get_tag, get_tag_with_updater, set_tag_with_updater};
 use crate::prelude::*;
 
+const LAUNCHER_NAME: &str = "icp-cli-network-launcher";
+
 pub fn get_cached_launcher_version(
     paths: LRead<&PackageCachePaths>,
     version: &str,
 ) -> Result<Option<PathBuf>, ReadCacheError> {
     let declared_version = if version == "latest" {
-        let Some(version) =
-            get_tag(paths, "icp-cli-network-launcher", "latest").context(LoadTagSnafu)?
-        else {
+        let Some(version) = get_tag(paths, LAUNCHER_NAME, "latest").context(LoadTagSnafu)? else {
             return Ok(None);
         };
         version.to_owned()
@@ -27,12 +27,55 @@ pub fn get_cached_launcher_version(
     };
     let version_path = paths.launcher_version(&declared_version);
     if version_path.exists() {
-        Ok(Some(version_path.join("icp-cli-network-launcher")))
+        Ok(Some(version_path.join(LAUNCHER_NAME)))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Like [`get_cached_launcher_version`], but for the "latest" tag also checks
+/// whether the launcher was downloaded by an older CLI version, returning `None`
+/// if so. Pinned versions are never considered stale.
+pub fn get_cached_launcher_version_if_fresh(
+    paths: LRead<&PackageCachePaths>,
+    version: &str,
+) -> Result<Option<PathBuf>, ReadCacheError> {
+    let declared_version = if version == "latest" {
+        let (tag, updater) =
+            get_tag_with_updater(paths, LAUNCHER_NAME, "latest").context(LoadTagSnafu)?;
+        let Some(version) = tag else {
+            return Ok(None);
+        };
+        if is_updater_stale(updater.as_deref()) {
+            return Ok(None);
+        }
+        version
+    } else {
+        assert!(version.starts_with('v'));
+        version.to_owned()
+    };
+    let version_path = paths.launcher_version(&declared_version);
+    if version_path.exists() {
+        Ok(Some(version_path.join(LAUNCHER_NAME)))
     } else {
         Ok(None)
     }
 }
 
+/// Returns true if the given updater version is older than the current CLI version
+/// (or if no updater version is recorded).
+fn is_updater_stale(updater_version: Option<&str>) -> bool {
+    let Some(updater_version) = updater_version else {
+        return true;
+    };
+    let current = semver::Version::parse(env!("CARGO_PKG_VERSION"))
+        .expect("package versions should always be valid semver");
+    let Ok(stored) = semver::Version::parse(updater_version) else {
+        return true;
+    };
+    stored < current
+}
+
 #[derive(Debug, Snafu)]
 pub enum ReadCacheError {
     #[snafu(display("failed to read package tag"))]
@@ -67,7 +110,14 @@ pub async fn download_launcher_version(
 ) -> Result<(String, PathBuf), DownloadLauncherError> {
     let pkg_version = if version_req == "latest" {
         let latest = get_latest_launcher_version(client).await?;
-        set_tag(paths, "icp-cli-network-launcher", &latest, "latest").context(CreateTagSnafu)?;
+        set_tag_with_updater(
+            paths,
+            LAUNCHER_NAME,
+            &latest,
+            "latest",
+            env!("CARGO_PKG_VERSION"),
+        )
+        .context(CreateTagSnafu)?;
         latest
     } else {
         assert!(version_req.starts_with('v'));
@@ -136,7 +186,7 @@ pub async fn download_launcher_version(
         from: extracted_dir_path,
         to: &version_path,
     })?;
-    Ok((pkg_version, version_path.join("icp-cli-network-launcher")))
+    Ok((pkg_version, version_path.join(LAUNCHER_NAME)))
 }
 
 #[derive(Debug, Snafu)]

crates/icp/src/network/managed/cache.rs

@@ -251,7 +251,41 @@ pub fn set_tag(
     Ok(())
 }
 
+/// Like [`set_tag`], but also records the CLI version that performed the update.
+pub fn set_tag_with_updater(
+    paths: LWrite<&PackageCachePaths>,
+    tool: &str,
+    version: &str,
+    tag: &str,
+    updater_version: &str,
+) -> Result<(), crate::fs::json::Error> {
+    let mut manifest: Manifest = crate::fs::json::load_or_default(&paths.manifest())?;
+    manifest
+        .tags
+        .insert(format!("{tool}:{tag}"), version.to_string());
+    manifest
+        .updater_versions
+        .insert(tool.to_string(), updater_version.to_string());
+    crate::fs::json::save(&paths.manifest(), &manifest)?;
+    Ok(())
+}
+
+/// Like [`get_tag`], but also returns the updater version for the tool.
+/// Returns `(tag_value, updater_version)`.
+pub fn get_tag_with_updater(
+    paths: LRead<&PackageCachePaths>,
+    tool: &str,
+    tag: &str,
+) -> Result<(Option<String>, Option<String>), crate::fs::json::Error> {
+    let manifest: Manifest = crate::fs::json::load_or_default(&paths.manifest())?;
+    let tag_value = manifest.tags.get(&format!("{tool}:{tag}")).cloned();
+    let updater = manifest.updater_versions.get(tool).cloned();
+    Ok((tag_value, updater))
+}
+
 #[derive(Serialize, Deserialize, Default)]
 struct Manifest {
     tags: HashMap<String, String>,
+    #[serde(default)]
+    updater_versions: HashMap<String, String>,
 }