raphael
b871cd9da2
Move equipment capabilities and the E30 control state machine out of C++
code and into YAML data files; introduce a Router for SECS dispatch;
consolidate small files.
Behavioural changes: none. Demo identical (15 SxFy transactions +
3 equipment-initiated primaries), 67 test cases / 384 assertions still
all green. Structural changes only.
Why
---
The previous server.cpp held the equipment data dictionary (3 SVIDs,
2 ECIDs, 3 CEIDs, 2 alarms, 2 recipes, 4 host commands) as imperative
C++ in a 50-line `populate()` function, and routed inbound messages
through a 150-line if-ladder. Adding a new SVID required a recompile.
Adding a new state transition required editing two switch statements
(`operator_*` and `on_host_request_*`). The control state machine's
behavioural rules were spread across imperative code in two methods.
This is exactly what implementation_plan.md calls out as the wrong
shape: behavioural rules should live in versioned data, and every
runtime/test/analyzer should read from that data rather than re-encode
it. This commit starts that move.
What's new
----------
data/equipment.yaml
Equipment data dictionary. Declarative SVIDs / ECIDs / CEIDs /
alarms / recipes / host commands. Host commands carry their HCACK
ack code plus optional `emit_ceid` and `set_alarm` side-effects.
Adding a new SVID or command is a YAML edit, no recompile.
data/control_state.yaml
The E30 §6.2 control state transition table as data. Each row is
(from, on) -> (to [, then] [, ack]). `then` chains an auto-advance
through the transient AttemptOnline state. The previous
imperative switch is gone.
include/secsgem/config/loader.hpp + src/config/loader.cpp
yaml-cpp-backed loader. `load_control_state(path)` returns a
ControlTransitionTable + initial state; `load_equipment(path, model)`
populates the EquipmentDataModel and returns the device descriptor
(id, MDLN, SOFTREV, optional auto-emit CEID). Surfaces config
errors with file path + field name via ConfigError.
include/secsgem/gem/router.hpp (header-only)
Small (stream, function) -> handler map. Server registers all
handlers once at startup, then the Connection's message handler is
just `router.dispatch(msg)`. Unhandled primaries with W set get
SxF0 by default. Replaces the if-ladder in secs_server.cpp.
include/secsgem/gem/control_state.hpp + .cpp
ControlTransitionTable is the new pure data type. ControlStateMachine
is now a thin engine over the table: `fire(event)` looks up the row,
optionally transitions, optionally chains a `then` transition, returns
the ack code. Behaviour rules no longer live in C++ switches.
The default in-code table matches data/control_state.yaml row for row;
tests rely on it so they don't need the YAML file.
include/secsgem/gem/data_model.hpp + .cpp
`register_command(rcmd, CommandSpec)` replaces the function-handler
signature. CommandSpec = (HostCmdAck, optional emit_ceid, optional
set_alarm). `dispatch_command` returns a CommandResult so the server
can fire the side-effects after S2F42 is sent.
apps/secs_server.cpp
No populate(), no if-ladder. Loads equipment.yaml + control_state.yaml
at startup (clean error on bad config), wires the Router once,
delegates dispatch. Sm change handler reads emit_on_control_change
from the YAML. Welcome S10F3 removed for parity with config (a future
YAML rule could re-introduce it declaratively).
tests/test_loader.cpp (new)
Verifies the YAML loader produces the same shape as the in-code
default table, and that equipment.yaml populates every section
(SVIDs/ECIDs/CEIDs/alarms/recipes/commands). SECSGEM_DATA_DIR
CMake define points at ${CMAKE_SOURCE_DIR}/data so tests don't
depend on cwd.
CMakeLists.txt, Dockerfile
find_package(yaml-cpp) and link. libyaml-cpp-dev added to the
Ubuntu base image (yaml-cpp 0.8 ships the modern target name).
File consolidation
------------------
Five small files removed; their content lives in fewer headers:
- secs2/item.cpp -> inline in secs2/item.hpp
- secs2/message.cpp -> inline in secs2/message.hpp
- hsms/types.hpp -> merged into hsms/header.hpp
- hsms/frame.hpp -> merged into hsms/header.hpp
- hsms/frame.cpp -> merged into hsms/header.cpp
hsms/header.hpp is now "the HSMS wire format" in one place: SType + status
enums + Timers + Header + Frame + constants. All includers updated.
Net effect
----------
Before: equipment data dictionary lived in 50 lines of imperative
populate() inside secs_server.cpp; dispatch in a 20-branch if-ladder.
After: equipment data dictionary lives in 47 lines of YAML; dispatch
is a Router built once. Adding a new capability is now a YAML edit
in the common case.
Test count up to 67 cases / 384 assertions (+4 cases / +106 assertions)
covering the loader and the new table-driven SM paths.
What's NOT changed
------------------
The per-SxFy reply construction still lives in C++ (each message has a
unique body shape). Moving those into YAML/JSON message-shape
definitions is the next refactor step but requires a generic typed
encoder/decoder driven by shape descriptors; out of scope here.
Spooling, the S9 error stream, S1F19/F20, and the other gaps in
COMPLIANCE.md remain unchanged.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
90 lines
2.9 KiB
C++
90 lines
2.9 KiB
C++
#include <doctest/doctest.h>
|
|
|
|
#include "secsgem/hsms/header.hpp"
|
|
#include "secsgem/secs2/codec.hpp"
|
|
|
|
using namespace secsgem::hsms;
|
|
namespace s2 = secsgem::secs2;
|
|
|
|
TEST_CASE("data message header round-trip") {
|
|
Header h = Header::data_message(0x1234, 1, 13, true, 0xAABBCCDD);
|
|
auto bytes = h.encode();
|
|
Header back = Header::decode(bytes.data());
|
|
|
|
CHECK(back == h);
|
|
CHECK(back.stype == SType::Data);
|
|
CHECK(back.w_bit());
|
|
CHECK(back.stream() == 1);
|
|
CHECK(back.function() == 13);
|
|
CHECK(back.session_id == 0x1234);
|
|
CHECK(back.system_bytes == 0xAABBCCDD);
|
|
}
|
|
|
|
TEST_CASE("data message header byte layout") {
|
|
Header h = Header::data_message(0x0001, 1, 1, true, 0x00000001);
|
|
auto b = h.encode();
|
|
std::array<uint8_t, 10> expected{0x00, 0x01, 0x81, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
|
|
CHECK(b == expected);
|
|
}
|
|
|
|
TEST_CASE("W-bit clear when no reply expected") {
|
|
Header h = Header::data_message(0, 6, 11, false, 7);
|
|
CHECK_FALSE(h.w_bit());
|
|
CHECK((h.byte2 & 0x80) == 0);
|
|
CHECK(h.stream() == 6);
|
|
}
|
|
|
|
TEST_CASE("control header layout (Select.req)") {
|
|
Header h = Header::control(SType::SelectReq, 0x00000005);
|
|
auto b = h.encode();
|
|
std::array<uint8_t, 10> expected{0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05};
|
|
CHECK(b == expected);
|
|
|
|
Header back = Header::decode(b.data());
|
|
CHECK(back == h);
|
|
CHECK(back.stype == SType::SelectReq);
|
|
}
|
|
|
|
TEST_CASE("select.rsp carries status in byte3") {
|
|
Header h = Header::control(SType::SelectRsp, 5, kControlSessionId, 0,
|
|
static_cast<uint8_t>(SelectStatus::Ok));
|
|
CHECK(h.byte3 == 0);
|
|
Header back = Header::decode(h.encode().data());
|
|
CHECK(back.stype == SType::SelectRsp);
|
|
CHECK(back.byte3 == static_cast<uint8_t>(SelectStatus::Ok));
|
|
}
|
|
|
|
TEST_CASE("frame round-trip with body") {
|
|
s2::Item body_item = s2::Item::list({s2::Item::ascii("MDLN"), s2::Item::ascii("1.0")});
|
|
std::vector<uint8_t> body = s2::encode(body_item);
|
|
|
|
Frame f(Header::data_message(0, 1, 2, false, 42), body);
|
|
auto wire = f.encode();
|
|
|
|
// length prefix counts header + body
|
|
uint32_t len = (wire[0] << 24) | (wire[1] << 16) | (wire[2] << 8) | wire[3];
|
|
CHECK(len == kHeaderSize + body.size());
|
|
CHECK(wire.size() == kLengthPrefixSize + len);
|
|
|
|
Frame back = Frame::decode(wire.data() + kLengthPrefixSize, len);
|
|
CHECK(back.header == f.header);
|
|
CHECK(back.body == body);
|
|
CHECK(s2::decode(back.body) == body_item);
|
|
}
|
|
|
|
TEST_CASE("control frame has empty body") {
|
|
Frame f(Header::control(SType::LinktestReq, 99));
|
|
auto wire = f.encode();
|
|
uint32_t len = (wire[0] << 24) | (wire[1] << 16) | (wire[2] << 8) | wire[3];
|
|
CHECK(len == kHeaderSize);
|
|
|
|
Frame back = Frame::decode(wire.data() + kLengthPrefixSize, len);
|
|
CHECK(back.body.empty());
|
|
CHECK(back.header.stype == SType::LinktestReq);
|
|
}
|
|
|
|
TEST_CASE("frame decode rejects short payload") {
|
|
std::vector<uint8_t> tooShort(5, 0);
|
|
CHECK_THROWS_AS(Frame::decode(tooShort.data(), tooShort.size()), FrameError);
|
|
}
|