quick n dirty YAML validator

Author: jakelang

chisel/src/config.rs

@@ -0,0 +1,75 @@
+use std::error::Error;
+
+use crate::fail;
+use crate::options::ChiselFlags;
+use serde_yaml::Value;
+
+pub fn parse_config(flags: &ChiselFlags, buf: &String) {
+    let yaml = serde_yaml::from_str::<Value>(buf).unwrap_or_else(|e| {
+        fail(
+            1,
+            &format!("Failed to parse YAML configuration: {}", e.description()),
+        )
+    });
+}
+
+pub fn validate_config(flags: &ChiselFlags, yaml: &Value) -> Result<(), String> {
+    if flags.debug_enabled() {
+        println!("Validating YAML configuration...");
+    }
+
+    // rules
+    // - top-level value must always be a mapping of string to mapping
+    // - each child mapping must have a string field: file
+    // - each child mapping must contain at least one string to mapping map (represents a module)
+    match yaml {
+        Value::Mapping(m) => {
+            // Iterate over rulesets
+            for (idx, (key, value)) in m.iter().enumerate() {
+                // Rule 1
+                match (key, value) {
+                    (Value::String(name), Value::Mapping(ruleset)) => {
+                        // Rule 2
+                        match ruleset.get(&Value::String("file".to_string())) {
+                            Some(Value::String(path)) => (),
+                            Some(_) => {
+                                return Err(format!(
+                                    "Ruleset {}: field 'file' has invalid type",
+                                    name
+                                ))
+                            }
+                            _ => {
+                                return Err(format!(
+                                    "Ruleset {}: Missing required field 'file'",
+                                    name
+                                ))
+                            }
+                        }
+                        // Rule 3
+                        if ruleset
+                            .iter()
+                            .filter(|(lhs, rhs)| match (lhs, rhs) {
+                                (Value::String(module_name), Value::Mapping(module_opts)) => true,
+                                _ => false,
+                            })
+                            .collect::<Vec<(&Value, &Value)>>()
+                            .len()
+                            == 0
+                        {
+                            return Err(format!("Ruleset {}: Missing module declarations", name));
+                        }
+                    }
+                    (Value::String(name), _) => {
+                        return Err(format!("Ruleset '{}': invalid value type", name))
+                    }
+                    (_, Value::Mapping(m)) => {
+                        return Err(format!("Ruleset {}: invalid key type", idx))
+                    }
+                    (_, _) => return Err(format!("Ruleset {}: invalid key and value type", idx)),
+                }
+            }
+            return Ok(());
+        }
+        _ => Err("Top-level YAML value is not a mapping".to_string()),
+    }
+}

chisel/src/main.rs

@@ -1,3 +1,4 @@
+mod config;
 mod options;
 mod run;
 

chisel/src/run.rs

@@ -2,9 +2,11 @@ use std::error::Error;
 use std::fs::read_to_string;
 
 use clap::ArgMatches;
+use serde_yaml::Value;
 
-use crate::options::ChiselFlags;
+use crate::config::validate_config;
 use crate::fail;
+use crate::options::ChiselFlags;
 
 /// Execute chisel in config-driven mode.
 pub fn subcommand_run(flags: ChiselFlags) -> i32 {
@@ -48,7 +50,7 @@ pub fn subcommand_run(flags: ChiselFlags) -> i32 {
                 println!("Successfully loaded configuration");
             }
             conf
-        },
+        }
         Err(e) => fail(
             1,
             &format!("Failed to load configuration: {}", e.description()),
@@ -62,7 +64,22 @@ pub fn subcommand_run(flags: ChiselFlags) -> i32 {
         );
     }
 
-    // Parse config
+    let yaml_parsed = serde_yaml::from_str::<Value>(&config).unwrap_or_else(|e| {
+        fail(
+            1,
+            &format!("Failed to parse YAML configuration: {}", e.description()),
+        )
+    });
+
+    match validate_config(&flags, &yaml_parsed) {
+        Ok(()) => {
+            if flags.debug_enabled() {
+                println!("Config validation OK");
+            }
+        }
+        Err(e) => fail(1, &format!("Config validation failed: {}", e)),
+    }
+
     // Instantiate modules
     // Execute modules
     // Display results