Add link and self-update

coolreader18 · coolreader18 · commit e296ddbdee25 · 2025-02-05T13:40:59.000-06:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/paths/Cargo.toml b/crates/paths/Cargo.toml
@@ -11,7 +11,6 @@ anyhow.workspace = true
 chrono = { workspace = true, features = ["now"] }
 fs2.workspace = true
 itoa.workspace = true
-semver.workspace = true
 serde.workspace = true
 thiserror.workspace = true
 
diff --git a/crates/paths/src/cli.rs b/crates/paths/src/cli.rs
@@ -1,3 +1,5 @@
+use std::path::Path;
+
 use anyhow::Context;
 
 use crate::utils::{path_type, PathBufExt};
@@ -30,53 +32,37 @@ path_type!(BinFile: file);
 path_type!(BinDir: dir);
 
 impl BinDir {
-    pub fn version_dir(&self, version: &semver::Version) -> VersionBinDir {
-        VersionBinDir(self.0.join(version.to_string()))
+    pub fn version_dir(&self, version: &str) -> VersionBinDir {
+        VersionBinDir(self.0.join(version))
     }
 
+    pub const CURRENT_VERSION_DIR_NAME: &str = "current";
     pub fn current_version_dir(&self) -> VersionBinDir {
-        VersionBinDir(self.0.join("current"))
+        VersionBinDir(self.0.join(Self::CURRENT_VERSION_DIR_NAME))
     }
 
-    pub fn set_current_version(&self, version: &semver::Version) -> anyhow::Result<()> {
-        let link_path = self.current_version_dir();
-        #[cfg(unix)]
-        {
-            // remove the link if it already exists
-            std::fs::remove_file(&link_path).ok();
-            std::os::unix::fs::symlink(version.to_string(), link_path)?;
-        }
-        #[cfg(windows)]
-        {
-            junction::delete(&link_path).ok();
-            let version_path = self.version_dir(version);
-            // We won't be able to create a junction if the fs isn't NTFS, so fall back to trying
-            // to make a symlink.
-            junction::create(&version_path, &link_path)
-                .or_else(|err| std::os::windows::fs::symlink_dir(version.to_string(), &link_path).or(Err(err)))?;
-        }
-        Ok(())
+    pub fn set_current_version(&self, version: &str) -> anyhow::Result<()> {
+        self.current_version_dir().link_to(self.version_dir(version).as_ref())
     }
 
-    pub fn current_version(&self) -> anyhow::Result<Option<semver::Version>> {
+    pub fn current_version(&self) -> anyhow::Result<Option<String>> {
         match std::fs::read_link(self.current_version_dir()) {
-            Ok(path) => path
-                .to_str()
-                .context("not utf8")
-                .and_then(|s| s.parse::<semver::Version>().map_err(Into::into))
-                .context("could not parse `current` symlink as a version number")
-                .map(Some),
+            Ok(path) => path.into_os_string().into_string().ok().context("not utf8").map(Some),
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
             Err(e) => Err(e.into()),
         }
     }
 
-    pub fn installed_versions(&self) -> anyhow::Result<Vec<semver::Version>> {
+    pub fn installed_versions(&self) -> anyhow::Result<Vec<String>> {
         self.read_dir()?
             .filter_map(|r| match r {
                 Ok(entry) => {
-                    let parsed: semver::Version = entry.file_name().to_str()?.parse().ok()?;
-                    Some(anyhow::Ok(parsed))
+                    let name = entry.file_name();
+                    if name == Self::CURRENT_VERSION_DIR_NAME {
+                        None
+                    } else {
+                        entry.file_name().into_string().ok().map(Ok)
+                    }
                 }
                 Err(e) => Some(Err(e.into())),
             })
@@ -90,6 +76,32 @@ impl VersionBinDir {
     pub fn spacetimedb_cli(self) -> SpacetimedbCliBin {
         SpacetimedbCliBin(self.0.joined("spacetimedb-cli").with_exe_ext())
     }
+
+    pub fn create_custom(&self, path: &Path) -> anyhow::Result<()> {
+        if std::fs::symlink_metadata(self).is_ok_and(|m| m.file_type().is_dir()) {
+            anyhow::bail!("version already exists");
+        }
+        self.link_to(path)
+    }
+
+    fn link_to(&self, path: &Path) -> anyhow::Result<()> {
+        let rel_path = path.strip_prefix(self).unwrap_or(path);
+        #[cfg(unix)]
+        {
+            // remove the link if it already exists
+            std::fs::remove_file(self).ok();
+            std::os::unix::fs::symlink(rel_path, self)?;
+        }
+        #[cfg(windows)]
+        {
+            junction::delete(self).ok();
+            // We won't be able to create a junction if the fs isn't NTFS, so fall back to trying
+            // to make a symlink.
+            junction::create(path, self)
+                .or_else(|err| std::os::windows::fs::symlink_dir(rel_path, self).or(Err(err)))?;
+        }
+        Ok(())
+    }
 }
 
 path_type!(SpacetimedbCliBin: file);
diff --git a/crates/update/src/cli.rs b/crates/update/src/cli.rs
@@ -4,9 +4,11 @@ use std::ffi::OsString;
 use std::future::Future;
 use std::process::ExitCode;
 
+use anyhow::Context;
 use spacetimedb_paths::{RootDir, SpacetimePaths};
 
 mod install;
+mod link;
 mod list;
 mod uninstall;
 mod upgrade;
@@ -36,6 +38,26 @@ impl Args {
                 crate::proxy::run_cli(Some(&paths), None, cli_args)
             }
             Subcommand::Version(version) => version.exec(&paths).map(|()| ExitCode::SUCCESS),
+            Subcommand::SelfInstall { install_latest } => {
+                let current_exe = std::env::current_exe().context("could not get current exe")?;
+                let suppress_eexists = |r: std::io::Result<()>| {
+                    r.or_else(|e| (e.kind() == std::io::ErrorKind::AlreadyExists).then_some(()).ok_or(e))
+                };
+                suppress_eexists(paths.cli_bin_dir.create()).context("could not create bin dir")?;
+                suppress_eexists(paths.cli_config_dir.create()).context("could not create config dir")?;
+                suppress_eexists(paths.data_dir.create()).context("could not create data dir")?;
+                paths
+                    .cli_bin_file
+                    .create_parent()
+                    .and_then(|()| std::fs::copy(&current_exe, &paths.cli_bin_file))
+                    .context("could not install binary")?;
+
+                if install_latest {
+                    upgrade::Upgrade {}.exec(&paths)?;
+                }
+
+                Ok(ExitCode::SUCCESS)
+            }
         }
     }
 }
@@ -48,6 +70,11 @@ enum Subcommand {
         #[clap(allow_hyphen_values = true)]
         args: Vec<OsString>,
     },
+    SelfInstall {
+        /// Download and install the latest CLI version after self-installing.
+        #[arg(long)]
+        install_latest: bool,
+    },
 }
 
 #[derive(clap::Args)]
@@ -66,6 +93,7 @@ impl Version {
             Upgrade(subcmd) => subcmd.exec(paths),
             Install(subcmd) => subcmd.exec(paths),
             Uninstall(subcmd) => subcmd.exec(paths),
+            Link(subcmd) => subcmd.exec(paths),
         }
     }
 }
