Be able to capture, instead of stream, micromamba

In some commands, e.g. `csm env create` we don't want to always show the
output. Now we capture it and only show it if there was an error.

Author: relrod

src/csmrc.rs

@@ -20,6 +20,12 @@ pub struct Config {
 
     /// If false, skip downloading micromamba even if needed (for testing).
     pub download_micromamba: bool,
+
+    /// (Internal) If true, the program is being run in verbose mode.
+    /// We do not support this being set from the configuration file, because
+    /// the configuration file is parsed after logging is initialized. The user
+    /// can technically do it, we won't error, but it won't have much effect.
+    pub verbose: bool,
 }
 
 #[allow(clippy::derivable_impls)]
@@ -30,6 +36,7 @@ impl Default for Config {
             noop_mode: false,
             cache_dir: None,
             download_micromamba: true,
+            verbose: false,
         }
     }
 }

src/env.rs

@@ -1,5 +1,5 @@
 use crate::csmrc::Config;
-use crate::micromamba::micromamba;
+use crate::micromamba::{MicromambaResult, micromamba};
 use crate::shell::SupportedShell;
 
 use log::{debug, error, info};
@@ -112,6 +112,10 @@ pub fn run(config: Config, subcommand: Subcommand) -> ExitCode {
                 error!("No environment name could be determined. You can specify one with --name");
                 return ExitCode::FAILURE;
             };
+            info!(
+                "Creating environment '{}' - this may take some time...",
+                env_name
+            );
             let result = micromamba(
                 &config,
                 vec![
@@ -123,19 +127,32 @@ pub fn run(config: Config, subcommand: Subcommand) -> ExitCode {
                     &env_name,
                     "--yes",
                 ],
+                config.verbose,
             );
-            result.exit_code()
+            let rc = result.exit_code();
+            match result {
+                MicromambaResult::CapturedOutput(output) if rc != ExitCode::SUCCESS => {
+                    error!("Got a non-zero exit code from micromamba, dumping output:");
+                    error!("micromamba stdout:");
+                    println!("{}", String::from_utf8_lossy(&output.stdout));
+                    error!("micromamba stderr:");
+                    println!("{}", String::from_utf8_lossy(&output.stderr));
+                }
+                MicromambaResult::CapturedOutput(_) if rc == ExitCode::SUCCESS => info!("Done."),
+                _ => {}
+            }
+            rc
         }
