WIP

Author: relrod

src/env.rs

@@ -1,5 +1,5 @@
 use crate::csmrc::Config;
-use crate::util::micromamba;
+use crate::micromamba::micromamba;
 
 use log::{debug, error, info};
 use serde::Deserialize;

src/main.rs

@@ -1,7 +1,7 @@
 mod csmrc;
 mod env;
+mod micromamba;
 mod robot;
-mod util;
 
 use crate::csmrc::Config;
 use clap::{Parser, Subcommand};

src/micromamba.rs

@@ -0,0 +1,65 @@
+//! This module deals with `micromamba` - obtaining it, calling it, etc.
+
+use crate::csmrc::Config;
+use log::debug;
+use std::collections::HashMap;
+use std::io::{Error, ErrorKind};
+use std::path::PathBuf;
+use std::process::Command;
+
+pub enum MicromambaLocation {
+    /// A working `micromamba` was found in `$PATH` already.
+    InPath,
+
+    /// A working `micromamba` exists at the given path.
+    Path(PathBuf),
+}
+
+/// Return a [`Command`] ready to shell out to `micromamba` with the appropriate
+/// environment variables set based on configuration.
+pub fn micromamba_at(location: MicromambaLocation, config: &Config, args: Vec<&str>) -> Command {
+    let mut env_vars: HashMap<&str, String> = HashMap::new();
+
+    if let Some(mamba_root_prefix) = &config.mamba_root_prefix {
+        env_vars.insert("MAMBA_ROOT_PREFIX", mamba_root_prefix.to_string());
+    }
+
+    let mut cmd = Command::new("micromamba");
+    cmd.args(args);
+    cmd.envs(env_vars);
+    debug!("About to run: {:?}", cmd);
+    cmd
+}
+
+pub fn micromamba(config: &Config, args: Vec<&str>) -> Result<Command, Error> {
+    match micromamba_path(config) {
+        None => Err(Error::from(ErrorKind::NotFound)),
+        Some(location) => Ok(micromamba_at(location, config, args))
+    }
+}
+
+/// We need a `micromamba` binary to work with. If one is not present, attempt
+/// to download and install `micromamba` into the user's cache directory. Return
+/// a [`MicromambaLocation`] with the result if we found a working `micromamba`.
+///
+/// 1. If there is already a `micromamba` command in $PATH, we use it.
+/// 2. Otherwise, download micromamba and install it somewhere in the user
+///    cache directory. (We cannot rely on this - it could be that the user's
+///    cache directory is mounted noexec or similar).
+///
+/// Alternative approaches that we do not take here currently:
+/// - On Linux, we *could* in theory use memfd_create + fexecve to embed the app
+///   and run it from memory. This won't work on Windows.
+///
+/// - 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_path(config: &Config) -> Option<MicromambaLocation> {
+    // Assume it's in $PATH already and see what happens.
+    if let Ok(output) = micromamba_at(MicromambaLocation::InPath, config, vec!["--version"]).output() {
+        // The full path doesn't matter, it's in $PATH
+        debug!("micromamba reported version {}", String::from_utf8_lossy(&output.stdout));
+        return Some(MicromambaLocation::InPath);
+    }
+    None
+}