feat(adbc): add --version and require the version to be installed

The adbc commands were pinned to the active version, unlike `ampup
install` which takes one. Add --version to install, list, and uninstall.

Resolving the version now also requires it to be installed. Installing
amp replaces the whole version directory, so drivers placed under a
version whose binaries are not there yet would be destroyed by the next
`ampup install`.

Part of edgeandnode/amp#2600.

Author: incrypto32

ampup/src/commands/adbc.rs

@@ -19,37 +19,35 @@ use crate::{
     version_manager::VersionManager,
 };
 
-/// Install an ADBC driver for the active amp version.
+/// Install an ADBC driver for an amp version (the active one by default).
 pub async fn install(
     driver: &str,
     install_dir: Option<PathBuf>,
     repo: String,
     github_token: Option<String>,
     arch: Option<String>,
     platform: Option<String>,
+    version: Option<String>,
 ) -> Result<()> {
     let driver = parse_driver(driver)?;
     let config = Config::new(install_dir)?;
     let github = GitHubClient::new(repo, token::resolve_github_token(github_token))?;
-    install_driver(&github, config, driver, arch, platform).await
+    install_driver(&github, config, driver, arch, platform, version).await
 }
 
-/// Fetch, verify, extract, and place `driver` for the active amp version using
-/// an already-constructed GitHub client. Split from [`install`] so tests can
+/// Fetch, verify, extract, and place `driver` for an amp version using an
+/// already-constructed GitHub client. Split from [`install`] so tests can
 /// inject a client pointed at a mock server.
 pub(crate) async fn install_driver(
     github: &GitHubClient,
     config: Config,
     driver: Driver,
     arch: Option<String>,
     platform: Option<String>,
+    version: Option<String>,
 ) -> Result<()> {
     let version_manager = VersionManager::new(config);
-
-    // Drivers are pinned to an installed amp version, so one must be active.
-    let version = version_manager
-        .get_current()?
-        .ok_or_else(|| anyhow!("no active amp version; run `ampup install` first"))?;
+    let version = resolve_version(&version_manager, version)?;
 
     let platform = resolve_platform(platform)?;
     let arch = resolve_arch(arch)?;
@@ -130,15 +128,18 @@ fn place_driver(staging: &Path, driver_dir: &Path, lib_name: &str) -> Result<()>
     Ok(())
 }
 