-        Subcommand::List => micromamba(&config, vec!["env", "list"]).exit_code(),
-        Subcommand::Info => micromamba(&config, vec!["info"]).exit_code(),
+        Subcommand::List => micromamba(&config, vec!["env", "list"], true).exit_code(),
+        Subcommand::Info => micromamba(&config, vec!["info"], true).exit_code(),
         Subcommand::Run(args) => {
             let Some(env_name) = determine_env_name(args.name) else {
                 error!("No environment name could be determined. You can specify one with --name");
                 return ExitCode::FAILURE;
             };
             let mut micromamba_args = vec!["run", "--name", &env_name, &args.command];
             micromamba_args.extend(args.arguments.iter().map(|s| s.as_str()));
-            micromamba(&config, micromamba_args).exit_code()
+            micromamba(&config, micromamba_args, true).exit_code()
         }
         Subcommand::Activate => {
             // TODO: handle env name similar to run/create

src/main.rs

@@ -76,6 +76,10 @@ fn main() -> ExitCode {
         config.noop_mode = true;
     }
 
+    if cli.verbose {
+        config.verbose = true;
+    }
+
     let Some(home) = std::env::home_dir() else {
         error!("Failed to determine home directory");
         return ExitCode::FAILURE;

src/micromamba.rs

@@ -6,7 +6,7 @@ use std::collections::HashMap;
 use std::fs;
 use std::io;
 use std::path::{Path, PathBuf};
-use std::process::{Command, ExitCode, ExitStatus};
+use std::process::{Command, ExitCode, ExitStatus, Output};
 
 /// The result from trying to shell out to `micromamba`.
 ///
@@ -20,8 +20,11 @@ use std::process::{Command, ExitCode, ExitStatus};
 pub enum MicromambaResult {
     /// We were run in no-op mode, so we didn't actually call out to it
     Noop,
-    /// We were able to successfully call it and get a result
-    Ok(ExitStatus),
+    /// We were able to successfully call it and get a result, though we streamed
+    /// the output and did not save it.
+    StreamedOutput(ExitStatus),
+    /// We were able to successfully call it and get a result, capturing output.
+    CapturedOutput(Output),
     /// We were unable to find or create a working `micromamba`
     NotFound,
     /// We found a micromamba binary, but could not run it
@@ -30,11 +33,16 @@ pub enum MicromambaResult {
 
 impl MicromambaResult {
     pub fn exit_code(&self) -> ExitCode {
-        match self {
-            Self::Ok(exit_status) => exit_status
+        let to_code = |status: &ExitStatus| {
+            status
                 .code()
                 .map(|c| ExitCode::from(c as u8))
-                .unwrap_or(ExitCode::FAILURE),
+                .unwrap_or(ExitCode::FAILURE)
+        };
+
+        match self {
+            Self::StreamedOutput(exit_status) => to_code(exit_status),
+            Self::CapturedOutput(output) => to_code(&output.status),
             Self::Noop => ExitCode::SUCCESS,
             _ => ExitCode::FAILURE,
         }
@@ -102,7 +110,7 @@ fn block_on_child_exit(child: &mut std::process::Child) -> MicromambaResult {
     match child.wait() {
         Ok(exit_status) => {
             debug!("micromamba exited with status: {}", exit_status);
-            MicromambaResult::Ok(exit_status)
+            MicromambaResult::StreamedOutput(exit_status)
         }
         Err(e) => {
             error!("We found a micromamba binary, but failed to wait for it to run");
@@ -112,17 +120,32 @@ fn block_on_child_exit(child: &mut std::process::Child) -> MicromambaResult {
     }
 }
 
-fn exec_micromamba(cmd: &mut Command) -> MicromambaResult {
-    match cmd.spawn() {
-        Ok(mut child) => block_on_child_exit(&mut child),
-        Err(e) if e.kind() == io::ErrorKind::NotFound => {
-            debug!("Could not run micromamba at specified path: {}", e);
-            MicromambaResult::NotFound
+fn exec_micromamba(cmd: &mut Command, stream_output: bool) -> MicromambaResult {
+    if stream_output {
+        match cmd.spawn() {
+            Ok(mut child) => block_on_child_exit(&mut child),
+            Err(e) if e.kind() == io::ErrorKind::NotFound => {
+                debug!("Could not run micromamba at specified path: {}", e);
+                MicromambaResult::NotFound
+            }
+            Err(e) => {
+                error!("We found a micromamba binary, but failed to run it");
+                error!("Error was: {}", e);
+                MicromambaResult::CouldNotRun
+            }
         }
-        Err(e) => {
-            error!("We found a micromamba binary, but failed to run it");
-            error!("Error was: {}", e);
-            MicromambaResult::CouldNotRun
+    } else {
+        match cmd.output() {
+            Ok(output) => MicromambaResult::CapturedOutput(output),
+            Err(e) if e.kind() == io::ErrorKind::NotFound => {
+                debug!("Could not run micromamba at specified path: {}", e);
+                MicromambaResult::NotFound
+            }
+            Err(e) => {
+                error!("We found a micromamba binary, but failed to run it");
+                error!("Error was: {}", e);
+                MicromambaResult::CouldNotRun
+            }
         }
     }
 }
@@ -144,7 +167,7 @@ fn exec_micromamba(cmd: &mut Command) -> MicromambaResult {
 /// - We *could* embed the micromamba binary in our binary (Windows or Linux
 ///   based on compile target) and write it to the user cache directory rather
 ///   than downloading it. But this inflates our binary size.
-pub fn micromamba(config: &Config, args: Vec<&str>) -> MicromambaResult {
+pub fn micromamba(config: &Config, args: Vec<&str>, stream_output: bool) -> MicromambaResult {
     let mut cmd = micromamba_at("micromamba", config, &args);
 
     if config.noop_mode {
@@ -154,8 +177,8 @@ pub fn micromamba(config: &Config, args: Vec<&str>) -> MicromambaResult {
 
     // If we were able to get a result using micromamba found in $PATH, then
     // we're done.
-    match exec_micromamba(&mut cmd) {
-        ok @ MicromambaResult::Ok(_) => {
+    match exec_micromamba(&mut cmd, stream_output) {
+        ok @ (MicromambaResult::StreamedOutput(_) | MicromambaResult::CapturedOutput(_)) => {
             debug!("Ran micromamba found in $PATH");
             return ok;
         }
@@ -179,8 +202,8 @@ pub fn micromamba(config: &Config, args: Vec<&str>) -> MicromambaResult {
         }
     };
     let mut cmd = micromamba_at(&downloaded_path.to_string_lossy(), config, &args);
-    match exec_micromamba(&mut cmd) {
-        ok @ MicromambaResult::Ok(_) => {
+    match exec_micromamba(&mut cmd, stream_output) {
+        ok @ (MicromambaResult::StreamedOutput(_) | MicromambaResult::CapturedOutput(_)) => {
             debug!(
                 "Ran downloaded/cached micromamba at {}",
                 downloaded_path.display()

tests/env.rs

@@ -11,7 +11,7 @@ fn csm_env_create(csm: &mut common::Csm, name: &str) -> Result<(), Error> {
         .current_dir(common::tests_dir().join("micromamba-minimal"))
         .assert()
         .success()
-        .stdout(predicate::str::contains("Transaction finished"));
+        .stderr(predicate::str::contains("Done."));
     Ok(())
 }