Add v5 primitive-life session wire protocol
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m56s
Foundation / checks (client) (push) Successful in 12m41s
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 (postgres) (push) Canceled after 2m43s
Foundation / checks (network) (push) Canceled after 13m22s
Foundation / checks (checks) (push) Canceled after 15m28s

This commit is contained in:
dingo
2026-10-10 13:15:20 -04:00
parent 066b85333b
commit 8c6e244dad
8 changed files with 248 additions and 32 deletions
+128 -21
View File
@@ -24,6 +24,10 @@ constexpr std::uint8_t max_snapshot_chunks = 16;
constexpr std::size_t address_bytes = 8 + (2 * session_address_bytes);
constexpr std::size_t handoff_offer_bytes = 16 + address_bytes + session_grant_wire_bytes;
constexpr std::size_t redirect_bytes = address_bytes;
constexpr std::size_t life_request_bytes = 24;
constexpr std::size_t life_receipt_bytes = 17;
constexpr std::size_t life_outcome_bytes = 25;
constexpr std::size_t life_query_bytes = 8;
void put(std::vector<std::uint8_t>& out, std::uint64_t v, std::size_t count) {
for (std::size_t i = 0; i < count; ++i)
@@ -35,11 +39,12 @@ std::uint64_t get(std::span<const std::uint8_t> in, std::size_t at, std::size_t
v |= static_cast<std::uint64_t>(in[at + i]) << (8 * i);
return v;
}
std::vector<std::uint8_t> header(SessionMessageType type, std::size_t payload) {
std::vector<std::uint8_t> header(SessionMessageType type, std::size_t payload,
std::uint16_t version = session_protocol_version) {
std::vector<std::uint8_t> out;
out.reserve(session_header_bytes + payload);
put(out, session_magic, 4);
put(out, session_protocol_version, 2);
put(out, version, 2);
out.push_back(static_cast<std::uint8_t>(type));
out.push_back(0);
return out;
@@ -93,38 +98,55 @@ WireGrant grant_at(std::span<const std::uint8_t> in, std::size_t at) {
} // namespace
std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
const auto is_life = std::holds_alternative<PrimitiveLifeRequest>(message) ||
std::holds_alternative<PrimitiveLifeReceipt>(message) ||
std::holds_alternative<PrimitiveLifeOutcome>(message) ||
std::holds_alternative<PrimitiveLifeQuery>(message);
return encode_session(message, is_life ? session_protocol_v5 : session_protocol_version);
}
std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uint16_t version) {
if (version != session_protocol_version && version != session_protocol_v5)
return {};
if (version == session_protocol_version &&
(std::holds_alternative<PrimitiveLifeRequest>(message) ||
std::holds_alternative<PrimitiveLifeReceipt>(message) ||
std::holds_alternative<PrimitiveLifeOutcome>(message) ||
std::holds_alternative<PrimitiveLifeQuery>(message)))
return {};
struct Encoder {
std::uint16_t version;
std::vector<std::uint8_t> operator()(const SessionHello& m) const {
auto out = header(SessionMessageType::hello, hello_bytes);
auto out = header(SessionMessageType::hello, hello_bytes, version);
put(out, m.required_features, 4);
out.insert(out.end(), m.grant.begin(), m.grant.end());
return out;
}
std::vector<std::uint8_t> operator()(const SessionWelcome& m) const {
auto out = header(SessionMessageType::welcome, welcome_bytes);
auto out = header(SessionMessageType::welcome, welcome_bytes, version);
for (const auto v : {m.session, m.epoch, m.world, m.frame, m.region, m.expires_at,
m.server_seconds, m.server_tick})
put(out, v, 8);
return out;
}
std::vector<std::uint8_t> operator()(const SessionRefresh& m) const {
auto out = header(SessionMessageType::refresh, refresh_bytes);
auto out = header(SessionMessageType::refresh, refresh_bytes, version);
out.insert(out.end(), m.grant.begin(), m.grant.end());
return out;
}
std::vector<std::uint8_t> operator()(const SessionRefreshResult& m) const {
auto out = header(SessionMessageType::refresh_result, refresh_result_bytes);
auto out = header(SessionMessageType::refresh_result, refresh_result_bytes, version);
out.push_back(m.status);
put(out, m.expires_at, 8);
return out;
}
std::vector<std::uint8_t> operator()(const SessionClose& m) const {
auto out = header(SessionMessageType::close, close_bytes);
auto out = header(SessionMessageType::close, close_bytes, version);
out.push_back(static_cast<std::uint8_t>(m.reason));
return out;
}
std::vector<std::uint8_t> operator()(const SessionIntention& m) const {
auto out = header(SessionMessageType::intention, intention_bytes);
auto out = header(SessionMessageType::intention, intention_bytes, version);
for (const auto v : {m.session, m.epoch, m.sequence, m.tick})
put(out, v, 8);
put(out, static_cast<std::uint16_t>(m.move_x), 2);
@@ -132,20 +154,21 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
return out;
}
std::vector<std::uint8_t> operator()(const IntentionReceipt& m) const {
auto out = header(SessionMessageType::intention_receipt, intention_receipt_bytes);
auto out =
header(SessionMessageType::intention_receipt, intention_receipt_bytes, version);
put(out, m.sequence, 8);
out.push_back(static_cast<std::uint8_t>(m.status));
put(out, m.server_tick, 8);
return out;
}
std::vector<std::uint8_t> operator()(const SimulatedThrough& m) const {
auto out = header(SessionMessageType::simulated_through, simulated_bytes);
auto out = header(SessionMessageType::simulated_through, simulated_bytes, version);
for (const auto v : {m.epoch, m.sequence, m.tick})
put(out, v, 8);
return out;
}
std::vector<std::uint8_t> operator()(const SessionAction& m) const {
auto out = header(SessionMessageType::action, action_bytes);
auto out = header(SessionMessageType::action, action_bytes, version);
for (const auto v : {m.session, m.epoch, m.action_id})
put(out, v, 8);
put(out, m.kind, 2);
@@ -153,7 +176,7 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
return out;
}
std::vector<std::uint8_t> operator()(const ActionReceipt& m) const {
auto out = header(SessionMessageType::action_receipt, action_receipt_bytes);
auto out = header(SessionMessageType::action_receipt, action_receipt_bytes, version);
put(out, m.action_id, 8);
out.push_back(static_cast<std::uint8_t>(m.status));
put(out, m.server_tick, 8);
@@ -161,7 +184,7 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
return out;
}
std::vector<std::uint8_t> operator()(const ActionOutcome& m) const {
auto out = header(SessionMessageType::action_outcome, action_outcome_bytes);
auto out = header(SessionMessageType::action_outcome, action_outcome_bytes, version);
put(out, m.action_id, 8);
out.push_back(static_cast<std::uint8_t>(m.result));
put(out, m.tick, 8);
@@ -169,12 +192,12 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
return out;
}
std::vector<std::uint8_t> operator()(const ActionQuery& m) const {
auto out = header(SessionMessageType::action_query, action_query_bytes);
auto out = header(SessionMessageType::action_query, action_query_bytes, version);
put(out, m.action_id, 8);
return out;
}
std::vector<std::uint8_t> operator()(const SessionInterest& m) const {
auto out = header(SessionMessageType::interest, interest_bytes);
auto out = header(SessionMessageType::interest, interest_bytes, version);
for (const auto v : {m.x, m.y, m.z})
put(out, static_cast<std::uint64_t>(v), 8);
put(out, m.radius, 2);
@@ -182,7 +205,7 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
}
std::vector<std::uint8_t> operator()(const SnapshotChunk& m) const {
auto out = header(SessionMessageType::snapshot_chunk,
snapshot_chunk_header_bytes + m.records.size());
snapshot_chunk_header_bytes + m.records.size(), version);
for (const auto v :
{m.epoch, m.tick, m.baseline, m.field_revision, m.organism_revision})
put(out, v, 8);
@@ -194,14 +217,14 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
return out;
}
std::vector<std::uint8_t> operator()(const SnapshotAck& m) const {
auto out = header(SessionMessageType::snapshot_ack, snapshot_ack_bytes);
auto out = header(SessionMessageType::snapshot_ack, snapshot_ack_bytes, version);
put(out, m.epoch, 8);
put(out, m.tick, 8);
return out;
}
// Invalid text fields are encoded as given; the receiver refuses them.
std::vector<std::uint8_t> operator()(const HandoffOffer& m) const {
auto out = header(SessionMessageType::handoff_offer, handoff_offer_bytes);
auto out = header(SessionMessageType::handoff_offer, handoff_offer_bytes, version);
out.insert(out.end(), m.transfer.begin(), m.transfer.end());
put_address(out, m.destination);
out.insert(out.end(), m.ticket.begin(), m.ticket.end());
@@ -209,23 +232,61 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
return out;
}
std::vector<std::uint8_t> operator()(const SessionRedirect& m) const {
auto out = header(SessionMessageType::redirect, redirect_bytes);
auto out = header(SessionMessageType::redirect, redirect_bytes, version);
put_address(out, m.owner);
out.resize(session_header_bytes + redirect_bytes);
return out;
}
std::vector<std::uint8_t> operator()(const PrimitiveLifeRequest& m) const {
auto out =
header(SessionMessageType::primitive_life_request, life_request_bytes, version);
put(out, m.session, 8);
put(out, m.epoch, 8);
put(out, m.request_id, 8);
return out;
}
std::vector<std::uint8_t> operator()(const PrimitiveLifeReceipt& m) const {
auto out =
header(SessionMessageType::primitive_life_receipt, life_receipt_bytes, version);
put(out, m.request_id, 8);
out.push_back(static_cast<std::uint8_t>(m.status));
put(out, m.server_tick, 8);
return out;
}
std::vector<std::uint8_t> operator()(const PrimitiveLifeOutcome& m) const {
auto out =
header(SessionMessageType::primitive_life_outcome, life_outcome_bytes, version);
put(out, m.request_id, 8);
out.push_back(static_cast<std::uint8_t>(m.result));
put(out, m.life_identity, 8);
put(out, m.commit_sequence, 8);
return out;
}
std::vector<std::uint8_t> operator()(const PrimitiveLifeQuery& m) const {
auto out = header(SessionMessageType::primitive_life_query, life_query_bytes, version);
put(out, m.request_id, 8);
return out;
}
};
return std::visit(Encoder{}, message);
return std::visit(Encoder{version}, message);
}
std::expected<SessionMessage, SessionCodecError>
decode_session(std::span<const std::uint8_t> bytes) {
return decode_session(bytes, nullptr);
}
std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const std::uint8_t> bytes,
std::uint16_t* version) {
if (bytes.size() < session_header_bytes)
return std::unexpected(SessionCodecError::truncated);
if (get(bytes, 0, 4) != session_magic)
return std::unexpected(SessionCodecError::bad_magic);
if (get(bytes, 4, 2) != session_protocol_version)
const auto wire_version = static_cast<std::uint16_t>(get(bytes, 4, 2));
if (wire_version != session_protocol_version && wire_version != session_protocol_v5)
return std::unexpected(SessionCodecError::unsupported_version);
if (version)
*version = wire_version;
if (bytes[7] != 0)
return std::unexpected(SessionCodecError::reserved_flags);
const auto payload = bytes.subspan(session_header_bytes);
@@ -383,6 +444,52 @@ decode_session(std::span<const std::uint8_t> bytes) {
return std::unexpected(SessionCodecError::invalid_value);
return SessionRedirect{std::move(*owner)};
}
case static_cast<std::uint8_t>(SessionMessageType::primitive_life_request): {
if (wire_version < session_protocol_v5)
return std::unexpected(SessionCodecError::unknown_type);
if (!expect(life_request_bytes))
return std::unexpected(SessionCodecError::wrong_length);
PrimitiveLifeRequest m{get(payload, 0, 8), get(payload, 8, 8), get(payload, 16, 8)};
if (!m.session || !m.epoch || !m.request_id)
return std::unexpected(SessionCodecError::invalid_value);
return m;
}
case static_cast<std::uint8_t>(SessionMessageType::primitive_life_receipt): {
if (wire_version < session_protocol_v5)
return std::unexpected(SessionCodecError::unknown_type);
if (!expect(life_receipt_bytes))
return std::unexpected(SessionCodecError::wrong_length);
if (payload[8] > max_admit_status)
return std::unexpected(SessionCodecError::invalid_value);
return PrimitiveLifeReceipt{get(payload, 0, 8), static_cast<AdmitStatus>(payload[8]),
get(payload, 9, 8)};
}
case static_cast<std::uint8_t>(SessionMessageType::primitive_life_outcome): {
if (wire_version < session_protocol_v5)
return std::unexpected(SessionCodecError::unknown_type);
if (!expect(life_outcome_bytes))
return std::unexpected(SessionCodecError::wrong_length);
if (payload[8] < 1 || payload[8] > static_cast<std::uint8_t>(PrimitiveLifeResult::unknown))
return std::unexpected(SessionCodecError::invalid_value);
const PrimitiveLifeOutcome m{get(payload, 0, 8),
static_cast<PrimitiveLifeResult>(payload[8]),
get(payload, 9, 8), get(payload, 17, 8)};
if (!m.request_id ||
(m.result == PrimitiveLifeResult::born && (!m.life_identity || !m.commit_sequence)) ||
(m.result != PrimitiveLifeResult::born && (m.life_identity || m.commit_sequence)))
return std::unexpected(SessionCodecError::invalid_value);
return m;
}
case static_cast<std::uint8_t>(SessionMessageType::primitive_life_query): {
if (wire_version < session_protocol_v5)
return std::unexpected(SessionCodecError::unknown_type);
if (!expect(life_query_bytes))
return std::unexpected(SessionCodecError::wrong_length);
const auto id = get(payload, 0, 8);
if (!id)
return std::unexpected(SessionCodecError::invalid_value);
return PrimitiveLifeQuery{id};
}
default:
return std::unexpected(SessionCodecError::unknown_type);
}