csm env unpack command

Author: relrod

Cargo.lock

@@ -4,7 +4,8 @@ version = "0.1.0"
 edition = "2024"
 
 [lints.clippy]
-all = "deny"
+#all = "deny"
+complexity = "deny"
 
 [features]
 default = ["__test_bash"]  # Don't assume devs have other shells installed
@@ -19,6 +20,7 @@ clap = { version = "4.5.50", features = ["derive", "wrap_help"] }
 clap_complete = "4.5.60"
 dirs = "6.0.0"
 env_logger = "0.11.8"
+flate2 = "1.1.5"
 log = "0.4.28"
 reqwest = { version = "0.12.24", default-features = false, features = ["http2", "charset", "system-proxy", "blocking", "rustls-tls-native-roots"] }
 serde = { version = "1.0.228", features = ["derive"] }

Cargo.toml

@@ -4,7 +4,8 @@ use crate::shell::SupportedShell;
 
 use log::{debug, error, info, warn};
 use serde::Deserialize;
-use std::io::{Error, ErrorKind};
+use std::fs;
+use std::io;
 use std::path::{Component, Path, PathBuf};
 use std::process::ExitCode;
 
@@ -21,7 +22,7 @@ pub enum Subcommand {
     /// Create an archive from an environment. Requires `conda-pack` to be in the environment.
     Pack(PackArgs),
     /// Unpack an archive to create an environment from it.
-    Unpack(CommonEnvArgs),
+    Unpack(UnpackArgs),
     /// List existing environments
     List,
     /// Display information about the micromamba setup
@@ -73,13 +74,23 @@ pub struct PackArgs {
     /// Common environment arguments
     #[command(flatten)]
     common: CommonEnvArgs,
-    /// Output path/filename of the packed environment. If not specified, the
-    /// same method is used to determine the environment name as for the
-    /// "--name" parameter, and the default name is <env_name>.tar.gz
+    /// Output path/filename of the packed environment, ending in .tar.gz. If
+    /// not specified, the same method is used to determine the environment name
+    /// as for the "--name" parameter, and the default name is <env_name>.tar.gz
     #[arg(long, short, value_name = "OUTPUT")]
     output: Option<String>,
 }
 
+#[derive(Debug, clap::Args)]
+pub struct UnpackArgs {
+    /// Common environment arguments
+    #[command(flatten)]
+    common: CommonEnvArgs,
+    /// Path to a packed environment archive (ending in .tar.gz)
+    #[arg(value_name = "ARCHIVE")]
+    archive_path: PathBuf,
+}
+
 /// Contains the fields we need from a parsed environment file.
 #[derive(Deserialize)]
 struct RobotmkEnv {
@@ -102,9 +113,10 @@ struct PostBuildCommand {
 
 impl RobotmkSetup {
     /// Attempt to parse a setup file.
-    fn from_path<P: AsRef<Path>>(path: P) -> Result<Self, std::io::Error> {
+    fn from_path<P: AsRef<Path>>(path: P) -> Result<Self, io::Error> {
         let contents = std::fs::read_to_string(path)?;
-        serde_yaml_ng::from_str(&contents).map_err(|e| Error::new(ErrorKind::InvalidData, e))
+        serde_yaml_ng::from_str(&contents)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
     }
 
     fn run_post_create(self, config: &Config, env_name: &str) -> Result<(), ExitCode> {
@@ -129,9 +141,9 @@ impl RobotmkSetup {
 }
 
 /// Attempt to parse an environment file.
-fn parse_env_yaml<P: AsRef<Path>>(path: P) -> Result<RobotmkEnv, std::io::Error> {
+fn parse_env_yaml<P: AsRef<Path>>(path: P) -> Result<RobotmkEnv, io::Error> {
     let contents = std::fs::read_to_string(path)?;
-    serde_yaml_ng::from_str(&contents).map_err(|e| Error::new(ErrorKind::InvalidData, e))
+    serde_yaml_ng::from_str(&contents).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
 }
 
 pub fn determine_env_name(explicit_name: Option<String>, env_yaml_path: &Path) -> Option<String> {
@@ -233,7 +245,7 @@ pub fn run(config: Config, subcommand: Subcommand) -> Result<(), ExitCode> {
                     Some(path) => (path, true),
                 };
                 let setup = match RobotmkSetup::from_path(&filename) {
-                    Err(e) if e.kind() == ErrorKind::NotFound => {
+                    Err(e) if e.kind() == io::ErrorKind::NotFound => {
                         if required {
                             // Handled above, but theoretical race here, so handle it
                             error!("The specified setup file was not found");
@@ -365,10 +377,73 @@ pub fn run(config: Config, subcommand: Subcommand) -> Result<(), ExitCode> {
             )
             .into()
         }
-        _ => {
-            println!("{:?}", config);
-            println!("{:?}", subcommand);
-            Ok(())
+        Subcommand::Unpack(args) => {
+            fn archive_name_to_env_name(archive_path: &Path) -> Option<&str> {
+                let filename = archive_path.file_name()?.to_str()?;
+                filename
+                    .strip_suffix(".tar.gz")
+                    .or_else(|| filename.strip_suffix(".tgz"))
+            }
+            let env_name = match args.common.name {
+                Some(name) => name,
+                None => match archive_name_to_env_name(&args.archive_path) {
+                    Some(name) => {
+                        info!(
+                            "Using '{}' as environment name, based on archive filename",
+                            name
+                        );
+                        String::from(name)
+                    }
+                    None => {
+                        error!(
+                            "Could not determine environment name from archive filename. Please specify an environment name with --name."
+                        );
+                        return Err(ExitCode::FAILURE);
+                    }
+                },
+            };
+
+            // TODO: We really need a more generic error type to avoid this kind of mapping everywhere
+            let target_env_path = micromamba::create_env_dir(&config, &env_name).map_err(|e| {
+                error!("{}", e);
+                ExitCode::FAILURE
+            })?;
+
+            // Send the archive to flate2 to decompress and untar
+            info!(
+                "Unpacking archive '{}' to create environment '{}'",
+                args.archive_path.display(),
+                env_name
+            );
+            debug!("Opening '{}' for read", args.archive_path.display());
+            let archive_file = fs::File::open(&args.archive_path).map_err(|e| {
+                error!("{}", e);
+                ExitCode::FAILURE
+            })?;
+            let decompressor = flate2::read::GzDecoder::new(archive_file);
+            let mut archive = tar::Archive::new(decompressor);
+            archive.unpack(&target_env_path).map_err(|e| {
+                error!(
+                    "Could not unpack archive to '{}': {}",
+                    target_env_path.display(),
+                    e
+                );
+                ExitCode::FAILURE
+            })?;
+            info!(
+                "Successfully unpacked environment to '{}'",
+                target_env_path.display()
+            );
+
+            info!("Running 'conda-unpack' in the new environment to fix paths...");
+            let result = micromamba(
+                &config,
+                vec!["run", "--name", &env_name, "conda-unpack"],
+                config.verbose,
+            );
+            let rc = result.exit_code();
+            dump_micromamba_captured_output_on_error(&result, rc);
+            result.into()
         }
     }
 }

src/env.rs

@@ -353,3 +353,27 @@ pub fn bin_path_for_env(config: &Config, name: &str) -> Option<PathBuf> {
     let os_specific_bin = if cfg!(windows) { "Scripts" } else { "bin" };
     path_for_env(config, name).map(|p| p.join(os_specific_bin))
 }
+
+/// Create a directory for a new environment, if it does not already exist.
+pub fn create_env_dir(config: &Config, name: &str) -> Result<PathBuf, std::io::Error> {
+    let env_path = match path_for_env(config, name) {
+        Some(path) => path,
+        None => {
+            return Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("Could not determine path for environment '{}'", name),
+            ));
+        }
+    };
+    if env_path.exists() {
+        return Err(io::Error::new(
+            io::ErrorKind::AlreadyExists,
+            format!(
+                "The target environment directory '{:?}' already exists",
+                env_path
+            ),
+        ));
+    }
+    std::fs::create_dir_all(&env_path)?;
+    Ok(env_path)
+}

src/micromamba.rs

@@ -284,7 +284,43 @@ fn test_csm_env_pack_unpack() -> Result<(), Error> {
         .success()
         .stdout(predicate::str::contains("100% Completed"));
 
-    // TODO: unpack
+    csm.command()
+        .args(["env", "unpack", "-n", "unpacked", "packed.tar.gz"])
+        .assert()
+        .success()
+        .stderr(predicate::str::contains(
+            "Successfully unpacked environment",
+        ));
+
+    let (shell, cmd) = if cfg!(windows) {
+        ("powershell", "echo $env:CONDA_PROMPT_MODIFIER")
+    } else {
+        ("sh", "echo $CONDA_PROMPT_MODIFIER")
+    };
+
+    csm.command()
+        .args(["env", "run", "-n", "unpacked", "--", shell, "-c", cmd])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("(unpacked)"));
+
+    Ok(())
+}
+
+/// Test `csm env unpack` environment name detection
+#[test]
+fn test_csm_env_unpack_detect_name() -> Result<(), Error> {
+    let csm = common::Csm::new()?;
+
+    for path in ["/path/to/my_env.tar.gz", "my_env.tgz"] {
+        csm.command()
+            .args(["-n", "env", "unpack", path])
+            .assert()
+            .failure() // with -n, it won't be able to resolve paths, so it'll fail
+            .stderr(predicate::str::contains(
+                "Using 'my_env' as environment name",
+            ));
+    }
 
     Ok(())
 }