Add a no-op mode

Author: relrod

src/csmrc.rs

@@ -6,12 +6,26 @@ use serde::Deserialize;
 use std::default::Default;
 use std::io::{Error, ErrorKind};
 
-#[derive(Debug, Default, Deserialize)]
+#[derive(Debug, Deserialize)]
 pub struct Config {
     /// Override the $MAMBA_ROOT_PREFIX when shelling out to micromamba.
     #[serde(default)]
-    #[allow(dead_code)]
     pub mamba_root_prefix: Option<String>,
+
+    /// If true, don't make any changes or call any commands, just print what
+    /// we *would* do normally.
+    #[serde(default)]
+    pub noop_mode: bool,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for Config {
+    fn default() -> Self {
+        Config {
+            mamba_root_prefix: None,
+            noop_mode: false,
+        }
+    }
 }
 
 impl Config {

src/env.rs

@@ -1,7 +1,7 @@
 use crate::csmrc::Config;
 use crate::util::micromamba;
 
-use log::{debug, error};
+use log::{debug, error, info};
 use serde::Deserialize;
 use std::io::{Error, ErrorKind};
 use std::path::Component;
@@ -96,8 +96,8 @@ pub fn run(config: Config, subcommand: Subcommand) -> ExitCode {
                 error!("No environment name could be determined. You can specify one with --name");
                 return ExitCode::FAILURE;
             };
-            let cmd = micromamba(
-                config,
+            let mut cmd = micromamba(
+                &config,
                 vec![
                     "env",
                     "create",
@@ -107,19 +107,22 @@ pub fn run(config: Config, subcommand: Subcommand) -> ExitCode {
                     &env_name,
                     "--yes",
                 ],
-            )
-            .spawn()
-            .expect("failed to call micromamba")
-            .wait();
-            match cmd {
-                // Exit with whatever code micromamba gives us
-                Ok(exit_status) => exit_status
-                    .code()
-                    .map(|c| ExitCode::from(c as u8))
-                    .unwrap_or(ExitCode::FAILURE),
-                Err(e) => {
-                    error!("Failed to spawn micromamba: {}", e);
-                    ExitCode::FAILURE
+            );
+            if config.noop_mode {
+                info!("Would run: {:?}", cmd);
+                ExitCode::SUCCESS
+            } else {
+                let cmd = cmd.spawn().expect("failed to call micromamba").wait();
+                match cmd {
+                    // Exit with whatever code micromamba gives us
+                    Ok(exit_status) => exit_status
+                        .code()
+                        .map(|c| ExitCode::from(c as u8))
+                        .unwrap_or(ExitCode::FAILURE),
+                    Err(e) => {
+                        error!("Failed to spawn micromamba: {}", e);
+                        ExitCode::FAILURE
+                    }
                 }
             }
         }

src/main.rs

@@ -3,8 +3,9 @@ mod env;
 mod robot;
 mod util;
 
+use crate::csmrc::Config;
 use clap::{Parser, Subcommand};
-use log::{LevelFilter, debug, error, warn};
+use log::{LevelFilter, debug, error, info, warn};
 use std::fs::File;
 use std::io::Write;
 use std::path::Path;
@@ -14,9 +15,14 @@ use std::process::ExitCode;
 #[command(version)]
 /// Checkmk synthetic monitoring command-line tool
 struct Cli {
+    /// Enable verbose debugging output
     #[arg(short, long)]
     verbose: bool,
 
+    /// Don't make any changes, only print what would happen
+    #[arg(short = 'n', long = "noop")]
+    noop_mode: bool,
+
     #[command(subcommand)]
     command: Command,
 }
@@ -39,20 +45,38 @@ fn main() -> ExitCode {
     let default_verbosity = if cli.verbose {
         LevelFilter::Debug
     } else {
-        LevelFilter::Warn
+        // We use info level for no-op mode messages.
+        LevelFilter::Info
     };
     let mut env_logger_builder = env_logger::Builder::new();
     env_logger_builder.filter_level(default_verbosity);
     env_logger_builder.parse_default_env();
     env_logger_builder.format_timestamp(None);
     env_logger_builder.init();
 
+    let config = match Config::from_csmrc() {
+        Ok(config) => {
+            if cli.noop_mode {
+                Config {
+                    noop_mode: true,
+                    ..config
+                }
+            } else {
+                config
+            }
+        }
+        Err(err) => {
+            error!("Failed to parse .csmrc: {}", err);
+            return ExitCode::FAILURE;
+        }
+    };
+
     let Some(home) = util::homedir() else {
         error!("Failed to determine home directory");
         return ExitCode::FAILURE;
     };
 
-    if let Err(e) = create_mambarc(&home) {
+    if let Err(e) = create_mambarc(&config, &home) {
         let attempted_path = home.join(".mambarc");
         warn!(
             "Could not create {}, but continuing: {}",
@@ -61,13 +85,6 @@ fn main() -> ExitCode {
         );
     }
 
-    let config = match csmrc::Config::from_csmrc() {
-        Ok(config) => config,
-        Err(err) => {
-            error!("Failed to parse .csmrc: {}", err);
-            return ExitCode::FAILURE;
-        }
-    };
     match cli.command {
         Command::Env(sub) => env::run(config, sub),
         Command::Robot(sub) => robot::run(config, sub),
@@ -76,13 +93,22 @@ fn main() -> ExitCode {
 
 /// Create a ~/.mambarc (%UserProfile%\.mambarc on Windows) if it does not
 /// exist.
-fn create_mambarc(home: &Path) -> std::io::Result<()> {
+fn create_mambarc(config: &Config, home: &Path) -> std::io::Result<()> {
     let mambarc = include_str!("../templates/mambarc");
     let mambarc_path = home.join(".mambarc");
+
+    if config.noop_mode && !mambarc_path.exists() {
+        info!("Would create {}", mambarc_path.display());
+        return Ok(());
+    }
+
     match File::create_new(&mambarc_path) {
         Ok(mut file) => file.write_all(mambarc.trim_start().as_bytes())?,
         Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
-            debug!("File {mambarc_path:?} already exists, not creating")
+            debug!(
+                "File {} already exists, not creating",
+                mambarc_path.display()
+            )
         }
         Err(e) => return Err(e),
     }

src/util.rs

@@ -19,11 +19,11 @@ pub fn homedir() -> Option<PathBuf> {
 
 /// Return a [`Command`] ready to shell out to `micromamba` with the appropriate
 /// environment variables set based on configuration.
-pub fn micromamba(config: Config, args: Vec<&str>) -> Command {
+pub fn micromamba(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);
+    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");