-/// List installed ADBC drivers for the active amp version.
-pub fn list(install_dir: Option<PathBuf>) -> Result<()> {
+/// List installed ADBC drivers for an amp version (the active one by default).
+pub fn list(install_dir: Option<PathBuf>, version: Option<String>) -> Result<()> {
     let config = Config::new(install_dir)?;
     let version_manager = VersionManager::new(config);
 
-    let Some(version) = version_manager.get_current()? else {
+    // Without an explicit version, having none active is an empty state rather
+    // than an error.
+    if version.is_none() && version_manager.get_current()?.is_none() {
         ui::info!("No active amp version");
         return Ok(());
-    };
+    }
+    let version = resolve_version(&version_manager, version)?;
 
     let drivers = installed_drivers(&version_manager.config().drivers_dir(&version))?;
     if drivers.is_empty() {
@@ -156,16 +157,17 @@ pub fn list(install_dir: Option<PathBuf>) -> Result<()> {
     Ok(())
 }
 
-/// Uninstall an ADBC driver from the active amp version.
-pub fn uninstall(install_dir: Option<PathBuf>, driver: &str) -> Result<()> {
+/// Uninstall an ADBC driver from an amp version (the active one by default).
+pub fn uninstall(
+    install_dir: Option<PathBuf>,
+    driver: &str,
+    version: Option<String>,
+) -> Result<()> {
     let driver = parse_driver(driver)?;
 
     let config = Config::new(install_dir)?;
     let version_manager = VersionManager::new(config);
-
-    let version = version_manager
-        .get_current()?
-        .ok_or_else(|| anyhow!("no active amp version; run `ampup install` first"))?;
+    let version = resolve_version(&version_manager, version)?;
 
     let driver_dir = version_manager
         .config()
@@ -190,6 +192,28 @@ pub fn uninstall(install_dir: Option<PathBuf>, driver: &str) -> Result<()> {
     Ok(())
 }
 
+/// Resolve the amp version to operate on: an explicit one, or the active one.
+///
+/// The version must already be installed. Installing amp replaces the whole
+/// version directory, so drivers placed under a version whose binaries are not
+/// there yet would be destroyed by the next `ampup install`.
+fn resolve_version(version_manager: &VersionManager, version: Option<String>) -> Result<String> {
+    let version = match version {
+        Some(version) => version,
+        None => version_manager
+            .get_current()?
+            .ok_or_else(|| anyhow!("no active amp version; run `ampup install` first"))?,
+    };
+
+    if !version_manager.is_installed(&version) {
+        bail!(
+            "amp {} is not installed; run `ampup install {version}` first",
+            ui::version(&version),
+        );
+    }
+    Ok(version)
+}
+
 /// The catalog drivers currently installed under `drivers_dir`.
 ///
 /// Only complete installs count: an entry must be a directory named after a

ampup/src/main.rs

@@ -185,7 +185,7 @@ enum SelfCommands {
 
 #[derive(Debug, clap::Subcommand)]
 enum AdbcCommands {
-    /// Install an ADBC driver for the active amp version
+    /// Install an ADBC driver for an amp version
     Install {
         /// Installation directory (defaults to $AMP_DIR or $XDG_CONFIG_HOME/.amp or $HOME/.amp)
         #[arg(long, env = "AMP_DIR")]
@@ -209,23 +209,35 @@ enum AdbcCommands {
         /// Override platform detection (linux, darwin)
         #[arg(long)]
         platform: Option<String>,
+
+        /// Amp version to install the driver for (defaults to the active one)
+        #[arg(long = "version")]
+        amp_version: Option<String>,
     },
 
-    /// List installed ADBC drivers for the active version
+    /// List installed ADBC drivers for an amp version
     List {
         /// Installation directory (defaults to $AMP_DIR or $XDG_CONFIG_HOME/.amp or $HOME/.amp)
         #[arg(long, env = "AMP_DIR")]
         install_dir: Option<std::path::PathBuf>,
+
+        /// Amp version to list drivers for (defaults to the active one)
+        #[arg(long = "version")]
+        amp_version: Option<String>,
     },
 
-    /// Uninstall an ADBC driver
+    /// Uninstall an ADBC driver from an amp version
     Uninstall {
         /// Installation directory (defaults to $AMP_DIR or $XDG_CONFIG_HOME/.amp or $HOME/.amp)
         #[arg(long, env = "AMP_DIR")]
         install_dir: Option<std::path::PathBuf>,
 
         /// Driver to uninstall (e.g. postgresql)
         driver: String,
+
+        /// Amp version to uninstall the driver from (defaults to the active one)
+        #[arg(long = "version")]
+        amp_version: Option<String>,
     },
 }
 
@@ -326,18 +338,31 @@ async fn run() -> anyhow::Result<()> {
                 github_token,
                 arch,
                 platform,
+                amp_version,
             } => {
-                commands::adbc::install(&driver, install_dir, repo, github_token, arch, platform)
-                    .await?;
+                commands::adbc::install(
+                    &driver,
+                    install_dir,
+                    repo,
+                    github_token,
+                    arch,
+                    platform,
+                    amp_version,
+                )
+                .await?;
             }
-            AdbcCommands::List { install_dir } => {
-                commands::adbc::list(install_dir)?;
+            AdbcCommands::List {
+                install_dir,
+                amp_version,
+            } => {
+                commands::adbc::list(install_dir, amp_version)?;
             }
             AdbcCommands::Uninstall {
                 install_dir,
                 driver,
+                amp_version,
             } => {
-                commands::adbc::uninstall(install_dir, &driver)?;
+                commands::adbc::uninstall(install_dir, &driver, amp_version)?;
             }
         },
         None => {

ampup/src/tests/it_adbc.rs

@@ -15,7 +15,10 @@ use crate::{
     commands::adbc,
     config::Config,
     github::GitHubClient,
-    tests::{fixtures::TempInstallDir, mock_github},
+    tests::{
+        fixtures::{MockBinary, TempInstallDir},
+        mock_github,
+    },
 };
 
 const LIB: &str = "libadbc_driver_postgresql.so";
@@ -45,6 +48,7 @@ async fn adbc_install_places_driver_and_manifest() {
     let temp = TempInstallDir::new().expect("temp install dir");
     let version = "v1.0.0";
     fs::write(temp.current_version_file(), version).expect("write active version");
+    MockBinary::create(&temp, version).expect("install version binaries");
 
     // The release asset the installer will fetch, plus its advertised digest.
     let tarball = make_targz(&[
@@ -75,6 +79,7 @@ async fn adbc_install_places_driver_and_manifest() {
         Driver::Postgresql,
         Some("x86_64".to_string()),
         Some("linux".to_string()),
+        None,
     )
     .await
     .expect("install should succeed");
@@ -102,6 +107,7 @@ async fn adbc_install_rejects_asset_without_digest() {
     let temp = TempInstallDir::new().expect("temp install dir");
     let version = "v1.0.0";
     fs::write(temp.current_version_file(), version).expect("write active version");
+    MockBinary::create(&temp, version).expect("install version binaries");
 
     let tarball = make_targz(&[
         (LIB, b"ELF"),
@@ -130,6 +136,7 @@ async fn adbc_install_rejects_asset_without_digest() {
         Driver::Postgresql,
         Some("x86_64".to_string()),
         Some("linux".to_string()),
+        None,
     )
     .await
     .expect_err("install should refuse an asset without a digest");
@@ -141,19 +148,51 @@ async fn adbc_install_rejects_asset_without_digest() {
     );
 }
 
+#[tokio::test]
+async fn adbc_install_refuses_a_version_that_is_not_installed() {
+    let temp = TempInstallDir::new().expect("temp install dir");
+    // v1.0.0 is active and installed; v2.0.0 has no binaries.
+    fs::write(temp.current_version_file(), "v1.0.0").expect("write active version");
+    MockBinary::create(&temp, "v1.0.0").expect("install version binaries");
+
+    // No mock server: resolving the version fails before anything is fetched.
+    let github = GitHubClient::with_api_base("http://127.0.0.1:1".to_string()).expect("client");
+    let config = Config::new(Some(temp.path().to_path_buf())).expect("config");
+
+    let err = adbc::install_driver(
+        &github,
+        config,
+        Driver::Postgresql,
+        Some("x86_64".to_string()),
+        Some("linux".to_string()),
+        Some("v2.0.0".to_string()),
+    )
+    .await
+    .expect_err("install should refuse a version that is not installed");
+    assert!(err.to_string().contains("is not installed"), "got: {err}");
+
+    // Installing amp replaces the whole version directory, so drivers must not
+    // be placed under a version whose binaries are not there yet.
+    assert!(
+        !temp.versions_dir().join("v2.0.0").exists(),
+        "no version directory should be created for an uninstalled version",
+    );
+}
+
 #[test]
 fn adbc_uninstall_removes_installed_driver() {
     let temp = TempInstallDir::new().expect("temp install dir");
     let version = "v1.0.0";
     fs::write(temp.current_version_file(), version).expect("write active version");
+    MockBinary::create(&temp, version).expect("install version binaries");
 
     let drivers_dir = temp.versions_dir().join(version).join("drivers");
     let driver_dir = drivers_dir.join("postgresql");
     fs::create_dir_all(&driver_dir).expect("driver dir");
     fs::write(driver_dir.join(LIB), b"ELF").expect("lib");
     fs::write(driver_dir.join("manifest.toml"), b"manifest_version = 1").expect("manifest");
 
-    adbc::uninstall(Some(temp.path().to_path_buf()), "postgresql")
+    adbc::uninstall(Some(temp.path().to_path_buf()), "postgresql", None)
         .expect("uninstall should succeed");
 
     assert!(!driver_dir.exists(), "driver directory removed");