Move csm env unpack out

Author: relrod

src/env/mod.rs

@@ -8,10 +8,9 @@ pub mod unpack;
 
 use crate::csmrc::Config;
 use crate::env::parsing::env_file::RobotmkEnv;
-use crate::micromamba::{self, MicromambaResult, micromamba};
+use crate::micromamba::{MicromambaResult, micromamba};
 
 use log::{debug, error, info};
-use std::fs;
 use std::path::{Component, Path, PathBuf};
 use std::process::ExitCode;
 
@@ -125,74 +124,6 @@ pub fn run(config: Config, subcommand: Subcommand) -> Result<(), ExitCode> {
         Subcommand::Activate(args) => activate::run(config, args),
         Subcommand::Deactivate => deactivate::run(),
         Subcommand::Pack(args) => pack::run(config, args),
-        Subcommand::Unpack(args) => {
-            fn archive_name_to_env_name(archive_path: &Path) -> Option<String> {
-                let filename = archive_path.file_name()?.to_str()?;
-                filename
-                    .strip_suffix(".tar.gz")
-                    .or_else(|| filename.strip_suffix(".tgz"))
-                    .map(String::from)
-            }
-            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
-                        );
-                        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()
-        }
+        Subcommand::Unpack(args) => unpack::run(config, args),
     }
 }

src/env/unpack.rs

@@ -1,6 +1,11 @@
-use crate::env::CommonArgs;
+use crate::csmrc::Config;
+use crate::env::{CommonArgs, dump_micromamba_captured_output_on_error};
+use crate::micromamba::{self, micromamba};
 
-use std::path::PathBuf;
+use log::{debug, error, info};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::ExitCode;
 
 #[derive(Debug, clap::Args)]
 pub struct Args {
@@ -11,3 +16,73 @@ pub struct Args {
     #[arg(value_name = "ARCHIVE")]
     pub archive_path: PathBuf,
 }
+
+pub fn run(config: Config, args: Args) -> Result<(), ExitCode> {
+    fn archive_name_to_env_name(archive_path: &Path) -> Option<String> {
+        let filename = archive_path.file_name()?.to_str()?;
+        filename
+            .strip_suffix(".tar.gz")
+            .or_else(|| filename.strip_suffix(".tgz"))
+            .map(String::from)
+    }
+    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
+                );
+                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()
+}