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
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:
@@ -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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user