WS2 complete: implemented strict/degraded startup policy with validated config parsing, enforced device initialization guarantees, added integration tests, and updated configuration docs

Author: CameronBrooks11

CMakeLists.txt

@@ -262,6 +262,17 @@ if(BUILD_TESTING)
         ENVIRONMENT "${_provider_test_env}"
     )
 
+    add_test(
+        NAME provider.config_startup
+        COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tests/test_config_startup.py --test all
+    )
+    set_tests_properties(provider.config_startup PROPERTIES
+        LABELS "provider;integration;config"
+        FIXTURES_REQUIRED proto_python
+        TIMEOUT 120
+        ENVIRONMENT "${_provider_test_env}"
+    )
+
     add_test(
         NAME provider.adpp
         COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tests/test_adpp_integration.py --test all

docs/configuration.md

@@ -16,6 +16,8 @@ This document defines the `anolis-provider-sim` YAML configuration used at proce
 provider:              # Optional
   name: chamber-provider
 
+startup_policy: strict # Optional: strict | degraded (default: strict)
+
 devices:               # Recommended (can be empty)
   - id: tempctl0
     type: tempctl
@@ -51,6 +53,13 @@ Supported type options:
 
 `chaos_control` is always added automatically and must not be configured in `devices`.
 
+### `startup_policy` (optional)
+
+Controls startup behavior when one or more configured devices fail to initialize.
+
+- `strict` (default): abort startup on first initialization failure
+- `degraded`: continue startup with successfully initialized devices only
+
 ### `simulation` (required)
 
 `simulation.mode` is required and must be one of:
@@ -72,6 +81,7 @@ Additional notes:
 - `tick_rate_hz` range: `[0.1, 1000.0]`
 - `physics_config` is resolved relative to the provider config file directory
 - `sim` mode requires a FluxGraph-enabled build (`ENABLE_FLUXGRAPH=ON`)
+- Removed keys (hard errors): `noise_enabled`, `update_rate_hz`
 
 ## Example Configs In-Repo
 
@@ -184,11 +194,15 @@ The runtime does not parse provider YAML content.
 
 ## Startup Behavior
 
-Current behavior is fail-fast:
+Startup behavior is policy-controlled:
 
-- Invalid YAML/schema -> startup failure
-- Unknown device type or invalid device parameter -> startup failure
-- Device initialization exception -> startup failure
+- Config/schema errors are always fail-fast:
+  - invalid YAML/schema
+  - duplicate `devices[].id`
+  - invalid simulation key matrix
+- Device initialization failures:
+  - `startup_policy=strict`: fail-fast
+  - `startup_policy=degraded`: startup continues with successful devices only
 
 ## Validation Commands
 

scripts/test.ps1

@@ -6,14 +6,14 @@
 #
 # Options:
 #   -Preset <name>      Test preset (default: dev-windows-release on Windows, dev-release otherwise)
-#   -Suite <name>       all|smoke|adpp|multi|fault|fluxgraph (default: all)
+#   -Suite <name>       all|smoke|config|adpp|multi|fault|fluxgraph (default: all)
 #   -VerboseOutput      Run ctest with -VV
 #   -Help               Show help
 
 [CmdletBinding(PositionalBinding = $false)]
 param(
     [string]$Preset = "",
-    [ValidateSet("all", "smoke", "adpp", "multi", "fault", "fluxgraph")]
+    [ValidateSet("all", "smoke", "config", "adpp", "multi", "fault", "fluxgraph")]
     [string]$Suite = "all",
     [switch]$VerboseOutput,
     [switch]$Help,

scripts/test.sh

@@ -6,7 +6,7 @@
 #
 # Options:
 #   --preset <name>   Test preset (default: dev-release)
-#   --suite <name>    all|smoke|adpp|multi|fault|fluxgraph (default: all)
+#   --suite <name>    all|smoke|config|adpp|multi|fault|fluxgraph (default: all)
 #   -v, --verbose     Run ctest with -VV
 #   -h, --help        Show help
 
@@ -59,10 +59,10 @@ while [[ $# -gt 0 ]]; do
 done
 
 case "$SUITE" in
-all | smoke | adpp | multi | fault | fluxgraph) ;;
+all | smoke | config | adpp | multi | fault | fluxgraph) ;;
 *)
     echo "[ERROR] Invalid suite: $SUITE"
-    echo "Valid values: all, smoke, adpp, multi, fault, fluxgraph"
+    echo "Valid values: all, smoke, config, adpp, multi, fault, fluxgraph"
     exit 2
     ;;
 esac

src/config.cpp

@@ -2,11 +2,15 @@
 #include <filesystem>
 #include <iostream>
 #include <regex>
+#include <set>
 #include <stdexcept>
 
 namespace anolis_provider_sim {
 
 namespace fs = std::filesystem;
+namespace {
+constexpr const char *kReservedChaosControlId = "chaos_control";
+}
 
 // Parse simulation mode from string
 SimulationMode parse_simulation_mode(const std::string &mode_str) {
@@ -22,6 +26,17 @@ SimulationMode parse_simulation_mode(const std::string &mode_str) {
   }
 }
 
+StartupPolicy parse_startup_policy(const std::string &policy_str) {
+  if (policy_str == "strict") {
+    return StartupPolicy::Strict;
+  }
+  if (policy_str == "degraded") {
+    return StartupPolicy::Degraded;
+  }
+  throw std::runtime_error("Invalid startup_policy: '" + policy_str +
+                           "'. Valid values: strict, degraded");
+}
+
 // Parse transform type from string
 static TransformType parse_transform_type(const std::string &type_str) {
   if (type_str == "first_order_lag") {
@@ -226,12 +241,27 @@ ProviderConfig load_config(const std::string &path) {
     config.provider_name = provider_name;
   }
 
+  // Parse optional startup policy (default: strict)
+  if (yaml["startup_policy"]) {
+    try {
+      const std::string startup_policy_str =
+          yaml["startup_policy"].as<std::string>();
+      config.startup_policy = parse_startup_policy(startup_policy_str);
+    } catch (const YAML::Exception &) {
+      throw std::runtime_error(
+          "[CONFIG] Invalid startup_policy: must be a string");
+    } catch (const std::runtime_error &e) {
+      throw std::runtime_error("[CONFIG] " + std::string(e.what()));
+    }
+  }
+
   // Parse devices section
   if (yaml["devices"]) {
     if (!yaml["devices"].IsSequence()) {
       throw std::runtime_error("'devices' must be a sequence");
     }
 
+    std::set<std::string> seen_device_ids;
     for (std::size_t i = 0; i < yaml["devices"].size(); ++i) {
       const auto &device_node = yaml["devices"][i];
       if (!device_node.IsMap()) {
@@ -261,6 +291,27 @@ ProviderConfig load_config(const std::string &path) {
                                  std::to_string(i) + "]: " + e.what());
       }
 
+      if (spec.id.empty()) {
+        throw std::runtime_error("[CONFIG] Invalid devices[" +
+                                 std::to_string(i) +
+                                 "]: 'id' must not be empty");
+      }
+      if (spec.type.empty()) {
+        throw std::runtime_error("[CONFIG] Invalid devices[" +
+                                 std::to_string(i) +
+                                 "]: 'type' must not be empty");
+      }
+      if (spec.id == kReservedChaosControlId) {
+        throw std::runtime_error(
+            "[CONFIG] devices[].id 'chaos_control' is reserved and cannot be "
+            "configured explicitly");
+      }
+
+      if (!seen_device_ids.insert(spec.id).second) {
+        throw std::runtime_error("[CONFIG] Duplicate device id: '" + spec.id +
+                                 "'");
+      }
+
       // Store all other fields as configuration parameters
       for (const auto &kv : device_node) {
         std::string key = kv.first.as<std::string>();
@@ -295,9 +346,34 @@ ProviderConfig load_config(const std::string &path) {
                              std::string(e.what()));
   }
 
+  std::set<std::string> provided_simulation_keys;
+  const std::set<std::string> known_simulation_keys = {
+      "mode", "tick_rate_hz", "physics_config", "ambient_temp_c",
+      "ambient_signal_path"};
+  for (const auto &kv : yaml["simulation"]) {
+    const std::string key = kv.first.as<std::string>();
+    provided_simulation_keys.insert(key);
+
+    if (key == "noise_enabled" || key == "update_rate_hz") {
+      throw std::runtime_error("[CONFIG] simulation." + key +
+                               " is no longer supported");
+    }
+
+    if (known_simulation_keys.find(key) == known_simulation_keys.end()) {
+      throw std::runtime_error("[CONFIG] Unknown simulation key: '" + key +
+                               "'");
+    }
+  }
+
   // Parse simulation.tick_rate_hz (required for non_interacting and sim)
   if (yaml["simulation"]["tick_rate_hz"]) {
-    double tick_rate = yaml["simulation"]["tick_rate_hz"].as<double>();
+    double tick_rate = 0.0;
+    try {
+      tick_rate = yaml["simulation"]["tick_rate_hz"].as<double>();
+    } catch (const YAML::Exception &) {
+      throw std::runtime_error("[CONFIG] simulation.tick_rate_hz must be "
+                               "numeric in range [0.1, 1000.0]");
+    }
 
     // Validate bounds
     if (tick_rate < 0.1 || tick_rate > 1000.0) {
@@ -310,37 +386,77 @@ ProviderConfig load_config(const std::string &path) {
 
   // Parse simulation.physics_config (required for sim mode)
   if (yaml["simulation"]["physics_config"]) {
-    config.physics_config_path =
-        yaml["simulation"]["physics_config"].as<std::string>();
+    try {
+      config.physics_config_path =
+          yaml["simulation"]["physics_config"].as<std::string>();
+    } catch (const YAML::Exception &) {
+      throw std::runtime_error(
+          "[CONFIG] simulation.physics_config must be a string");
+    }
+
+    if (config.physics_config_path->empty()) {
+      throw std::runtime_error(
+          "[CONFIG] simulation.physics_config cannot be empty");
+    }
+  }
+
+  if (yaml["simulation"]["ambient_temp_c"]) {
+    try {
+      config.ambient_temp_c = yaml["simulation"]["ambient_temp_c"].as<double>();
+    } catch (const YAML::Exception &) {
+      throw std::runtime_error(
+          "[CONFIG] simulation.ambient_temp_c must be numeric");
+    }
   }
 
+  if (yaml["simulation"]["ambient_signal_path"]) {
+    try {
+      config.ambient_signal_path =
+          yaml["simulation"]["ambient_signal_path"].as<std::string>();
+    } catch (const YAML::Exception &) {
+      throw std::runtime_error(
+          "[CONFIG] simulation.ambient_signal_path must be a string");
+    }
+
+    if (config.ambient_signal_path->empty()) {
+      throw std::runtime_error(
+          "[CONFIG] simulation.ambient_signal_path cannot be empty");
+    }
+  }
+
+  if (config.ambient_signal_path && !config.ambient_temp_c) {
+    throw std::runtime_error("[CONFIG] simulation.ambient_signal_path requires "
+                             "simulation.ambient_temp_c");
+  }
+
+  const auto ensure_mode_allowed_keys = [&](const std::set<std::string> &keys,
+                                            const std::string &mode_name) {
+    for (const auto &provided_key : provided_simulation_keys) {
+      if (keys.find(provided_key) == keys.end()) {
+        throw std::runtime_error("[CONFIG] simulation." + provided_key +
+                                 " is not valid for mode=" + mode_name);
+      }
+    }
+  };
+
   // Startup validation matrix
   switch (config.simulation_mode) {
   case SimulationMode::NonInteracting:
+    ensure_mode_allowed_keys({"mode", "tick_rate_hz"}, "non_interacting");
     if (!config.tick_rate_hz) {
       throw std::runtime_error(
           "[CONFIG] mode=non_interacting requires simulation.tick_rate_hz");
     }
-    if (config.physics_config_path) {
-      throw std::runtime_error(
-          "[CONFIG] mode=non_interacting cannot have physics_config (prevents "
-          "silent ignored config)");
-    }
     break;
 
   case SimulationMode::Inert:
-    if (config.tick_rate_hz) {
-      throw std::runtime_error(
-          "[CONFIG] mode=inert cannot have simulation.tick_rate_hz (prevents "
-          "ignored config)");
-    }
-    if (config.physics_config_path) {
-      throw std::runtime_error("[CONFIG] mode=inert cannot have physics_config "
-                               "(prevents silent ignored config)");
-    }
+    ensure_mode_allowed_keys({"mode"}, "inert");
     break;
 
   case SimulationMode::Sim:
+    ensure_mode_allowed_keys({"mode", "tick_rate_hz", "physics_config",
+                              "ambient_temp_c", "ambient_signal_path"},
+                             "sim");
     if (!config.tick_rate_hz) {
       throw std::runtime_error(
           "[CONFIG] mode=sim requires simulation.tick_rate_hz");
@@ -352,48 +468,6 @@ ProviderConfig load_config(const std::string &path) {
     break;
   }
 
-  const bool has_ambient_temp =
-      static_cast<bool>(yaml["simulation"]["ambient_temp_c"]);
-  const bool has_ambient_path =
-      static_cast<bool>(yaml["simulation"]["ambient_signal_path"]);
-
-  if (config.simulation_mode != SimulationMode::Sim &&
-      (has_ambient_temp || has_ambient_path)) {
-    throw std::runtime_error(
-        "[CONFIG] simulation.ambient_* options are only valid in mode=sim");
-  }
-
-  if (config.simulation_mode == SimulationMode::Sim) {
-    if (has_ambient_path && !has_ambient_temp) {
-      throw std::runtime_error("[CONFIG] simulation.ambient_signal_path "
-                               "requires simulation.ambient_temp_c");
-    }
-
-    if (has_ambient_temp) {
-      try {
-        (void)yaml["simulation"]["ambient_temp_c"].as<double>();
-      } catch (const YAML::Exception &) {
-        throw std::runtime_error(
-            "[CONFIG] simulation.ambient_temp_c must be numeric");
-      }
-    }
-
-    if (has_ambient_path) {
-      std::string ambient_path;
-      try {
-        ambient_path =
-            yaml["simulation"]["ambient_signal_path"].as<std::string>();
-      } catch (const YAML::Exception &) {
-        throw std::runtime_error(
-            "[CONFIG] simulation.ambient_signal_path must be a string");
-      }
-      if (ambient_path.empty()) {
-        throw std::runtime_error(
-            "[CONFIG] simulation.ambient_signal_path cannot be empty");
-      }
-    }
-  }
-
   // Validate physics_bindings are only used in sim mode
   if (config.simulation_mode != SimulationMode::Sim) {
     for (const auto &device : config.devices) {
@@ -405,14 +479,6 @@ ProviderConfig load_config(const std::string &path) {
     }
   }
 
-  // Store legacy simulation params for backward compatibility
-  for (const auto &kv : yaml["simulation"]) {
-    std::string key = kv.first.as<std::string>();
-    if (key != "mode" && key != "tick_rate_hz" && key != "physics_config") {
-      config.simulation[key] = kv.second;
-    }
-  }
-
   return config;
 }