Add cellular mutation action protocol v10
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m52s
Foundation / checks (checks) (push) Failing after 4m1s
Foundation / checks (tsan) (push) Canceled after 0s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (client) (push) Canceled after 11m9s
Foundation / checks (network) (push) Canceled after 9m18s
Foundation / checks (postgres) (push) Canceled after 7m18s

This commit is contained in:
dingo
2026-10-11 06:57:22 -04:00
parent 50b6e25c0c
commit 9da2bd37dd
6 changed files with 161 additions and 29 deletions
+66 -23
View File
@@ -13,6 +13,7 @@ constexpr std::size_t close_bytes = 1;
constexpr std::size_t intention_bytes = (std::size_t{4} * 8) + 4;
constexpr std::size_t cellular_intention_bytes = (std::size_t{4} * 8) + 4 + 1 + 3 + 8;
constexpr std::size_t cellular_action_bytes = (std::size_t{4} * 8) + 4 + 1 + 3 + 8;
constexpr std::size_t cellular_mutation_action_bytes = (std::size_t{7} * 8) + 2 + 6;
constexpr std::size_t cellular_perception_prefix_bytes = 8 + 8 + 2;
constexpr std::size_t cellular_diagnostics_bytes = 64;
constexpr std::size_t cellular_perception_v9_prefix_bytes =
@@ -127,17 +128,19 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
std::holds_alternative<CellularPerception>(message)
? (std::get<CellularPerception>(message).diagnostics ? session_protocol_v9
: session_protocol_v8)
: std::holds_alternative<CellularAction>(message) ? session_protocol_v7
: std::holds_alternative<CellularIntention>(message) ? session_protocol_v6
: is_life ? session_protocol_v5
: session_protocol_version;
: std::holds_alternative<CellularAction>(message) ? session_protocol_v7
: std::holds_alternative<CellularMutationAction>(message) ? session_protocol_v10
: std::holds_alternative<CellularIntention>(message) ? session_protocol_v6
: is_life ? session_protocol_v5
: session_protocol_version;
return encode_session(message, version);
}
std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uint16_t version) {
if (version != session_protocol_version && version != session_protocol_v5 &&
version != session_protocol_v6 && version != session_protocol_v7 &&
version != session_protocol_v8 && version != session_protocol_v9)
version != session_protocol_v8 && version != session_protocol_v9 &&
version != session_protocol_v10)
return {};
if (version == session_protocol_version &&
(std::holds_alternative<PrimitiveLifeRequest>(message) ||
@@ -148,21 +151,25 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uin
if (version != session_protocol_v6 && std::holds_alternative<CellularIntention>(message))
return {};
if (version != session_protocol_v7 && version != session_protocol_v8 &&
version != session_protocol_v9 && std::holds_alternative<CellularAction>(message))
version != session_protocol_v9 && version != session_protocol_v10 &&
std::holds_alternative<CellularAction>(message))
return {};
if (version != session_protocol_v7 && version != session_protocol_v8 &&
version != session_protocol_v9 && std::holds_alternative<ActionOutcome>(message) &&
version != session_protocol_v9 && version != session_protocol_v10 &&
std::holds_alternative<ActionOutcome>(message) &&
std::get<ActionOutcome>(message).result == ActionResult::committed)
return {};
if (version != session_protocol_v10 && std::holds_alternative<CellularMutationAction>(message))
return {};
if (version != session_protocol_v8 && version != session_protocol_v9 &&
std::holds_alternative<CellularPerception>(message))
version != session_protocol_v10 && std::holds_alternative<CellularPerception>(message))
return {};
if (const auto* perception = std::get_if<CellularPerception>(&message)) {
if (!perception->tick || perception->patches.size() > max_cellular_perceived_patches ||
(!perception->life_identity && !perception->patches.empty()) ||
(version == session_protocol_v8 && perception->diagnostics) ||
(version == session_protocol_v9 && perception->life_identity &&
!perception->diagnostics) ||
((version == session_protocol_v9 || version == session_protocol_v10) &&
perception->life_identity && !perception->diagnostics) ||
(perception->life_identity == 0 && perception->diagnostics) ||
(perception->diagnostics && !valid_diagnostics(*perception->diagnostics)) ||
!std::ranges::is_sorted(perception->patches,
@@ -240,16 +247,27 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uin
put(out, m.intake_y_um, 4);
return out;
}
std::vector<std::uint8_t> operator()(const CellularMutationAction& m) const {
auto out = header(SessionMessageType::cellular_mutation_action,
cellular_mutation_action_bytes, version);
for (const auto value : {m.session, m.epoch, m.action_id, m.tick, m.life_identity,
m.event_index, m.offer_tick})
put(out, value, 8);
put(out, m.operator_id, 2);
put(out, 0, 6);
return out;
}
std::vector<std::uint8_t> operator()(const CellularPerception& m) const {
auto out = header(SessionMessageType::cellular_perception,
(version == session_protocol_v9 ? cellular_perception_v9_prefix_bytes
: cellular_perception_prefix_bytes) +
(version == session_protocol_v9 || version == session_protocol_v10
? cellular_perception_v9_prefix_bytes
: cellular_perception_prefix_bytes) +
m.patches.size() * cellular_perceived_patch_bytes,
version);
put(out, m.tick, 8);
put(out, m.life_identity, 8);
put(out, m.patches.size(), 2);
if (version == session_protocol_v9) {
if (version == session_protocol_v9 || version == session_protocol_v10) {
const auto& d = m.diagnostics;
put(out, d ? d->reserve_energy_pj : 0, 8);
for (const auto value : d ? d->reserve_matter_fg : std::array<std::uint64_t, 4>{})
@@ -404,7 +422,8 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
const auto wire_version = static_cast<std::uint16_t>(get(bytes, 4, 2));
if (wire_version != session_protocol_version && wire_version != session_protocol_v5 &&
wire_version != session_protocol_v6 && wire_version != session_protocol_v7 &&
wire_version != session_protocol_v8 && wire_version != session_protocol_v9)
wire_version != session_protocol_v8 && wire_version != session_protocol_v9 &&
wire_version != session_protocol_v10)
return std::unexpected(SessionCodecError::unsupported_version);
if (version)
*version = wire_version;
@@ -488,7 +507,7 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
}
case static_cast<std::uint8_t>(SessionMessageType::cellular_action): {
if (wire_version != session_protocol_v7 && wire_version != session_protocol_v8 &&
wire_version != session_protocol_v9)
wire_version != session_protocol_v9 && wire_version != session_protocol_v10)
return std::unexpected(SessionCodecError::unsupported_version);
if (!expect(cellular_action_bytes))
return std::unexpected(SessionCodecError::wrong_length);
@@ -509,12 +528,35 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
return std::unexpected(SessionCodecError::invalid_value);
return m;
}
case static_cast<std::uint8_t>(SessionMessageType::cellular_perception): {
if (wire_version != session_protocol_v8 && wire_version != session_protocol_v9)
case static_cast<std::uint8_t>(SessionMessageType::cellular_mutation_action): {
if (wire_version != session_protocol_v10)
return std::unexpected(SessionCodecError::unsupported_version);
const auto prefix = wire_version == session_protocol_v9
? cellular_perception_v9_prefix_bytes
: cellular_perception_prefix_bytes;
if (!expect(cellular_mutation_action_bytes))
return std::unexpected(SessionCodecError::wrong_length);
CellularMutationAction m;
m.session = get(payload, 0, 8);
m.epoch = get(payload, 8, 8);
m.action_id = get(payload, 16, 8);
m.tick = get(payload, 24, 8);
m.life_identity = get(payload, 32, 8);
m.event_index = get(payload, 40, 8);
m.offer_tick = get(payload, 48, 8);
m.operator_id = static_cast<std::uint16_t>(get(payload, 56, 2));
if (!m.session || !m.epoch || !m.action_id || !m.tick || !m.life_identity ||
!m.event_index || !m.offer_tick || m.offer_tick >= m.tick || !m.operator_id ||
std::ranges::any_of(payload.subspan(58, 6),
[](std::uint8_t value) { return value != 0; }))
return std::unexpected(SessionCodecError::invalid_value);
return m;
}
case static_cast<std::uint8_t>(SessionMessageType::cellular_perception): {
if (wire_version != session_protocol_v8 && wire_version != session_protocol_v9 &&
wire_version != session_protocol_v10)
return std::unexpected(SessionCodecError::unsupported_version);
const auto prefix =
wire_version == session_protocol_v9 || wire_version == session_protocol_v10
? cellular_perception_v9_prefix_bytes
: cellular_perception_prefix_bytes;
if (payload.size() < prefix)
return std::unexpected(SessionCodecError::wrong_length);
const auto count = static_cast<std::size_t>(get(payload, 16, 2));
@@ -526,7 +568,7 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
m.life_identity = get(payload, 8, 8);
if (!m.tick || (!m.life_identity && count))
return std::unexpected(SessionCodecError::invalid_value);
if (wire_version == session_protocol_v9) {
if (wire_version == session_protocol_v9 || wire_version == session_protocol_v10) {
CellularLifeDiagnostics d;
d.reserve_energy_pj = get(payload, 18, 8);
for (std::size_t channel = 0; channel < d.reserve_matter_fg.size(); ++channel)
@@ -553,7 +595,8 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
d.intake != CellularIntakeResult::not_reported)
return std::unexpected(SessionCodecError::invalid_value);
}
if (wire_version == session_protocol_v9 && m.life_identity && !m.diagnostics)
if ((wire_version == session_protocol_v9 || wire_version == session_protocol_v10) &&
m.life_identity && !m.diagnostics)
return std::unexpected(SessionCodecError::invalid_value);
if (m.diagnostics && !valid_diagnostics(*m.diagnostics))
return std::unexpected(SessionCodecError::invalid_value);
@@ -613,7 +656,7 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
payload[8] > static_cast<std::uint8_t>(ActionResult::committed) ||
(payload[8] == static_cast<std::uint8_t>(ActionResult::committed) &&
wire_version != session_protocol_v7 && wire_version != session_protocol_v8 &&
wire_version != session_protocol_v9))
wire_version != session_protocol_v9 && wire_version != session_protocol_v10))
return std::unexpected(SessionCodecError::invalid_value);
const ActionOutcome m{get(payload, 0, 8), static_cast<ActionResult>(payload[8]),
get(payload, 9, 8), get(payload, 17, 8)};