ADPP v1 Parity and API Boundary Corrections

Author: CameronBrooks11

CMakeLists.txt

@@ -95,6 +95,7 @@ set(SOURCES
     # Layer 1: Protocol core
     src/core/main.cpp
     src/core/handlers.cpp
+    src/core/health.cpp
     src/core/transport/framed_stdio.cpp
 
     # Layer 2: Devices
@@ -224,6 +225,10 @@ if (WIN32)
     target_compile_definitions(anolis-provider-sim PRIVATE _CRT_SECURE_NO_WARNINGS)
 endif()
 
+target_compile_definitions(anolis-provider-sim PRIVATE
+    ANOLIS_PROVIDER_SIM_VERSION="${PROJECT_VERSION}"
+)
+
 if(BUILD_TESTING)
     find_package(Python3 COMPONENTS Interpreter REQUIRED)
 

README.md

@@ -130,6 +130,7 @@ Makes a device appear unavailable for a specified duration.
 - `DescribeDevice` returns `NOT_FOUND` (unknown/unavailable target)
 - `ReadSignals` for explicit signal requests returns `NOT_FOUND`
 - `CallFunction` returns `INVALID_ARGUMENT` with injected fault message
+- Rejects invalid requests where `duration_ms <= 0`
 - Automatically clears after duration expires
 
 #### `inject_signal_fault`
@@ -146,6 +147,7 @@ Forces a signal to report `FAULT` quality for a specified duration.
 
 - Signal quality becomes `FAULT`
 - Signal value freezes at current value
+- Rejects invalid requests where `duration_ms <= 0`
 - Automatically clears after duration expires
 
 #### `inject_call_latency`
@@ -160,6 +162,7 @@ Adds artificial latency to all function calls on a device.
 **Behavior:**
 
 - All CallFunction requests delayed by specified amount
+- Rejects invalid requests where `latency_ms < 0`
 - Useful for testing timeout handling and responsiveness under load
 
 #### `inject_call_failure`
@@ -176,6 +179,8 @@ Causes a specific function to fail probabilistically.
 
 - Function returns `INVALID_ARGUMENT` at specified rate
 - Uses uniform random distribution for probabilistic failures
+- Requires numeric string `function_id` (for example, `"1"`)
+- Requires `failure_rate` in `[0.0, 1.0]`
 
 #### `clear_faults`
 

src/chaos/chaos_control_device.cpp

@@ -1,6 +1,8 @@
 #include "chaos/chaos_control_device.hpp"
 #include "chaos/fault_injection.hpp"
 
+#include <algorithm>
+#include <cctype>
 #include <thread>
 
 namespace sim_devices {
@@ -73,6 +75,12 @@ static FunctionPolicy make_policy(FunctionPolicy::Category cat) {
   return p;
 }
 
+static bool is_numeric_function_id(const std::string &function_id) {
+  return !function_id.empty() &&
+         std::all_of(function_id.begin(), function_id.end(),
+                     [](unsigned char ch) { return std::isdigit(ch) != 0; });
+}
+
 // -----------------------------
 // Capabilities
 // -----------------------------
@@ -132,7 +140,7 @@ CapabilitySet get_capabilities() {
     *f.add_args() = make_arg("device_id", ValueType::VALUE_TYPE_STRING, true,
                              "Target device ID");
     *f.add_args() = make_arg("function_id", ValueType::VALUE_TYPE_STRING, true,
-                             "Target function name");
+                             "Target function ID as string (e.g. '1')");
     *f.add_args() = make_arg("failure_rate", ValueType::VALUE_TYPE_DOUBLE, true,
                              "Failure probability (0.0-1.0)");
     *f.mutable_policy() = make_policy(FunctionPolicy::CATEGORY_ACTUATE);
@@ -179,6 +187,9 @@ CallResult call_function(uint32_t function_id,
     if (!get_arg_int64(args, "duration_ms", duration_ms)) {
       return bad("missing or invalid duration_ms");
     }
+    if (duration_ms <= 0) {
+      return bad("duration_ms must be > 0");
+    }
 
     fault_injection::inject_device_unavailable(device_id, duration_ms);
     return ok();
@@ -199,6 +210,9 @@ CallResult call_function(uint32_t function_id,
     if (!get_arg_int64(args, "duration_ms", duration_ms)) {
       return bad("missing or invalid duration_ms");
     }
+    if (duration_ms <= 0) {
+      return bad("duration_ms must be > 0");
+    }
 
     fault_injection::inject_signal_fault(device_id, signal_id, duration_ms);
     return ok();
@@ -215,6 +229,9 @@ CallResult call_function(uint32_t function_id,
     if (!get_arg_int64(args, "latency_ms", latency_ms)) {
       return bad("missing or invalid latency_ms");
     }
+    if (latency_ms < 0) {
+      return bad("latency_ms must be >= 0");
+    }
 
     fault_injection::inject_call_latency(device_id, latency_ms);
     return ok();
@@ -232,9 +249,18 @@ CallResult call_function(uint32_t function_id,
     if (!get_arg_string(args, "function_id", function_id_str)) {
       return bad("missing or invalid function_id");
     }
+    if (!is_numeric_function_id(function_id_str)) {
+      return bad("function_id must be a numeric string (e.g. '1')");
+    }
+    if (function_id_str == "0") {
+      return bad("function_id must be >= 1");
+    }
     if (!get_arg_double(args, "failure_rate", failure_rate)) {
       return bad("missing or invalid failure_rate");
     }
+    if (failure_rate < 0.0 || failure_rate > 1.0) {
+      return bad("failure_rate must be in [0.0, 1.0]");
+    }
 
     fault_injection::inject_call_failure(device_id, function_id_str,
                                          failure_rate);

src/chaos/fault_injection.cpp

@@ -157,7 +157,7 @@ void inject_call_failure(const std::string &device_id,
   std::lock_guard<std::mutex> lock(s.mutex);
   CallFailureFault fault;
   fault.function_id = function_id;
-  fault.failure_rate = std::clamp(failure_rate, 0.0, 1.0);
+  fault.failure_rate = failure_rate;
 
   // Replace existing fault for this function, or add new one
   auto &faults = s.call_failure_faults[device_id];

src/core/handlers.cpp

@@ -1,5 +1,7 @@
 #include "core/handlers.hpp"
 
+#include <cstdint>
+#include <map>
 #include <string>
 #include <vector>
 
@@ -19,6 +21,10 @@ using anolis::deviceprovider::v1::ReadSignalsRequest;
 using anolis::deviceprovider::v1::Status;
 using anolis::deviceprovider::v1::WaitReadyRequest;
 
+#ifndef ANOLIS_PROVIDER_SIM_VERSION
+#define ANOLIS_PROVIDER_SIM_VERSION "0.0.0"
+#endif
+
 static inline void set_status_ok(anolis::deviceprovider::v1::Response &resp) {
   resp.mutable_status()->set_code(Status::CODE_OK);
   resp.mutable_status()->set_message("ok");
@@ -41,7 +47,7 @@ void handle_hello(const HelloRequest &req,
   auto *hello = resp.mutable_hello();
   hello->set_protocol_version("v1");
   hello->set_provider_name("anolis-provider-sim");
-  hello->set_provider_version("0.0.3");
+  hello->set_provider_version(ANOLIS_PROVIDER_SIM_VERSION);
 
   (*hello->mutable_metadata())["transport"] = "stdio+uint32_le";
   (*hello->mutable_metadata())["max_frame_bytes"] =
@@ -60,8 +66,13 @@ void handle_list_devices(const ListDevicesRequest &req,
     *out->add_devices() = d;
   }
 
-  // v1 sim: we ignore include_health for now (device_health omitted
-  // intentionally).
+  if (req.include_health()) {
+    const auto device_health = sim_health::make_list_devices_health(devices);
+    for (const auto &health : device_health) {
+      *out->add_device_health() = health;
+    }
+  }
+
   set_status_ok(resp);
 }
 
@@ -149,11 +160,26 @@ void handle_call(const CallRequest &req,
     return;
   }
 
-  // v1: only function_id supported (matches our DescribeDevice contract).
+  uint32_t resolved_function_id = req.function_id();
+
   if (req.function_id() == 0) {
-    set_status(resp, Status::CODE_UNIMPLEMENTED,
-               "function_name lookup not implemented in sim provider v1");
-    return;
+    const auto function_id =
+        sim_devices::resolve_function_id(req.device_id(), req.function_name());
+    if (!function_id.has_value()) {
+      set_status(resp, Status::CODE_NOT_FOUND,
+                 "unknown function_name '" + req.function_name() +
+                     "' for device_id '" + req.device_id() + "'");
+      return;
+    }
+    resolved_function_id = *function_id;
+  } else if (!req.function_name().empty()) {
+    const auto by_name =
+        sim_devices::resolve_function_id(req.device_id(), req.function_name());
+    if (by_name.has_value() && *by_name != req.function_id()) {
+      set_status(resp, Status::CODE_INVALID_ARGUMENT,
+                 "function_id/function_name mismatch");
+      return;
+    }
   }
 
   std::map<std::string, anolis::deviceprovider::v1::Value> args;
@@ -162,7 +188,7 @@ void handle_call(const CallRequest &req,
   }
 
   const auto result =
-      sim_devices::call_function(req.device_id(), req.function_id(), args);
+      sim_devices::call_function(req.device_id(), resolved_function_id, args);
   if (result.code != Status::CODE_OK) {
     set_status(resp, result.code, result.message);
     return;
@@ -176,19 +202,14 @@ void handle_call(const CallRequest &req,
 
 void handle_get_health(const GetHealthRequest & /*req*/,
                        anolis::deviceprovider::v1::Response &resp) {
+  const auto init_report =
+      anolis_provider_sim::DeviceFactory::get_initialization_report();
   auto *out = resp.mutable_get_health();
-  *out->mutable_provider() = sim_health::make_provider_health_ok();
+  *out->mutable_provider() = sim_health::make_provider_health(init_report);
 
-  // v1 sim: device health is optional; include basic OK states for known
-  // devices
-  const auto devices = sim_devices::list_devices(false);
-  for (const auto &d : devices) {
-    auto *dh = out->add_devices();
-    dh->set_device_id(d.device_id());
-    dh->set_state(anolis::deviceprovider::v1::DeviceHealth::STATE_OK);
-    dh->set_message("ok");
-    // last_seen omitted in v1 sim
-    (*dh->mutable_metrics())["impl"] = "sim";
+  const auto device_health = sim_health::make_get_health_devices(init_report);
+  for (const auto &health : device_health) {
+    *out->add_devices() = health;
   }
 
   set_status_ok(resp);
@@ -205,10 +226,24 @@ void handle_wait_ready(const WaitReadyRequest & /*req*/,
 
   std::cerr << "[WaitReady] Processing wait_ready() request\n";
 
+  const auto init_report =
+      anolis_provider_sim::DeviceFactory::get_initialization_report();
   auto *out = resp.mutable_wait_ready();
   (*out->mutable_diagnostics())["init_time_ms"] = "0";
   (*out->mutable_diagnostics())["device_count"] =
       std::to_string(sim_devices::list_devices(false).size());
+  (*out->mutable_diagnostics())["startup_policy"] =
+      sim_health::startup_policy_name(init_report.startup_policy);
+  (*out->mutable_diagnostics())["startup_configured_devices"] =
+      std::to_string(init_report.configured_device_count);
+  (*out->mutable_diagnostics())["startup_initialized_devices"] =
+      std::to_string(init_report.successful_device_ids.size());
+  (*out->mutable_diagnostics())["startup_failed_devices"] =
+      std::to_string(init_report.failed_devices.size());
+  (*out->mutable_diagnostics())["startup_degraded"] =
+      init_report.failed_devices.empty() ? "false" : "true";
+  (*out->mutable_diagnostics())["provider_version"] =
+      ANOLIS_PROVIDER_SIM_VERSION;
   (*out->mutable_diagnostics())["provider_impl"] = "sim";
 
   set_status_ok(resp);