@@ -77,6 +105,8 @@ enum VersionSubcommand {
     Upgrade(upgrade::Upgrade),
     Install(install::Install),
     Uninstall(uninstall::Uninstall),
+    #[command(hide = true)]
+    Link(link::Link),
 }
 
 fn reqwest_client() -> anyhow::Result<reqwest::Client> {
diff --git a/crates/update/src/cli/install.rs b/crates/update/src/cli/install.rs
@@ -41,7 +41,7 @@ impl Install {
             let client = super::reqwest_client()?;
             let version = download_and_install(&client, Some(self.version), self.artifact_name, paths).await?;
             if self.r#use {
-                paths.cli_bin_dir.set_current_version(&version)?;
+                paths.cli_bin_dir.set_current_version(&version.to_string())?;
             }
             Ok(())
         })?
@@ -109,7 +109,7 @@ pub(super) async fn download_and_install(
     pb.set_style(pb_style);
     pb.set_message("unpacking...");
 
-    let version_dir = paths.cli_bin_dir.version_dir(&release_version);
+    let version_dir = paths.cli_bin_dir.version_dir(&release_version.to_string());
     match artifact_type {
         ArtifactType::TarGz => {
             let tgz = archive.aggregate().reader();
@@ -144,11 +144,14 @@ impl ArtifactType {
     }
 }
 
-pub(super) async fn available_releases(client: &reqwest::Client) -> anyhow::Result<Vec<semver::Version>> {
+pub(super) async fn available_releases(client: &reqwest::Client) -> anyhow::Result<Vec<String>> {
     let url = "https://api.github.com/repos/clockworklabs/SpacetimeDB/releases";
     let releases: Vec<Release> = client.get(url).send().await?.json().await?;
 
-    releases.into_iter().map(|release| release.version()).collect()
+    releases
+        .into_iter()
+        .map(|release| Ok(release.version()?.to_string()))
+        .collect()
 }
 
 #[derive(Deserialize)]
diff --git a/crates/update/src/cli/link.rs b/crates/update/src/cli/link.rs
@@ -0,0 +1,38 @@
+use std::path::PathBuf;
+
+use anyhow::Context;
+use spacetimedb_paths::cli::BinDir;
+use spacetimedb_paths::SpacetimePaths;
+
+/// Set a local installation of SpacetimeDB as a custom version.
+#[derive(clap::Args)]
+pub(super) struct Link {
+    /// The name of the custom installation, e.g. `dev`.
+    name: String,
+    /// The path to the directory with the SpacetimeDB binaries.
+    path: PathBuf,
+
+    /// Switch to this version after it's created.
+    #[arg(long)]
+    r#use: bool,
+}
+
+impl Link {
+    pub(super) fn exec(self, paths: &SpacetimePaths) -> anyhow::Result<()> {
+        anyhow::ensure!(
+            self.name != BinDir::CURRENT_VERSION_DIR_NAME,
+            "name cannot be `current`"
+        );
+        let mut path = std::env::current_dir()?;
+        path.push(self.path);
+        paths
+            .cli_bin_dir
+            .version_dir(&self.name)
+            .create_custom(&path)
+            .context("could not link custom version")?;
+        if self.r#use {
+            paths.cli_bin_dir.set_current_version(&self.name)?;
+        }
+        Ok(())
+    }
+}
diff --git a/crates/update/src/cli/uninstall.rs b/crates/update/src/cli/uninstall.rs
@@ -1,18 +1,33 @@
+use anyhow::Context;
+use spacetimedb_paths::cli::BinDir;
 use spacetimedb_paths::SpacetimePaths;
 
 use super::ForceYes;
 
 /// Uninstall an installed SpacetimeDB version.
 #[derive(clap::Args)]
 pub(super) struct Uninstall {
-    version: semver::Version,
+    version: String,
     #[command(flatten)]
     yes: ForceYes,
 }
 
 impl Uninstall {
     pub(super) fn exec(self, paths: &SpacetimePaths) -> anyhow::Result<()> {
         let Self { version, yes } = self;
+        anyhow::ensure!(
+            version != BinDir::CURRENT_VERSION_DIR_NAME,
+            "cannot remove `current` version"
+        );
+        match paths
+            .cli_bin_dir
+            .current_version()
+            .context("couldn't read current version")
+        {
+            Ok(Some(current)) => anyhow::ensure!(version != current, "cannot uninstall currently used version"),
+            Ok(None) => {}
+            Err(e) => tracing::warn!("{e:#}"),
+        }
         if yes.confirm(format!("Uninstall v{version}?"))? {
             let dir = paths.cli_bin_dir.version_dir(&version);
             std::fs::remove_dir_all(dir)?;
diff --git a/crates/update/src/cli/upgrade.rs b/crates/update/src/cli/upgrade.rs
@@ -9,11 +9,15 @@ impl Upgrade {
         super::tokio_block_on(async {
             let client = super::reqwest_client()?;
             let version = super::install::download_and_install(&client, None, None, paths).await?;
-            paths.cli_bin_dir.set_current_version(&version)?;
+            paths.cli_bin_dir.set_current_version(&version.to_string())?;
 
             let cur_version = semver::Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
             if version > cur_version {
-                let mut new_update_binary = paths.cli_bin_dir.version_dir(&version).0.join("spacetimedb-update");
+                let mut new_update_binary = paths
+                    .cli_bin_dir
+                    .version_dir(&version.to_string())
+                    .0
+                    .join("spacetimedb-update");
                 new_update_binary.set_extension(std::env::consts::EXE_EXTENSION);
                 if new_update_binary.exists() {
                     tokio::fs::copy(new_update_binary, &paths.cli_bin_file).await?;
diff --git a/crates/update/src/cli/use.rs b/crates/update/src/cli/use.rs
@@ -8,6 +8,6 @@ pub(super) struct Use {
 
 impl Use {
     pub(super) fn exec(self, paths: &SpacetimePaths) -> anyhow::Result<()> {
-        paths.cli_bin_dir.set_current_version(&self.version)
+        paths.cli_bin_dir.set_current_version(&self.version.to_string())
     }
 }
diff --git a/crates/update/src/main.rs b/crates/update/src/main.rs
@@ -19,7 +19,13 @@ fn main() -> anyhow::Result<ExitCode> {
     if cmd == "spacetimedb-update" {
         spacetimedb_update_main()
     } else if cmd == "spacetime" {
-        proxy::run_cli(None, Some(argv0.as_os_str()), args.collect())
+        let args = args.collect::<Vec<_>>();
+        if args.first().is_some_and(|s| s == "version") {
+            // if the first arg is unambiguously `version`, go straight to `spacetime version`
+            spacetimedb_update_main()
+        } else {
+            proxy::run_cli(None, Some(argv0.as_os_str()), args)
+        }
     } else {
         anyhow::bail!(
             "unknown command name for spacetimedb-update multicall binary: {}",

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ pub(super) struct Use {`
`8`	`8`
`9`	`9`	`impl Use {`
`10`	`10`	`pub(super) fn exec(self, paths: &SpacetimePaths) -> anyhow::Result<()> {`
`11`		`- paths.cli_bin_dir.set_current_version(&self.version)`
	`11`	`+ paths.cli_bin_dir.set_current_version(&self.version.to_string())`
`12`	`12`	`}`
`13`	`13`	`}`