Basic .csmrc parsing

We rely here on `serde_yaml_ng`, which is a fork of `serde_yaml` that
seems at least somewhat actively maintained and used. The benefit here
is that we get easy deserialization into Rust types (which we wouldn't
get with something like `yaml_rust2` which just gives an AST). The
disadvantage is that we're depending on a library that I wish had more
community backing like the original `serde_yaml` did.

The alternative here would probably be foregoing YAML entirely and using
TOML instead, but it seems the rest of the Robotmk ecosystem uses YAML,
so it is probably best to remain consistent here.

Author: relrod

Cargo.lock

@@ -7,3 +7,5 @@ edition = "2024"
 clap = { version = "4.5.50", features = ["derive", "wrap_help"] }
 env_logger = "0.11.8"
 log = "0.4.28"
+serde = { version = "1.0.228", features = ["derive"] }
+serde_yaml_ng = "0.10.0"

Cargo.toml

@@ -0,0 +1,13 @@
+# csm - Checkmk synthetic monitoring
+
+(Under active development, not yet usable.)
+
+## Configuration: `~/.csmrc`
+
+You can optionally create a file, `~/.csmrc` (`%UserProfile%\.csmrc` on Windows)
+to override certain defaults. This is a YAML file with the following keys
+available:
+
+* `mamba_root_prefix` - A string which sets where the Mamba environment(s) will
+  be created on disk. By default, this is left up to `micromamba` and its
+  default root prefix is used.

README.md

@@ -0,0 +1,37 @@
+/// Module for reading a user's ~/.csmrc, if it exists.
+use log::debug;
+use serde::Deserialize;
+use std::default::Default;
+use std::io::{Error, ErrorKind};
+use std::path::PathBuf;
+
+#[derive(Debug, Default, 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>,
+}
+
+impl Config {
+    /// Read the user's ~/.csmrc if it exists, merging with the Default instance for
+    /// Config.
+    pub fn from_csmrc() -> Result<Self, std::io::Error> {
+        let home = match std::env::var("HOME") {
+            Ok(home) => home,
+            Err(_) => match std::env::var("USERPROFILE") {
+                Ok(home) => home,
+                Err(_) => return Ok(Config::default()),
+            },
+        };
+
+        let csmrc_path = PathBuf::from(home).join(".csmrc");
+        let Ok(csmrc_data) = std::fs::read_to_string(csmrc_path) else {
+            debug!("No .csmrc found, using defaults");
+            return Ok(Config::default());
+        };
+        let config = serde_yaml_ng::from_str(&csmrc_data).map_err(|e| Error::new(ErrorKind::InvalidData, e));
+        debug!("config: {:?}", config);
+        config
+    }
+}

src/csmrc.rs

@@ -1,3 +1,5 @@
+use crate::csmrc::Config;
+
 #[derive(Debug, clap::Subcommand)]
 pub enum Subcommand {
     /// Create an environment
@@ -27,6 +29,7 @@ pub struct CreateArgs {
     name: Option<String>,
 }
 
-pub fn run(subcommand: Subcommand) {
+pub fn run(config: Config, subcommand: Subcommand) {
+    println!("{:?}", config);
     println!("{:?}", subcommand);
 }

src/env.rs

@@ -1,8 +1,9 @@
+mod csmrc;
 mod env;
 mod robot;
 
 use clap::{Parser, Subcommand};
-use log::{LevelFilter, debug};
+use log::{LevelFilter, debug, error};
 use std::fs::File;
 use std::io::Write;
 use std::path::PathBuf;
@@ -29,7 +30,7 @@ enum Command {
     Robot(robot::Subcommand),
 }
 
-fn main() {
+fn main() -> Result<(), std::io::Error> {
     let cli = Cli::parse();
 
     // Set up logging
@@ -41,12 +42,20 @@ fn main() {
     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 _ = create_mambarc();
+    let config = match csmrc::Config::from_csmrc() {
+        Ok(config) => config,
+        Err(err) => {
+            error!("Failed to parse .csmrc: {}", err);
+            panic!("Failed to parse .csmrc as valid YAML");
+        }
+    };
     match cli.command {
-        Command::Env(sub) => env::run(sub),
-        Command::Robot(sub) => robot::run(sub),
+        Command::Env(sub) => Ok(env::run(config, sub)),
+        Command::Robot(sub) => Ok(robot::run(config, sub)),
     }
 }
 

src/main.rs

@@ -1,3 +1,5 @@
+use crate::csmrc::Config;
+
 #[derive(Debug, clap::Subcommand)]
 pub enum Subcommand {
     /// Create a Robotmk robot
@@ -13,6 +15,7 @@ pub struct CreateArgs {
     path: String,
 }
 
-pub fn run(subcommand: Subcommand) {
+pub fn run(config: Config, subcommand: Subcommand) {
+    println!("{:?}", config);
     println!("{:?}", subcommand);
 }