raphael
0721db9542
tests / build-and-test (push) Failing after 42s
Implements the largest functional gap from the compliance audit. The
equipment now queues events the host can't immediately receive (either
because there's no SELECTED session or because the demo's force-spool
flag is on) and transmits the queue on host request.
What's new
include/secsgem/gem/store/spool.hpp
SpoolStore: a deque queue with a configurable per-stream whitelist
(so only streams 5+6 spool by default), a max_size cap with FIFO
eviction on overflow, and a `force_spool` test flag. Enqueue
returns one of Queued / Dropped_NotSpoolable / Dropped_Full so the
caller can fall back to live delivery when appropriate. Drain
pops the entire queue in FIFO order. Two new ack enums:
ResetSpoolAck (S2F44 RSPACK) and SpoolRequestAck (S6F24 RSDA), plus
SpoolRequestCode (S6F23 RSDC, Transmit/Purge).
data/messages.yaml + auto-regenerated messages.hpp
S2F43 W <L,n <B stream>> Reset Spooling
S2F44 <L,2 <B RSPACK> <L,a ...>> Reset Spooling Ack
S6F23 W <B RSDC> Request Spooled Data
S6F24 <B RSDA> Request Spooled Data Ack
data/equipment.yaml
`spool:` section: max_size + spoolable_streams list. Two new host
commands SPOOL_ON / SPOOL_OFF that flip the force-spool flag (these
stand in for "host link down" in the demo without dropping TCP).
include/secsgem/gem/store/host_commands.hpp
Spec/Result gain an optional<bool> force_spool field. S2F41
dispatch returns the result, the server applies it after S2F42 is
queued.
src/config/loader.cpp
Reads `spool:` from equipment.yaml; reads `force_spool` from each
host_commands entry; populates SpoolStore + CommandSpec.
apps/secs_server.cpp
New `deliver_or_spool(msg, what)` helper. emit_event and
emit_alarm_set funnel through it: if force_spool is on (or there's
no active session), msg.stream is checked against the spoolable
list and the message is enqueued; otherwise it's sent live.
Two new handlers:
S2F43 parses the stream list, updates SpoolStore, replies S2F44
S6F23 RSDC=Transmit drains and re-sends each as a fresh primary
(posted on the executor so the S6F24 ack flushes first);
RSDC=Purge clears the queue and acks.
The S2F41 handler now also propagates result.force_spool into the
SpoolStore.
apps/secs_client.cpp
Demo extended with 4 new steps after the FAULT branch:
SPOOL_ON -> S2F42 Accept
START -> S2F42 Accept; CEID 300 emission spooled (no live S6F11)
SPOOL_OFF -> S2F42 Accept; queue still has the message
S6F23(Transmit) -> S6F24 Accept; spooled S6F11 arrives next
Then the existing S7F19/S7F5/S10F1/S1F15/Separate flow continues.
tests/test_data_model.cpp
Four new TEST_CASEs for SpoolStore (whitelist, FIFO eviction at
max_size, drain ordering, force flag).
tests/test_loader.cpp
Confirms equipment.yaml's `spool:` section populates the store and
`force_spool: true/false` flows through to dispatch results.
COMPLIANCE.md
Spooling moves from ⬜ to 🟡. Adds S2F43/F44 + S6F23/F24 as ✅ in
the message coverage matrix; calls out what's still missing
(S6F25/F26 notification, automatic activation on HSMS NOT-SELECTED,
persistent on-disk spool).
Verified
- Tests: 73 cases / 383 assertions pass (+4 spool cases).
- Demo (docker compose up server client) walks the full happy path
and the spool path, observed in the server log as:
spool: force_spool=true (depth=0)
spool: S6F11 CEID=300 queued (depth=1)
spool: force_spool=false (depth=1)
S6F23 transmit: draining 1 messages
and on the host side as the queued S6F11 arriving in the correct
order after S6F24.
Known limitations (logged in COMPLIANCE.md)
- Spool activation is manual via SPOOL_ON/OFF rather than
automatically triggered by HSMS NOT-SELECTED.
- No S6F25/F26 spooled-data-ready notification on re-SELECT.
- In-memory only; an equipment restart loses queued events.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
87 lines
2.9 KiB
C++
87 lines
2.9 KiB
C++
#include <doctest/doctest.h>
|
|
|
|
#include <fstream>
|
|
#include <string>
|
|
|
|
#include "secsgem/config/loader.hpp"
|
|
#include "secsgem/secs2/item.hpp"
|
|
|
|
using namespace secsgem;
|
|
namespace gem = secsgem::gem;
|
|
namespace s2 = secsgem::secs2;
|
|
|
|
#ifndef SECSGEM_DATA_DIR
|
|
#error "SECSGEM_DATA_DIR not defined; see CMakeLists.txt"
|
|
#endif
|
|
|
|
TEST_CASE("control_state.yaml parses into the same shape as default_table()") {
|
|
auto cfg = config::load_control_state(SECSGEM_DATA_DIR "/control_state.yaml");
|
|
auto baseline = gem::ControlTransitionTable::default_table();
|
|
|
|
CHECK(cfg.initial == gem::ControlState::HostOffline);
|
|
// Same row count; same (from, on) pairs map to the same destination.
|
|
CHECK(cfg.table.size() == baseline.size());
|
|
|
|
for (const auto& r : baseline.rows()) {
|
|
const auto* loaded = cfg.table.find(r.from, r.on);
|
|
REQUIRE(loaded != nullptr);
|
|
CHECK(loaded->to == r.to);
|
|
CHECK(loaded->then == r.then);
|
|
CHECK(loaded->ack_code == r.ack_code);
|
|
}
|
|
}
|
|
|
|
TEST_CASE("equipment.yaml populates SVIDs, ECIDs, CEIDs, alarms, recipes, commands") {
|
|
gem::EquipmentDataModel m;
|
|
auto desc = config::load_equipment(SECSGEM_DATA_DIR "/equipment.yaml", m);
|
|
|
|
CHECK(desc.model_name == "SECSGEM-SIM");
|
|
CHECK(desc.software_rev == "0.1.0");
|
|
REQUIRE(desc.emit_on_control_change.has_value());
|
|
CHECK(*desc.emit_on_control_change == 100);
|
|
|
|
CHECK(m.svids.all().size() == 3);
|
|
CHECK(m.svids.get(1)->name == "ControlState");
|
|
CHECK(m.svids.get(3)->value == s2::Item::boolean(true));
|
|
|
|
CHECK(m.ecids.all().size() == 2);
|
|
CHECK(m.ecids.get(10)->value == s2::Item::u4(uint32_t{1}));
|
|
|
|
CHECK(m.events.all_events().size() == 3);
|
|
CHECK(m.events.has_event(100));
|
|
CHECK(m.events.has_event(300));
|
|
|
|
CHECK(m.alarms.all().size() == 2);
|
|
CHECK(m.alarms.get(1)->text == "Chiller Temp High");
|
|
CHECK(m.alarms.get(1)->severity_category == 4);
|
|
|
|
CHECK(m.recipes.list().size() == 2);
|
|
CHECK(m.recipes.get("RECIPE-A").value().find("CHAMBER ARGON") != std::string::npos);
|
|
|
|
CHECK(m.commands.has("START"));
|
|
auto start = m.commands.dispatch("START", {});
|
|
CHECK(start.ack == gem::HostCmdAck::Accept);
|
|
CHECK(start.emit_ceid.value_or(0) == 300);
|
|
auto fault = m.commands.dispatch("FAULT", {});
|
|
CHECK(fault.set_alarm.value_or(0) == 1);
|
|
|
|
// Spool config loaded from YAML.
|
|
CHECK(m.spool.is_stream_spoolable(5));
|
|
CHECK(m.spool.is_stream_spoolable(6));
|
|
CHECK_FALSE(m.spool.is_stream_spoolable(1));
|
|
CHECK(m.spool.max_size() == 100);
|
|
|
|
// force_spool flag plumbed from YAML through CommandSpec.
|
|
auto on = m.commands.dispatch("SPOOL_ON", {});
|
|
auto off = m.commands.dispatch("SPOOL_OFF", {});
|
|
REQUIRE(on.force_spool.has_value());
|
|
CHECK(*on.force_spool == true);
|
|
REQUIRE(off.force_spool.has_value());
|
|
CHECK(*off.force_spool == false);
|
|
}
|
|
|
|
TEST_CASE("loader surfaces YAML errors with file path") {
|
|
CHECK_THROWS_AS(config::load_equipment("/tmp/does-not-exist.yaml", *new gem::EquipmentDataModel),
|
|
config::ConfigError);
|
|
}
|