From e2f62084336b2129a10e1efdbe56d698221dd134 Mon Sep 17 00:00:00 2001 From: dingo Date: Sat, 3 Oct 2026 22:09:06 -0400 Subject: [PATCH] Add M10.4a intentions, actions and admission Session protocol v1 (not yet deployed, amended in place) gains realtime intentions on datagrams with receipts and a cumulative simulated watermark, and account-scoped actions with stable ids, receipts, final outcomes and queries. IntentAdmission enforces session binding, rate, authority, epoch, vector, sequence, tick window, duplicates and the unresolved bound; RegionSessions and the client carry it over QUIC. Intentions and actions have no biological effect yet. ADR-0092. Co-Authored-By: Claude Opus 5.5 --- cmake/Network.cmake | 2 +- docs/ROADMAP.md | 5 +- docs/STATUS.md | 8 +- ...092-m10-intentions-and-durable-outcomes.md | 61 +++++ docs/adr/README.md | 1 + docs/architecture/NETWORK_ARCHITECTURE.md | 3 +- docs/engineering/VALIDATION.md | 34 +++ include/evo/client/region_session.hpp | 21 +- include/evo/network/intent_admission.hpp | 107 ++++++++ include/evo/network/session_protocol.hpp | 94 ++++++- include/evo/server/region_sessions.hpp | 26 +- schemas/network/session-v1.md | 38 ++- src/client/session/region_session.cpp | 91 +++++++ src/network/protocol/intent_admission.cpp | 246 ++++++++++++++++++ src/network/protocol/session_protocol.cpp | 126 ++++++++- src/server/session/region_sessions.cpp | 94 ++++++- tests/network_control.cpp | 143 +++++++++- tests/quic_sessions.cpp | 103 +++++++- 18 files changed, 1155 insertions(+), 48 deletions(-) create mode 100644 docs/adr/0092-m10-intentions-and-durable-outcomes.md create mode 100644 include/evo/network/intent_admission.hpp create mode 100644 src/network/protocol/intent_admission.cpp diff --git a/cmake/Network.cmake b/cmake/Network.cmake index cf542b2..acd310b 100644 --- a/cmake/Network.cmake +++ b/cmake/Network.cmake @@ -32,7 +32,7 @@ add_subdirectory("${mbedtls_source}" "${PROJECT_BINARY_DIR}/mbedtls" EXCLUDE_FRO # Dependency-free protocol: framing, envelopes, admission. No Mbed TLS types. add_library(evo_network_protocol STATIC src/network/protocol/codec.cpp src/network/protocol/admission.cpp src/network/protocol/session_control.cpp - src/network/protocol/session_protocol.cpp) + src/network/protocol/session_protocol.cpp src/network/protocol/intent_admission.cpp) target_link_libraries(evo_network_protocol PUBLIC evo_client_views evo_client_controls) evo_owned_target(evo_network_protocol) # Mbed TLS adapters: dev grants (HMAC-SHA256 via PSA) and the TLS 1.3 channel. diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 15ca9f8..ba7ddfe 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -521,8 +521,9 @@ hardware (10.9). 10.2 split: 10.2a selection, pins and build of msquic/OpenSSL d 10.2c loss/head-of-line measurements done (networking/M10_TRANSPORT_MEASUREMENTS.md). 10.3 split (ADR-0091): 10.3a account ids, ECDSA grants, identity adapter and region session control done; 10.3b QUIC session login (schemas/network/session-v1.md) done; -10.3c durable per-world account control (schema v10) done. Process wiring into -evo-server and the client comes with 10.4. 10.4-10.9 planned. +10.3c durable per-world account control (schema v10) done. 10.4 split (ADR-0092): +10.4a intention/action protocol and admission done; 10.4b durable action records and +10.4c evo-server wiring with a headless client follow. 10.5-10.9 planned. **Entry:** M9 client/session evidence and M7/M8 dev/stage durability. Read NETWORK_ARCHITECTURE, PERSISTENCE_ARCHITECTURE and ADR-0017. The M9 transport is diff --git a/docs/STATUS.md b/docs/STATUS.md index 9476b05..261d242 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -24,8 +24,12 @@ session login over QUIC (session-v1: Hello, Welcome, Refresh, Close with reasons the region and client side, tested end to end on loopback. M10.3c adds durable per-world account control (schema v10): grant serials survive restarts and apply across regions, cross-region takeover waits out the previous holder, and sessions close when their -control is fenced or cannot be renewed. Next: M10.4 intentions and durable outcomes, -including wiring M10 sessions into evo-server and the client. +control is fenced or cannot be renewed. M10.4a (ADR-0092) adds +intentions (datagram receipts and a cumulative simulated watermark) and account-scoped +actions with stable ids, receipts and final outcomes to session-v1, with admission +(window, rate, sequence, duplicates, unresolved bound) and client support; intentions and +actions have no biological effect yet. Next: M10.4b durable action records (migration +v11) and M10.4c evo-server wiring. ## Previous gate - 2026-10-02 diff --git a/docs/adr/0092-m10-intentions-and-durable-outcomes.md b/docs/adr/0092-m10-intentions-and-durable-outcomes.md new file mode 100644 index 0000000..101b832 --- /dev/null +++ b/docs/adr/0092-m10-intentions-and-durable-outcomes.md @@ -0,0 +1,61 @@ +# ADR-0092: M10 intentions, actions and durable outcomes + +## Status +Accepted for M10.4 (2026-10-03). Decisions confirmed with the maintainer on 2026-10-03: +intentions and actions have no biological effect yet (durable no-effect); stable action +ids and final outcomes are made durable in PostgreSQL in the same transaction as the +checkpoint; 10.4 wires M10 sessions into evo-server with a headless client (the GUI +client switches later). Delivery: 10.4a protocol and admission (this text), 10.4b durable +action records (migration v11) and host integration, 10.4c evo-server listener, headless +client and process kill tests. Each segment amends this ADR. + +## Context +ADR-0089 fixed the scheduling window (server_tick + 1 ..= + 8), one intention per tick, +per-session u64 sequences, at most 256 unresolved intentions and 1.5 s final outcomes. +ADR-0090 put superseding intentions on QUIC DATAGRAMs and reliable actions on the stream. +ADR-0091 binds sessions to accounts. No controllable organism or movement rule exists +(10.6 movement experiment, M11 organisms), so nothing an intention names can change +authoritative state yet. Committed batch traces record host inputs only, not request ids. + +## Decision (10.4a) +**Two kinds of client input, three distinct answers.** +- *Intentions* (datagram): session, epoch, sequence, tick, bounded move vector; never any + state claim (position, energy): the message has no such fields and any extra bytes make + it invalid. Answers: an `IntentionReceipt` (admitted = scheduled for its tick, or a + refusal) and a cumulative `SimulatedThrough` watermark (every admitted intention up to a + sequence whose tick has been simulated in the epoch), repeated every 20 ticks so a lost + datagram is covered. Intentions are superseding: there is no per-intention durable record. +- *Actions* (stream): a client-chosen action id, unique per account and stable across + retries and reconnects, a kind and a tick. Answers: an `ActionReceipt` (scheduled, or a + refusal) and a final `ActionOutcome`: `committed_no_effect` with its commit sequence once + the commit covering its tick is durable, or `not_committed`. `ActionQuery` resolves an id + at any time (`pending`, `unknown`, or the final outcome). The only kind is `probe`. +- A receipt is never a final outcome, and the watermark is never durability. + +**Admission** (`IntentAdmission`, transport-neutral, single owner), in order: the message +must name the connection's own session; rate (every attempt counts: 8 intentions and 4 +actions per 8-tick window); authority ready; epoch; vector norm <= 1000 or a known action +kind and nonzero id; strictly increasing sequence; tick inside the window and, for +intentions, after the previous admitted intention's tick; duplicates (an action id already +pending or final for the account is never admitted again: `duplicate`, followed by its +outcome when final); at most 256 unresolved intentions plus actions per session. +Actions belong to the account: a takeover or reconnect sees the same pending and final +actions. The host takes scheduled actions with `carry(tick)` for the batch that simulates +that tick and reports durable commits with `committed(end_tick, sequence)`. When the epoch +advances, actions never carried are final `not_committed`; carried ones stay pending until +their durable record decides them (10.4b). Recent final outcomes (2,048) are kept for +duplicates and queries; older ones are resolved from the durable record (10.4b). + +**Protocol.** Session protocol v1 gains message types 6-12 and Welcome gains the server +tick (schemas/network/session-v1.md). v1 has never been deployed, so it is amended in +place, as ADR-0083 did for M9 v1; after its first deployment, changes need a new version. +The action kind is a raw u16 on the wire and validated by admission (an enum narrower than +the wire field must never be cast from it). + +## Consequences and limits (10.4a) +- Durable resolution of carried actions after a crash, and of final outcomes evicted from + memory, needs the v11 records (10.4b). Until then a carried action of a lost epoch + answers `pending`. +- The simulated watermark says the targeted tick ran while the intention was scheduled; + with no movement rule it changed nothing. 10.6 gives intentions an effect. +- Nothing is wired into evo-server yet (10.4c); nothing deploys M10 sessions. diff --git a/docs/adr/README.md b/docs/adr/README.md index 10f27ef..02418c6 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -98,6 +98,7 @@ design. No unadopted candidate is a link dependency of the proof. - [ADR-0084: Engineering UI toolkit](0084-engineering-ui-toolkit.md) - Dear ImGui 1.92.9b pinned (M9.8a) and integrated as the engineering client overlay with toolkit-first input routing (M9.8c). - [ADR-0090: M10 QUIC transport](0090-m10-quic-transport.md) - msquic 2.6.2 with OpenSSL 3.5.9 LTS (TLS 1.3 only) from pinned sources on Windows and Linux; DATAGRAM frames for superseding state, streams for reliable actions; M9 TLS/TCP kept as dev fallback; owned impairment relay; exact CA pinning due in 10.2b. +- [ADR-0092: M10 intentions and durable outcomes](0092-m10-intentions-and-durable-outcomes.md) - realtime intentions (datagram receipts and a cumulative simulated watermark) and account-scoped actions with stable ids, receipts and final outcomes (committed_no_effect / not_committed); no biological effect until organisms exist; durable action records in the commit transaction (10.4b). - [ADR-0091: M10 session identity and control](0091-m10-session-identity-and-control.md) - provider-independent 128-bit AccountIds, ECDSA P-256 session grants (regions hold public keys only, signed environment byte), per-account serials where the newest grant wins, takeover of an existing session, in-session refresh, bounded attempt rates; identity adapter and issuer as a library; durable control lease follows (10.3c). - [ADR-0089: M10 timing and budgets](0089-m10-timing-and-budgets.md) - ratified 50 ms tick, 1 s flush with final outcomes p95 <= 1.5 s, responsiveness LAN p95 <= 150 ms / 100 ms RTT <= 250 ms, reference hardware; derived scheduling, sequence, baseline, queue/byte/work budgets and the exact/tolerant determinism contract; records the per-tick biology coupling. - [ADR-0088: Rendered deployment policy](0088-rendered-deployment-policy.md) - the deploy policy check renders every overlay with pinned kustomize v5.8.1 (checksum-verified, explicit preparation) and validates effective objects; unsupported kustomize features refused. diff --git a/docs/architecture/NETWORK_ARCHITECTURE.md b/docs/architecture/NETWORK_ARCHITECTURE.md index cf01c7e..4b0fba9 100644 --- a/docs/architecture/NETWORK_ARCHITECTURE.md +++ b/docs/architecture/NETWORK_ARCHITECTURE.md @@ -9,7 +9,8 @@ pinning (`evo_network_quic`, M10.2b); loss/head-of-line measurements (M10.2c, superseding state on DATAGRAMs and reliable actions on the ordered stream. Session identity and control (ADR-0091, M10.3): ECDSA-signed account-scoped grants ([session-grant-v1](../../schemas/network/session-grant-v1.md)), newest grant wins; login over -QUIC per [session-v1](../../schemas/network/session-v1.md). The scoped M9 dev session (TLS 1.3, protocol v1, dev-only grants) +QUIC per [session-v1](../../schemas/network/session-v1.md). Intentions and actions +(ADR-0092): receipt, simulated watermark and final outcome are distinct answers. The scoped M9 dev session (TLS 1.3, protocol v1, dev-only grants) is specified in [DEV_SESSION_PROTOCOL](../networking/DEV_SESSION_PROTOCOL.md) and ADR-0082. M0 has no networking. Steam distribution follows later through an identity-provider adapter; core account IDs are independent of Steam IDs. diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index 6a30f9e..0c22e4c 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -4203,3 +4203,37 @@ repeated; Clang 19 ASan/UBSan session and network tests; Windows MSVC 19.44 pres build and CTest 4/4 (binary timestamp checked). Not done: evo-server and client integration (10.4), ASan of the PostgreSQL suite, a real two-process cross-region takeover with QUIC clients, cluster migration (no deploy). + +## 2026-10-03 — M10.4a intentions, actions and admission (ADR-0092) + +Implemented session-v1 types 6-12 and Welcome server_tick (codec), `IntentAdmission` +(evo_network_protocol), RegionSessions host facts, datagram intentions, actions, queries, +carry/committed and outcome delivery, and the client API (intentions, actions, queries, +receipts, watermark, outcomes). +Unit tests (`evo-network-tests`): round trips of every new message, every truncation and +extension refused, an intention with appended state claims refused, invalid statuses and +results refused; admission refusals in order (other session, unknown session, stale epoch, +vector, replayed sequence, tick in the past, beyond 8 ticks, same tick, rate after 8 +attempts, not ready); cumulative watermark and its 20-tick repeat; action receipt, +pending query, zero id, unknown kind, wire kind 257 (no truncation), duplicate retry keeping +the original tick, action rate, carry once, commit to `committed_no_effect`, other +account's query, outcome visible to a reconnected session, never admitted twice, unresolved +bound across intentions and actions, abandon finalizing only uncarried actions, bounded +final outcomes. +Loopback QUIC (`evo-quic-session-tests`) with a simulated host: Welcome server tick; +intention receipt, outside window, watermark after the tick runs, not ready; action receipt, +pending query, carry, durable outcome, duplicate receipt then the same outcome, the outcome +from a reconnected session, an uncarried action finalized `not_committed` by an epoch +change, intentions in the new epoch; a raw peer appending state claims to an intention +datagram is closed with `protocol`. + +Found and fixed during development: an 8-bit `ActionKind` decoded from the u16 wire field +would have truncated unknown kinds to known ones (now raw u16 validated by admission); +unchecked optional accesses in the client (tidy). + +Executed: Linux GCC 14 preset `quic` CTest 4/4; session tests 10/10 repeated; Clang 19 +ASan/UBSan session and network tests; clang-tidy 19 on the new and changed sources and +tests; format check; Windows MSVC 19.44 preset `quic` build and CTest 4/4 (binaries rebuilt, +timestamps checked). +Not done: durable action records and crash resolution (10.4b), evo-server wiring and +process kill tests (10.4c). diff --git a/include/evo/client/region_session.hpp b/include/evo/client/region_session.hpp index 92442ce..fb8a79e 100644 --- a/include/evo/client/region_session.hpp +++ b/include/evo/client/region_session.hpp @@ -6,13 +6,16 @@ #include #include #include +#include // M10.3b client-side session login over QUIC (ADR-0091, schemas/network/session-v1.md). // Owned by one thread, which calls poll(). Sends Hello with the grant once the pinned // connection is up (then forgets the grant), waits for Welcome or Close, and can renew // the session in place with a newer grant. A Close from the server, a malformed message, // the Welcome deadline or a lost transport ends the session; reconnecting needs a new -// client and a fresh grant (ADR-0089). Intentions and views are later segments. +// client and a fresh grant (ADR-0089). M10.4 (ADR-0092): intentions as datagrams with +// receipts and a simulated watermark; actions with stable ids, receipts and final outcomes. +// The client never treats a receipt or the watermark as a final outcome. Views are 10.5. namespace evo::client { struct RegionSessionClientConfig { network::quic::ClientConfig transport; @@ -36,6 +39,22 @@ class RegionSessionClient { [[nodiscard]] std::optional take_refresh_result(); // Sends Close{client_closed} and closes the connection. void close(); + // Realtime intention for `tick` (server_tick + 1 ..= + 8); returns its sequence, or + // nothing unless established and sent. Datagrams may be lost: no receipt is not a refusal. + [[nodiscard]] std::optional + send_intention(std::uint64_t tick, std::int16_t move_x, std::int16_t move_y); + // A discrete action with a caller-chosen id, unique for the account (stable across + // retries and reconnects). False unless established and sent. + [[nodiscard]] bool send_action(std::uint64_t action_id, network::ActionKind kind, + std::uint64_t tick); + [[nodiscard]] bool query_action(std::uint64_t action_id); + [[nodiscard]] std::vector take_intention_receipts(); + [[nodiscard]] std::vector take_action_receipts(); + [[nodiscard]] std::vector take_action_outcomes(); + // Newest simulated watermark of this session's epoch. + [[nodiscard]] std::optional simulated() const noexcept; + // Latest server tick seen (Welcome, receipts, watermarks); 0 before Welcome. + [[nodiscard]] std::uint64_t server_tick() const noexcept; [[nodiscard]] RegionSessionState state() const noexcept; [[nodiscard]] const std::optional& welcome() const noexcept; [[nodiscard]] std::optional close_reason() const noexcept; diff --git a/include/evo/network/intent_admission.hpp b/include/evo/network/intent_admission.hpp new file mode 100644 index 0000000..835017a --- /dev/null +++ b/include/evo/network/intent_admission.hpp @@ -0,0 +1,107 @@ +#pragma once +#include "evo/network/session_control.hpp" +#include "evo/network/session_protocol.hpp" +#include +#include +#include +#include +#include +#include +#include + +// M10.4 admission of realtime intentions and discrete actions for one region (ADR-0092). +// Transport-neutral and single-owner; the host serializes calls. Three distinct answers: +// - receipt: admitted (scheduled for a tick) or a refusal, never more than that; +// - simulated: the cumulative watermark of admitted intentions whose tick has run; +// - final (actions only): committed_no_effect with its commit, or not_committed. +// Intentions are per session (sequence strictly increasing, superseded by later ones). +// Actions are per account, with client-chosen ids that are never admitted twice, so a +// retry or a reconnect resolves to the same outcome. Neither changes biology in M10.4. +namespace evo::network { +struct IntentLimits { + std::uint32_t intent_window{8}; // Ticks ahead of the server tick (ADR-0089). + std::uint32_t window_ticks{8}; // Rate window. + std::uint32_t max_intents_per_window{8}; // Every attempt counts. + std::uint32_t max_actions_per_window{4}; // Every attempt counts. + std::size_t max_unresolved{256}; // Intentions plus actions per session. + std::size_t max_sessions{32}; + std::size_t max_finals{2048}; // Recent final outcomes kept for duplicates and queries. + std::uint64_t watermark_every{20}; // Ticks between repeats of an unchanged watermark. +}; +// The host's authority as admission must see it. +struct AdmissionFacts { + bool ready{}; + std::uint64_t epoch{}, server_tick{}; +}; +// An action the host must record durably with the batch that covers its tick. +struct CarriedAction { + AccountId account; + std::uint64_t action_id{}, tick{}; + ActionKind kind{}; + friend bool operator==(const CarriedAction&, const CarriedAction&) = default; +}; +struct AccountOutcome { + AccountId account; + ActionOutcome outcome; +}; +enum class IntentConfigError : std::uint8_t { invalid }; + +class IntentAdmission { + public: + [[nodiscard]] static std::expected + create(IntentLimits limits); + // Session lifecycle, driven by session control (after Welcome, on any close). + [[nodiscard]] bool open(std::uint64_t session, const AccountId& account); + void close(std::uint64_t session); + // `session` is the connection's authenticated session; a message naming another is + // refused. Every attempt by a known session counts toward its rate. + [[nodiscard]] IntentionReceipt intention(std::uint64_t session, const SessionIntention& m, + const AdmissionFacts& facts); + [[nodiscard]] ActionReceipt action(std::uint64_t session, const SessionAction& m, + const AdmissionFacts& facts); + // What this process knows about an action of the session's account. + [[nodiscard]] ActionOutcome query(std::uint64_t session, const ActionQuery& m) const; + // Watermarks to send after the host simulated through facts.server_tick. + [[nodiscard]] std::vector> + simulated(const AdmissionFacts& facts); + // Scheduled actions whose tick is <= `tick`: they ride that tick's batch from now on. + [[nodiscard]] std::vector carry(std::uint64_t tick); + // A commit covering ticks up to `end_tick` is durable: its carried actions are final. + [[nodiscard]] std::vector committed(std::uint64_t end_tick, + std::uint64_t commit_sequence); + // Authority lost or epoch advanced: actions never carried are final (not_committed); + // carried ones stay unresolved until a durable record decides them (10.4b). + [[nodiscard]] std::vector abandon(); + // The current session of an account, for delivering outcomes. + [[nodiscard]] std::optional session_of(const AccountId& account) const; + [[nodiscard]] std::size_t unresolved(std::uint64_t session) const; + + private: + struct Pending { + std::uint64_t sequence{}, tick{}; + }; + struct Session { + std::uint64_t id{}; + AccountId account; + std::uint64_t last_sequence{}, window_start{}; + std::uint32_t intent_attempts{}, action_attempts{}; + std::deque pending; + std::uint64_t watermark{}, sent_watermark{}, sent_at_tick{}; + }; + enum class Stage : std::uint8_t { scheduled, carried }; + struct Action { + CarriedAction carried; + Stage stage{}; + }; + explicit IntentAdmission(IntentLimits limits) : limits_{limits} {} + Session* find(std::uint64_t session); + const Session* find(std::uint64_t session) const; + void count_window(Session& s, std::uint64_t server_tick) const; + [[nodiscard]] std::size_t unresolved_of(const Session& s) const; + void remember(const AccountId& account, const ActionOutcome& outcome); + IntentLimits limits_; + std::vector sessions_; + std::vector actions_; + std::deque finals_; +}; +} // namespace evo::network diff --git a/include/evo/network/session_protocol.hpp b/include/evo/network/session_protocol.hpp index bb4397b..33a5078 100644 --- a/include/evo/network/session_protocol.hpp +++ b/include/evo/network/session_protocol.hpp @@ -7,8 +7,10 @@ #include #include -// M10 session protocol v1, session part (ADR-0091, schemas/network/session-v1.md). -// Messages travel on the QUIC reliable stream (one message per framed QUIC message). +// M10 session protocol v1 (ADR-0091 session, ADR-0092 intentions and actions; +// schemas/network/session-v1.md). Session, action and outcome messages travel on the QUIC +// reliable stream (one message per framed QUIC message); intentions, their receipts and the +// simulated watermark travel as QUIC DATAGRAMs. // Each starts with an 8-byte header: magic "EVSN", version u16, type u8, flags u8 (0); // every payload has a fixed size and explicit little-endian fields. Grants are opaque // 160-byte credentials here. Later M10 segments add message types under a new version. @@ -19,11 +21,42 @@ inline constexpr std::size_t session_header_bytes = 8; inline constexpr std::size_t session_grant_wire_bytes = 160; enum class SessionMessageType : std::uint8_t { - hello = 1, // Client -> server: grant. - welcome, // Server -> client. - refresh, // Client -> server: newer grant for the open session. - refresh_result, // Server -> client. - close // Either way, then the sender closes the connection. + hello = 1, // Client -> server: grant. + welcome, // Server -> client. + refresh, // Client -> server: newer grant for the open session. + refresh_result, // Server -> client. + close, // Either way, then the sender closes the connection. + intention, // Client -> server, datagram: realtime movement intention. + intention_receipt, // Server -> client, datagram. + simulated_through, // Server -> client, datagram: cumulative simulated watermark. + action, // Client -> server, stream: discrete action with a stable id. + action_receipt, // Server -> client, stream. + action_outcome, // Server -> client, stream: final. + action_query // Client -> server, stream: resolve an action by id. +}; +// Admission answers for intentions and actions (wire 0..10). +enum class AdmitStatus : std::uint8_t { + admitted = 0, + unknown_session, // Not this connection's session. + stale_epoch, + outside_window, // Tick not in server_tick + 1 ..= server_tick + window. + rate_limited, // Every attempt counts toward the window budget. + replayed, // Intention sequence not above the last admitted one. + invalid_vector, + too_many_unresolved, + invalid_action, // Unknown kind or zero action id. + duplicate, // Action id already known for this account: its state follows. + not_ready // The region has no current authority (starting, recovering, draining). +}; +// Wire u16 (SessionAction::kind carries the raw value; admission validates it). +enum class ActionKind : std::uint8_t { + probe = 1 // No effect on biology: proves admission, scheduling and durability (M10.4). +}; +enum class ActionResult : std::uint8_t { + committed_no_effect = 1, // Durable in commit `commit_sequence`; changed nothing. + not_committed, // Final: never part of a committed batch. + pending, // Query answer only: admitted, not yet final. + unknown // Query answer only: no record of this action id. }; // Wire values 1..13. `connection_lost` is local only (the transport ended without a Close). enum class SessionCloseReason : std::uint8_t { @@ -60,6 +93,7 @@ struct SessionHello { struct SessionWelcome { std::uint64_t session{}, epoch{}, world{}, frame{}, region{}, expires_at{}; std::uint64_t server_seconds{}; // Server wall clock at Welcome, for refresh timing. + std::uint64_t server_tick{}; // Simulated tick at Welcome, for scheduling. friend bool operator==(const SessionWelcome&, const SessionWelcome&) = default; }; struct SessionRefresh { @@ -75,8 +109,52 @@ struct SessionRefreshResult { struct SessionClose { SessionCloseReason reason{}; }; +// A movement intention carries only what the player wants: never position, energy or any +// other state claim. Vector components within the M9 bound (norm <= 1000). +struct SessionIntention { + std::uint64_t session{}, epoch{}, sequence{}, tick{}; + std::int16_t move_x{}, move_y{}; + friend bool operator==(const SessionIntention&, const SessionIntention&) = default; +}; +struct IntentionReceipt { + std::uint64_t sequence{}; + AdmitStatus status{}; + std::uint64_t server_tick{}; + friend bool operator==(const IntentionReceipt&, const IntentionReceipt&) = default; +}; +// Every admitted intention up to `sequence` whose tick is <= `tick` has been simulated in +// `epoch` (cumulative, so a lost datagram is covered by the next). +struct SimulatedThrough { + std::uint64_t epoch{}, sequence{}, tick{}; + friend bool operator==(const SimulatedThrough&, const SimulatedThrough&) = default; +}; +struct SessionAction { + std::uint64_t session{}, epoch{}, action_id{}; + std::uint16_t kind{}; // Raw wire value: an unknown kind is refused by admission. + std::uint64_t tick{}; + friend bool operator==(const SessionAction&, const SessionAction&) = default; +}; +// Receipt only: admitted means scheduled for `tick`, never simulated or durable. +struct ActionReceipt { + std::uint64_t action_id{}; + AdmitStatus status{}; + std::uint64_t server_tick{}, tick{}; + friend bool operator==(const ActionReceipt&, const ActionReceipt&) = default; +}; +struct ActionOutcome { + std::uint64_t action_id{}; + ActionResult result{}; + std::uint64_t tick{}, commit_sequence{}; // Zero unless committed_no_effect. + friend bool operator==(const ActionOutcome&, const ActionOutcome&) = default; +}; +struct ActionQuery { + std::uint64_t action_id{}; + friend bool operator==(const ActionQuery&, const ActionQuery&) = default; +}; using SessionMessage = - std::variant; + std::variant; [[nodiscard]] std::vector encode_session(const SessionMessage& message); // Exactly one message; any other length for its type rejects. diff --git a/include/evo/server/region_sessions.hpp b/include/evo/server/region_sessions.hpp index db77322..616fdf1 100644 --- a/include/evo/server/region_sessions.hpp +++ b/include/evo/server/region_sessions.hpp @@ -1,4 +1,5 @@ #pragma once +#include "evo/network/intent_admission.hpp" #include "evo/network/quic_transport.hpp" #include "evo/network/session_control.hpp" #include "evo/network/session_grant.hpp" @@ -18,7 +19,11 @@ // public keys and admitted by SessionControl. A newer grant for an account closes the // account's previous connection with `superseded`. Refusals and closes send Close with a // reason, then the connection is closed after a short flush. Intentions and views are -// later segments (10.4, 10.5). Events carry account log labels only, never grants. +// later segments (10.5). Events carry account log labels only, never grants. +// M10.4 (ADR-0092): established sessions send intentions (datagrams) and actions (stream); +// IntentAdmission answers with receipts, simulated watermarks and final action outcomes. +// The host reports its authority each poll, takes carried actions for its batches and +// reports durable commits. // With a ControlLedger, control is durable and unique per world: a session that loses its // durable control (another region accepted a newer grant) closes with `superseded`, and // one whose control cannot be renewed in time closes with `shutdown`. @@ -39,6 +44,13 @@ struct RegionSessionsConfig { // `renew_interval` and closes before its control can lapse (`safety_margin`). network::ControlLedger* ledger{}; std::chrono::milliseconds renew_interval{5000}, safety_margin{2000}; + network::IntentLimits intents{}; // max_sessions follows control.max_sessions. +}; +// The region host's authority, read once per poll. +struct HostFacts { + bool ready{}; // Current authority, recovered, not draining. + std::uint64_t epoch{}; // Ownership epoch; a newer one closes every session. + std::uint64_t simulated_tick{}; }; enum class RegionSessionsError : std::uint8_t { configuration, keys, transport }; struct RegionSessionEvent { @@ -55,10 +67,16 @@ class RegionSessions { RegionSessions(const RegionSessions&) = delete; RegionSessions& operator=(const RegionSessions&) = delete; ~RegionSessions(); - // `epoch` is the region's current ownership epoch: a newer one closes every session - // (stale_epoch). `now_seconds` is wall time for grants, `now` monotonic for deadlines. - void poll(std::uint64_t epoch, std::uint64_t now_seconds, + // A newer epoch closes every session (stale_epoch) and abandons unscheduled actions. + // `now_seconds` is wall time for grants, `now` monotonic for deadlines. + void poll(const HostFacts& facts, std::uint64_t now_seconds, std::chrono::steady_clock::time_point now); + // Actions scheduled for ticks <= `tick`, to be recorded durably with the batch that + // simulates that tick (10.4b). Each action is returned once. + [[nodiscard]] std::vector carry(std::uint64_t tick); + // A commit covering ticks up to `end_tick` is durable: carried actions become final and + // their outcomes are sent to each account's current session. + void committed(std::uint64_t end_tick, std::uint64_t commit_sequence); // Closes every connection with `shutdown` (flushed by later polls). void shutdown(std::chrono::steady_clock::time_point now); [[nodiscard]] std::vector take_events(); diff --git a/schemas/network/session-v1.md b/schemas/network/session-v1.md index c6865ce..ed8db83 100644 --- a/schemas/network/session-v1.md +++ b/schemas/network/session-v1.md @@ -1,30 +1,47 @@ -# M10 session protocol, version 1 (session messages) +# M10 session protocol, version 1 -Login and session control over the QUIC reliable stream (ADR-0090 transport, ADR-0091 -identity). Implemented by `encode_session`/`decode_session` +Login, session control, intentions and actions over QUIC (ADR-0090 transport, ADR-0091 +identity, ADR-0092 intentions and actions). Implemented by `encode_session`/`decode_session` (include/evo/network/session_protocol.hpp), `RegionSessions` (server) and -`RegionSessionClient` (client). Each message is one framed QUIC reliable message. +`RegionSessionClient` (client). Stream messages are one framed QUIC reliable message +each; types 6-8 travel as one QUIC DATAGRAM each, and only after Welcome. Integers little-endian. Every message has a fixed length for its type; any other length, magic, version, nonzero flags, unknown type or out-of-range value is refused, and the server then sends Close (`unsupported_version` for another version, otherwise -`protocol`) and closes the connection. Later M10 segments add types in a new version. +`protocol`) and closes the connection. v1 has not been deployed; it was amended in place +by M10.4 (types 6-12, Welcome server_tick). After its first deployment, changes need a +new version. ## Header (8 bytes) | Offset | Size | Field | Rule | |---|---|---|---| | 0 | 4 | magic | bytes `EVSN` | | 4 | 2 | version | 1 | -| 6 | 1 | type | 1..5 below | +| 6 | 1 | type | 1..12 below | | 7 | 1 | flags | 0 | ## Messages | Type | Direction | Payload | Size | |---|---|---|---| | 1 Hello | client -> server | required_features u32 (0), grant (session-grant-v1, 160 bytes) | 164 | -| 2 Welcome | server -> client | session, epoch, world, frame, region, expires_at, server_seconds (u64 each; session and epoch nonzero) | 56 | +| 2 Welcome | server -> client | session, epoch, world, frame, region, expires_at, server_seconds, server_tick (u64 each; session and epoch nonzero) | 64 | | 3 Refresh | client -> server | newer grant for the same account (160 bytes) | 160 | | 4 RefreshResult | server -> client | status u8 (0 accepted, else a close reason value), expires_at u64 | 9 | | 5 Close | either | reason u8 | 1 | +| 6 Intention | client -> server, datagram | session, epoch, sequence, tick (u64), move_x, move_y (i16) | 36 | +| 7 IntentionReceipt | server -> client, datagram | sequence u64, status u8, server_tick u64 | 17 | +| 8 SimulatedThrough | server -> client, datagram | epoch, sequence, tick (u64) | 24 | +| 9 Action | client -> server | session, epoch, action_id (u64), kind u16, tick u64 | 34 | +| 10 ActionReceipt | server -> client | action_id u64, status u8, server_tick u64, tick u64 | 25 | +| 11 ActionOutcome | server -> client | action_id u64, result u8 (1..4), tick u64, commit_sequence u64 | 25 | +| 12 ActionQuery | client -> server | action_id u64 | 8 | + +Admission status (wire 0..10): 0 admitted, 1 unknown_session, 2 stale_epoch, +3 outside_window, 4 rate_limited, 5 replayed, 6 invalid_vector, 7 too_many_unresolved, +8 invalid_action, 9 duplicate, 10 not_ready. Action kinds: 1 probe (no effect). Action +results: 1 committed_no_effect, 2 not_committed (both final), 3 pending, 4 unknown (query +answers only). Intentions carry no state claims; their vector ranges and every action +field are checked by admission, which answers with a status rather than closing. Close reasons (wire 1..13): 1 client_closed, 2 superseded, 3 expired, 4 stale_epoch, 5 unauthenticated, 6 wrong_scope, 7 stale_grant, 8 rate_limited, 9 capacity, @@ -47,3 +64,10 @@ Close reasons (wire 1..13): 1 client_closed, 2 superseded, 3 expired, 4 stale_ep - Close is followed by closing the connection (the server waits up to 1 s for delivery). A client that closes its connection without Close is treated as `client_closed`. - Reconnecting needs a new connection and a newer grant (ADR-0089). +- Intentions (ADR-0092): one per tick, ticks and sequences increasing, tick within + server_tick + 1 ..= + 8. A receipt only says admitted or refused; `SimulatedThrough` + says which admitted intentions' ticks have run (cumulative, resent every 20 ticks). + Any datagram other than an Intention, or before Welcome, closes with `protocol`. +- Actions (ADR-0092): ids unique per account and never admitted twice. A receipt only + says scheduled or refused; `ActionOutcome` is sent once the action is final, again + after a duplicate of a final action, and in answer to `ActionQuery`. diff --git a/src/client/session/region_session.cpp b/src/client/session/region_session.cpp index fca4f42..b244d38 100644 --- a/src/client/session/region_session.cpp +++ b/src/client/session/region_session.cpp @@ -1,4 +1,5 @@ #include "evo/client/region_session.hpp" +#include #include namespace evo::client { @@ -16,6 +17,42 @@ struct RegionSessionClient::Impl { std::optional welcome; std::optional reason; std::optional refresh_result; + std::uint64_t next_sequence{1}, server_tick{}; + std::optional simulated; + std::vector intention_receipts; + std::vector action_receipts; + std::vector action_outcomes; + static constexpr std::size_t max_kept = 1024; // Per kind, until taken; oldest dropped. + + template static void keep(std::vector& list, const T& item) { + if (list.size() >= max_kept) + list.erase(list.begin()); + list.push_back(item); + } + void seen_tick(std::uint64_t tick) { + server_tick = std::max(server_tick, tick); + } + // Datagrams: receipts and watermarks only, after Welcome. + void datagram(std::span bytes) { + if (state != RegionSessionState::established) + return; + const auto decoded = network::decode_session(bytes); + if (!decoded) + return end(SessionCloseReason::protocol, true); + if (const auto* m = std::get_if(&*decoded)) { + seen_tick(m->server_tick); + return keep(intention_receipts, *m); + } + if (const auto* m = std::get_if(&*decoded)) { + if (!welcome || m->epoch != welcome->epoch) + return; // Another epoch's watermark says nothing about this session. + seen_tick(m->tick); + if (!simulated || m->sequence >= simulated->sequence) + simulated = *m; + return; + } + end(SessionCloseReason::protocol, true); + } bool send(const network::SessionMessage& m) { return connection != 0 && @@ -42,6 +79,7 @@ struct RegionSessionClient::Impl { if (state == RegionSessionState::awaiting_welcome) { if (const auto* m = std::get_if(&*decoded)) { welcome = *m; + seen_tick(m->server_tick); state = RegionSessionState::established; return; } @@ -52,6 +90,12 @@ struct RegionSessionClient::Impl { refresh_result = *m; return; } + if (const auto* m = std::get_if(&*decoded)) { + seen_tick(m->server_tick); + return keep(action_receipts, *m); + } + if (const auto* m = std::get_if(&*decoded)) + return keep(action_outcomes, *m); } end(SessionCloseReason::protocol, true); } @@ -89,6 +133,8 @@ void RegionSessionClient::poll(Clock::time_point now) { m.end(SessionCloseReason::connection_lost, false); } else if (e.kind == EventKind::message) { m.message(e.bytes); + } else if (e.kind == EventKind::datagram) { + m.datagram(e.bytes); } else if (e.kind == EventKind::closed) { m.connection = 0; // Already gone; nothing to close or send. m.end(SessionCloseReason::connection_lost, false); @@ -113,6 +159,51 @@ void RegionSessionClient::close() { impl_->end(SessionCloseReason::client_closed, true); } +std::optional +RegionSessionClient::send_intention(std::uint64_t tick, std::int16_t move_x, std::int16_t move_y) { + auto& m = *impl_; + if (m.state != RegionSessionState::established || m.connection == 0 || !m.welcome) + return std::nullopt; + const network::SessionIntention intention{ + m.welcome->session, m.welcome->epoch, m.next_sequence, tick, move_x, move_y}; + if (!m.endpoint->send_datagram(m.connection, network::encode_session(intention))) + return std::nullopt; + return m.next_sequence++; +} + +bool RegionSessionClient::send_action(std::uint64_t action_id, network::ActionKind kind, + std::uint64_t tick) { + auto& m = *impl_; + return m.state == RegionSessionState::established && m.welcome && + m.send(network::SessionAction{m.welcome->session, m.welcome->epoch, action_id, + static_cast(kind), tick}); +} + +bool RegionSessionClient::query_action(std::uint64_t action_id) { + auto& m = *impl_; + return m.state == RegionSessionState::established && m.send(network::ActionQuery{action_id}); +} + +std::vector RegionSessionClient::take_intention_receipts() { + return std::exchange(impl_->intention_receipts, {}); +} + +std::vector RegionSessionClient::take_action_receipts() { + return std::exchange(impl_->action_receipts, {}); +} + +std::vector RegionSessionClient::take_action_outcomes() { + return std::exchange(impl_->action_outcomes, {}); +} + +std::optional RegionSessionClient::simulated() const noexcept { + return impl_->simulated; +} + +std::uint64_t RegionSessionClient::server_tick() const noexcept { + return impl_->server_tick; +} + RegionSessionState RegionSessionClient::state() const noexcept { return impl_->state; } diff --git a/src/network/protocol/intent_admission.cpp b/src/network/protocol/intent_admission.cpp new file mode 100644 index 0000000..9010593 --- /dev/null +++ b/src/network/protocol/intent_admission.cpp @@ -0,0 +1,246 @@ +#include "evo/network/intent_admission.hpp" +#include + +namespace evo::network { +namespace { +constexpr std::int32_t max_component = 1000; +bool valid_vector(std::int16_t x, std::int16_t y) { + const std::int32_t ix = x, iy = y; + return ix * ix + iy * iy <= max_component * max_component; +} +bool in_window(std::uint64_t tick, std::uint64_t server_tick, std::uint32_t window) { + return tick > server_tick && tick - server_tick <= window; +} +} // namespace + +std::expected IntentAdmission::create(IntentLimits limits) { + if (limits.intent_window == 0 || limits.intent_window > 64 || limits.window_ticks == 0 || + limits.max_intents_per_window == 0 || limits.max_actions_per_window == 0 || + limits.max_unresolved == 0 || limits.max_unresolved > 4096 || limits.max_sessions == 0 || + limits.max_sessions > 1024 || limits.max_finals == 0 || limits.watermark_every == 0) + return std::unexpected(IntentConfigError::invalid); + IntentAdmission admission{limits}; + admission.sessions_.reserve(limits.max_sessions); + return admission; +} + +IntentAdmission::Session* IntentAdmission::find(std::uint64_t session) { + const auto it = + std::ranges::find_if(sessions_, [&](const Session& s) { return s.id == session; }); + return it == sessions_.end() ? nullptr : &*it; +} + +const IntentAdmission::Session* IntentAdmission::find(std::uint64_t session) const { + const auto it = + std::ranges::find_if(sessions_, [&](const Session& s) { return s.id == session; }); + return it == sessions_.end() ? nullptr : &*it; +} + +bool IntentAdmission::open(std::uint64_t session, const AccountId& account) { + if (session == 0 || find(session) || sessions_.size() >= limits_.max_sessions) + return false; + Session s; + s.id = session; + s.account = account; + sessions_.push_back(std::move(s)); + return true; +} + +void IntentAdmission::close(std::uint64_t session) { + // Unsimulated intentions die with the session; actions belong to the account and stay. + std::erase_if(sessions_, [&](const Session& s) { return s.id == session; }); +} + +void IntentAdmission::count_window(Session& s, std::uint64_t server_tick) const { + if (server_tick < s.window_start || server_tick - s.window_start >= limits_.window_ticks) { + s.window_start = server_tick; + s.intent_attempts = 0; + s.action_attempts = 0; + } +} + +std::size_t IntentAdmission::unresolved_of(const Session& s) const { + return s.pending.size() + + static_cast(std::ranges::count_if( + actions_, [&](const Action& a) { return a.carried.account == s.account; })); +} + +std::size_t IntentAdmission::unresolved(std::uint64_t session) const { + const auto* s = find(session); + return s ? unresolved_of(*s) : 0; +} + +IntentionReceipt IntentAdmission::intention(std::uint64_t session, const SessionIntention& m, + const AdmissionFacts& facts) { + IntentionReceipt r{m.sequence, AdmitStatus::admitted, facts.server_tick}; + auto* s = find(session); + if (!s) { + r.status = AdmitStatus::unknown_session; + return r; + } + count_window(*s, facts.server_tick); + const bool over = s->intent_attempts >= limits_.max_intents_per_window; + if (!over) + ++s->intent_attempts; + const std::uint64_t last_tick = s->pending.empty() ? 0 : s->pending.back().tick; + if (over) + r.status = AdmitStatus::rate_limited; + else if (m.session != session) + r.status = AdmitStatus::unknown_session; + else if (!facts.ready) + r.status = AdmitStatus::not_ready; + else if (m.epoch != facts.epoch) + r.status = AdmitStatus::stale_epoch; + else if (!valid_vector(m.move_x, m.move_y)) + r.status = AdmitStatus::invalid_vector; + else if (m.sequence <= s->last_sequence) + r.status = AdmitStatus::replayed; + // One intention per tick (ADR-0089): ticks advance with the sequence. + else if (!in_window(m.tick, facts.server_tick, limits_.intent_window) || m.tick <= last_tick) + r.status = AdmitStatus::outside_window; + else if (unresolved_of(*s) >= limits_.max_unresolved) + r.status = AdmitStatus::too_many_unresolved; + if (r.status == AdmitStatus::admitted) { + s->last_sequence = m.sequence; + s->pending.push_back({m.sequence, m.tick}); + } + return r; +} + +ActionReceipt IntentAdmission::action(std::uint64_t session, const SessionAction& m, + const AdmissionFacts& facts) { + ActionReceipt r{m.action_id, AdmitStatus::admitted, facts.server_tick, m.tick}; + auto* s = find(session); + if (!s) { + r.status = AdmitStatus::unknown_session; + return r; + } + count_window(*s, facts.server_tick); + const bool over = s->action_attempts >= limits_.max_actions_per_window; + if (!over) + ++s->action_attempts; + const auto& account = s->account; + const auto known_action = std::ranges::find_if(actions_, [&](const Action& a) { + return a.carried.account == account && a.carried.action_id == m.action_id; + }); + const auto known_final = std::ranges::find_if(finals_, [&](const AccountOutcome& f) { + return f.account == account && f.outcome.action_id == m.action_id; + }); + if (over) + r.status = AdmitStatus::rate_limited; + else if (m.session != session) + r.status = AdmitStatus::unknown_session; + else if (!facts.ready) + r.status = AdmitStatus::not_ready; + else if (m.epoch != facts.epoch) + r.status = AdmitStatus::stale_epoch; + else if (m.kind != static_cast(ActionKind::probe) || m.action_id == 0) + r.status = AdmitStatus::invalid_action; + else if (known_action != actions_.end() || known_final != finals_.end()) { + // Never admitted twice; the receipt names the tick it was scheduled for. + r.status = AdmitStatus::duplicate; + r.tick = + known_action != actions_.end() ? known_action->carried.tick : known_final->outcome.tick; + } else if (!in_window(m.tick, facts.server_tick, limits_.intent_window)) + r.status = AdmitStatus::outside_window; + else if (unresolved_of(*s) >= limits_.max_unresolved) + r.status = AdmitStatus::too_many_unresolved; + if (r.status == AdmitStatus::admitted) + actions_.push_back({{account, m.action_id, m.tick, ActionKind::probe}, Stage::scheduled}); + return r; +} + +ActionOutcome IntentAdmission::query(std::uint64_t session, const ActionQuery& m) const { + ActionOutcome o{m.action_id, ActionResult::unknown, 0, 0}; + const auto* s = find(session); + if (!s) + return o; + const auto pending = std::ranges::find_if(actions_, [&](const Action& a) { + return a.carried.account == s->account && a.carried.action_id == m.action_id; + }); + if (pending != actions_.end()) { + o.result = ActionResult::pending; + o.tick = pending->carried.tick; + return o; + } + const auto final = std::ranges::find_if(finals_, [&](const AccountOutcome& f) { + return f.account == s->account && f.outcome.action_id == m.action_id; + }); + return final != finals_.end() ? final->outcome : o; +} + +std::vector> +IntentAdmission::simulated(const AdmissionFacts& facts) { + std::vector> out; + for (auto& s : sessions_) { + while (!s.pending.empty() && s.pending.front().tick <= facts.server_tick) { + s.watermark = s.pending.front().sequence; + s.pending.pop_front(); + } + const bool changed = s.watermark != s.sent_watermark; + const bool repeat = + s.watermark != 0 && (facts.server_tick < s.sent_at_tick || + facts.server_tick - s.sent_at_tick >= limits_.watermark_every); + if (changed || repeat) { + s.sent_watermark = s.watermark; + s.sent_at_tick = facts.server_tick; + out.emplace_back(s.id, SimulatedThrough{facts.epoch, s.watermark, facts.server_tick}); + } + } + return out; +} + +std::vector IntentAdmission::carry(std::uint64_t tick) { + std::vector out; + for (auto& a : actions_) + if (a.stage == Stage::scheduled && a.carried.tick <= tick) { + a.stage = Stage::carried; + out.push_back(a.carried); + } + return out; +} + +void IntentAdmission::remember(const AccountId& account, const ActionOutcome& outcome) { + finals_.push_back({account, outcome}); + while (finals_.size() > limits_.max_finals) + finals_.pop_front(); +} + +std::vector IntentAdmission::committed(std::uint64_t end_tick, + std::uint64_t commit_sequence) { + std::vector out; + std::erase_if(actions_, [&](const Action& a) { + if (a.stage != Stage::carried || a.carried.tick > end_tick) + return false; + const ActionOutcome o{a.carried.action_id, ActionResult::committed_no_effect, + a.carried.tick, commit_sequence}; + out.push_back({a.carried.account, o}); + remember(a.carried.account, o); + return true; + }); + return out; +} + +std::vector IntentAdmission::abandon() { + std::vector out; + std::erase_if(actions_, [&](const Action& a) { + if (a.stage != Stage::scheduled) + return false; + const ActionOutcome o{a.carried.action_id, ActionResult::not_committed, 0, 0}; + out.push_back({a.carried.account, o}); + remember(a.carried.account, o); + return true; + }); + for (auto& s : sessions_) + s.pending.clear(); // Superseding intentions of a lost epoch are simply dropped. + return out; +} + +std::optional IntentAdmission::session_of(const AccountId& account) const { + const auto it = + std::ranges::find_if(sessions_, [&](const Session& s) { return s.account == account; }); + if (it == sessions_.end()) + return std::nullopt; + return it->id; +} +} // namespace evo::network diff --git a/src/network/protocol/session_protocol.cpp b/src/network/protocol/session_protocol.cpp index 3fa28f8..cb98aea 100644 --- a/src/network/protocol/session_protocol.cpp +++ b/src/network/protocol/session_protocol.cpp @@ -4,10 +4,18 @@ namespace evo::network { namespace { constexpr std::size_t hello_bytes = 4 + session_grant_wire_bytes; -constexpr std::size_t welcome_bytes = std::size_t{7} * 8; +constexpr std::size_t welcome_bytes = std::size_t{8} * 8; constexpr std::size_t refresh_bytes = session_grant_wire_bytes; constexpr std::size_t refresh_result_bytes = 1 + 8; constexpr std::size_t close_bytes = 1; +constexpr std::size_t intention_bytes = (std::size_t{4} * 8) + 4; +constexpr std::size_t intention_receipt_bytes = 8 + 1 + 8; +constexpr std::size_t simulated_bytes = std::size_t{3} * 8; +constexpr std::size_t action_bytes = (std::size_t{3} * 8) + 2 + 8; +constexpr std::size_t action_receipt_bytes = 8 + 1 + 8 + 8; +constexpr std::size_t action_outcome_bytes = 8 + 1 + 8 + 8; +constexpr std::size_t action_query_bytes = 8; +constexpr std::uint8_t max_admit_status = static_cast(AdmitStatus::not_ready); void put(std::vector& out, std::uint64_t v, std::size_t count) { for (std::size_t i = 0; i < count; ++i) @@ -49,8 +57,8 @@ std::vector encode_session(const SessionMessage& message) { } std::vector operator()(const SessionWelcome& m) const { auto out = header(SessionMessageType::welcome, welcome_bytes); - for (const auto v : - {m.session, m.epoch, m.world, m.frame, m.region, m.expires_at, m.server_seconds}) + 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; } @@ -70,6 +78,56 @@ std::vector encode_session(const SessionMessage& message) { out.push_back(static_cast(m.reason)); return out; } + std::vector operator()(const SessionIntention& m) const { + auto out = header(SessionMessageType::intention, intention_bytes); + for (const auto v : {m.session, m.epoch, m.sequence, m.tick}) + put(out, v, 8); + put(out, static_cast(m.move_x), 2); + put(out, static_cast(m.move_y), 2); + return out; + } + std::vector operator()(const IntentionReceipt& m) const { + auto out = header(SessionMessageType::intention_receipt, intention_receipt_bytes); + put(out, m.sequence, 8); + out.push_back(static_cast(m.status)); + put(out, m.server_tick, 8); + return out; + } + std::vector operator()(const SimulatedThrough& m) const { + auto out = header(SessionMessageType::simulated_through, simulated_bytes); + for (const auto v : {m.epoch, m.sequence, m.tick}) + put(out, v, 8); + return out; + } + std::vector operator()(const SessionAction& m) const { + auto out = header(SessionMessageType::action, action_bytes); + for (const auto v : {m.session, m.epoch, m.action_id}) + put(out, v, 8); + put(out, m.kind, 2); + put(out, m.tick, 8); + return out; + } + std::vector operator()(const ActionReceipt& m) const { + auto out = header(SessionMessageType::action_receipt, action_receipt_bytes); + put(out, m.action_id, 8); + out.push_back(static_cast(m.status)); + put(out, m.server_tick, 8); + put(out, m.tick, 8); + return out; + } + std::vector operator()(const ActionOutcome& m) const { + auto out = header(SessionMessageType::action_outcome, action_outcome_bytes); + put(out, m.action_id, 8); + out.push_back(static_cast(m.result)); + put(out, m.tick, 8); + put(out, m.commit_sequence, 8); + return out; + } + std::vector operator()(const ActionQuery& m) const { + auto out = header(SessionMessageType::action_query, action_query_bytes); + put(out, m.action_id, 8); + return out; + } }; return std::visit(Encoder{}, message); } @@ -99,8 +157,8 @@ decode_session(std::span bytes) { if (!expect(welcome_bytes)) return std::unexpected(SessionCodecError::wrong_length); SessionWelcome m; - std::uint64_t* fields[] = {&m.session, &m.epoch, &m.world, &m.frame, - &m.region, &m.expires_at, &m.server_seconds}; + std::uint64_t* fields[] = {&m.session, &m.epoch, &m.world, &m.frame, + &m.region, &m.expires_at, &m.server_seconds, &m.server_tick}; for (std::size_t i = 0; i < std::size(fields); ++i) *fields[i] = get(payload, 8 * i, 8); if (m.session == 0 || m.epoch == 0) @@ -127,6 +185,64 @@ decode_session(std::span bytes) { return std::unexpected(SessionCodecError::invalid_value); return SessionClose{static_cast(payload[0])}; } + case static_cast(SessionMessageType::intention): { + if (!expect(intention_bytes)) + return std::unexpected(SessionCodecError::wrong_length); + SessionIntention m; + m.session = get(payload, 0, 8); + m.epoch = get(payload, 8, 8); + m.sequence = get(payload, 16, 8); + m.tick = get(payload, 24, 8); + m.move_x = static_cast(static_cast(get(payload, 32, 2))); + m.move_y = static_cast(static_cast(get(payload, 34, 2))); + return m; // Ranges belong to admission, which answers with a status. + } + case static_cast(SessionMessageType::intention_receipt): { + if (!expect(intention_receipt_bytes)) + return std::unexpected(SessionCodecError::wrong_length); + if (payload[8] > max_admit_status) + return std::unexpected(SessionCodecError::invalid_value); + return IntentionReceipt{get(payload, 0, 8), static_cast(payload[8]), + get(payload, 9, 8)}; + } + case static_cast(SessionMessageType::simulated_through): { + if (!expect(simulated_bytes)) + return std::unexpected(SessionCodecError::wrong_length); + return SimulatedThrough{get(payload, 0, 8), get(payload, 8, 8), get(payload, 16, 8)}; + } + case static_cast(SessionMessageType::action): { + if (!expect(action_bytes)) + return std::unexpected(SessionCodecError::wrong_length); + SessionAction m; + m.session = get(payload, 0, 8); + m.epoch = get(payload, 8, 8); + m.action_id = get(payload, 16, 8); + m.kind = static_cast(get(payload, 24, 2)); // Admission checks it. + m.tick = get(payload, 26, 8); + return m; + } + case static_cast(SessionMessageType::action_receipt): { + if (!expect(action_receipt_bytes)) + return std::unexpected(SessionCodecError::wrong_length); + if (payload[8] > max_admit_status) + return std::unexpected(SessionCodecError::invalid_value); + return ActionReceipt{get(payload, 0, 8), static_cast(payload[8]), + get(payload, 9, 8), get(payload, 17, 8)}; + } + case static_cast(SessionMessageType::action_outcome): { + if (!expect(action_outcome_bytes)) + return std::unexpected(SessionCodecError::wrong_length); + if (payload[8] < static_cast(ActionResult::committed_no_effect) || + payload[8] > static_cast(ActionResult::unknown)) + return std::unexpected(SessionCodecError::invalid_value); + return ActionOutcome{get(payload, 0, 8), static_cast(payload[8]), + get(payload, 9, 8), get(payload, 17, 8)}; + } + case static_cast(SessionMessageType::action_query): { + if (!expect(action_query_bytes)) + return std::unexpected(SessionCodecError::wrong_length); + return ActionQuery{get(payload, 0, 8)}; + } default: return std::unexpected(SessionCodecError::unknown_type); } diff --git a/src/server/session/region_sessions.cpp b/src/server/session/region_sessions.cpp index 3113db9..cd581c0 100644 --- a/src/server/session/region_sessions.cpp +++ b/src/server/session/region_sessions.cpp @@ -62,14 +62,16 @@ struct RegionSessions::Impl { }; Impl(RegionSessionsConfig c, std::unique_ptr e, - network::GrantVerifier v, network::SessionControl s) + network::GrantVerifier v, network::SessionControl s, network::IntentAdmission i) : config{std::move(c)}, endpoint{std::move(e)}, verifier{std::move(v)}, - control{std::move(s)} {} + control{std::move(s)}, intents{std::move(i)} {} RegionSessionsConfig config; std::unique_ptr endpoint; network::GrantVerifier verifier; network::SessionControl control; + network::IntentAdmission intents; + HostFacts facts; std::vector connections; std::vector events; @@ -89,6 +91,13 @@ struct RegionSessions::Impl { // A refused send (budget) leaves the peer to observe the transport close instead. (void)endpoint->send_message(c.id, network::encode_session(m)).has_value(); } + // Realtime answers: a refused datagram is dropped; cumulative watermarks cover it. + void send_datagram(const Connection& c, const network::SessionMessage& m) { + (void)endpoint->send_datagram(c.id, network::encode_session(m)).has_value(); + } + [[nodiscard]] network::AdmissionFacts admission() const { + return {facts.ready, control.epoch(), facts.simulated_tick}; + } // Sends Close, releases control, reports, and closes after the flush deadline. void close(Connection& c, SessionCloseReason reason, Clock::time_point now) { if (c.state == State::closing) @@ -101,6 +110,8 @@ struct RegionSessions::Impl { event.account = c.account; event.reason = reason; events.push_back(std::move(event)); + if (c.state == State::established) + intents.close(c.session); if (c.session != 0) // May already be released (superseded, expired, epoch). (void)control.close(c.session).has_value(); // A superseded session's durable control already moved to its successor. @@ -166,11 +177,14 @@ struct RegionSessions::Impl { return; } } - welcome(c); + welcome(c, now); } - void welcome(Connection& c) { + void welcome(Connection& c, Clock::time_point now) { + if (!intents.open(c.session, c.account_id)) + return close(c, SessionCloseReason::capacity, now); c.state = State::established; + c.welcome.server_tick = facts.simulated_tick; send(c, c.welcome); events.push_back({RegionSessionEvent::Kind::opened, c.session, c.account, {}}); } @@ -225,6 +239,24 @@ struct RegionSessions::Impl { send(c, result); } + // Only established sessions may send datagrams, and only intentions. + void datagram(Connection& c, std::span bytes, Clock::time_point now) { + if (c.state == State::closing) + return; + const auto decoded = network::decode_session(bytes); + const auto* m = decoded ? std::get_if(&*decoded) : nullptr; + if (c.state != State::established || !m) + return close(c, SessionCloseReason::protocol, now); + send_datagram(c, intents.intention(c.session, *m, admission())); + } + + void deliver(const std::vector& outcomes) { + for (const auto& o : outcomes) + if (const auto session = intents.session_of(o.account)) + if (auto* c = by_session(*session); c && c->state == State::established) + send(*c, o.outcome); + } + void message(Connection& c, std::span bytes, std::uint64_t now_seconds, Clock::time_point now) { if (c.state == State::closing) @@ -245,6 +277,19 @@ struct RegionSessions::Impl { } if (const auto* m = std::get_if(&*decoded)) return refresh(c, *m, now_seconds, now); + if (const auto* m = std::get_if(&*decoded)) { + const auto receipt = intents.action(c.session, *m, admission()); + send(c, receipt); + // A duplicate of a final action: answer with the outcome as well. + if (receipt.status == network::AdmitStatus::duplicate) + if (const auto o = intents.query(c.session, {m->action_id}); + o.result == network::ActionResult::committed_no_effect || + o.result == network::ActionResult::not_committed) + send(c, o); + return; + } + if (const auto* m = std::get_if(&*decoded)) + return send(c, intents.query(c.session, *m)); if (const auto* m = std::get_if(&*decoded); m && m->reason == SessionCloseReason::client_closed) { close(c, SessionCloseReason::client_closed, now); @@ -275,22 +320,31 @@ RegionSessions::create(RegionSessionsConfig config) { for (const auto& k : config.issuer_keys) if (!verifier->add_key(k.key_id, k.public_key)) return std::unexpected(RegionSessionsError::keys); + config.intents.max_sessions = config.control.max_sessions; + auto intents = network::IntentAdmission::create(config.intents); + if (!intents) + return std::unexpected(RegionSessionsError::configuration); auto endpoint = network::quic::Endpoint::serve(config.transport); if (!endpoint) return std::unexpected(RegionSessionsError::transport); - return std::unique_ptr{new RegionSessions{std::make_unique( - std::move(config), std::move(*endpoint), std::move(*verifier), std::move(*control))}}; + return std::unique_ptr{new RegionSessions{ + std::make_unique(std::move(config), std::move(*endpoint), std::move(*verifier), + std::move(*control), std::move(*intents))}}; } -void RegionSessions::poll(std::uint64_t epoch, std::uint64_t now_seconds, Clock::time_point now) { +void RegionSessions::poll(const HostFacts& facts, std::uint64_t now_seconds, + Clock::time_point now) { auto& m = *impl_; - if (epoch > m.control.epoch()) { - // Every session ends with the epoch (ADR-0089); control has released them. - const auto closed = m.control.advance_epoch(epoch); + m.facts = facts; + if (facts.epoch > m.control.epoch()) { + // Every session ends with the epoch (ADR-0089); control has released them. Actions + // never carried are final; carried ones await their durable record. + const auto closed = m.control.advance_epoch(facts.epoch); if (closed) for (const auto session : *closed) if (auto* c = m.by_session(session)) m.close(*c, SessionCloseReason::stale_epoch, now); + (void)m.intents.abandon(); // Kept for queries; no session is left to tell. } for (auto& e : m.endpoint->poll()) { using network::quic::EventKind; @@ -307,6 +361,8 @@ void RegionSessions::poll(std::uint64_t epoch, std::uint64_t now_seconds, Clock: m.connections, [&](const Impl::Connection& c) { return c.id == e.connection; }); if (it == m.connections.end()) continue; + if (it->state == Impl::State::established) + m.intents.close(it->session); if (it->state == Impl::State::pending) { (void)m.control.close(it->session).has_value(); if (m.config.ledger && it->generation != 0) @@ -323,15 +379,21 @@ void RegionSessions::poll(std::uint64_t epoch, std::uint64_t now_seconds, Clock: : SessionCloseReason::connection_lost}); } m.connections.erase(it); - } // Datagrams carry nothing before 10.4. + } else if (e.kind == EventKind::datagram) { + if (auto* c = m.find(e.connection)) + m.datagram(*c, e.bytes, now); + } } + for (const auto& [session, watermark] : m.intents.simulated(m.admission())) + if (auto* c = m.by_session(session); c && c->state == Impl::State::established) + m.send_datagram(*c, watermark); for (const auto session : m.control.expire(now_seconds)) if (auto* c = m.by_session(session)) m.close(*c, SessionCloseReason::expired, now); for (auto& c : m.connections) { m.renew(c, now); if (c.state == Impl::State::pending && now >= c.deadline) - m.welcome(c); + m.welcome(c, now); if (c.state == Impl::State::hello && now >= c.deadline) m.close(c, SessionCloseReason::timeout, now); if (c.state == Impl::State::closing && now >= c.deadline && !c.close_requested) { @@ -341,6 +403,14 @@ void RegionSessions::poll(std::uint64_t epoch, std::uint64_t now_seconds, Clock: } } +std::vector RegionSessions::carry(std::uint64_t tick) { + return impl_->intents.carry(tick); +} + +void RegionSessions::committed(std::uint64_t end_tick, std::uint64_t commit_sequence) { + impl_->deliver(impl_->intents.committed(end_tick, commit_sequence)); +} + void RegionSessions::shutdown(Clock::time_point now) { for (auto& c : impl_->connections) impl_->close(c, SessionCloseReason::shutdown, now); diff --git a/tests/network_control.cpp b/tests/network_control.cpp index 4b51932..b427feb 100644 --- a/tests/network_control.cpp +++ b/tests/network_control.cpp @@ -1,5 +1,6 @@ #include "evo/identity/identity.hpp" #include "evo/network/dev_grant.hpp" +#include "evo/network/intent_admission.hpp" #include "evo/network/session_control.hpp" #include "evo/network/session_grant.hpp" #include "evo/network/session_protocol.hpp" @@ -326,7 +327,7 @@ void session_codec() { WireGrant grant{}; for (std::size_t i = 0; i < grant.size(); ++i) grant.at(i) = static_cast(i * 7); - SessionWelcome welcome{1, 2, 3, 4, 5, 6, 7}; + SessionWelcome welcome{1, 2, 3, 4, 5, 6, 7, 8}; const std::vector messages{ SessionHello{0, grant}, welcome, @@ -334,7 +335,14 @@ void session_codec() { SessionRefreshResult{0, 99}, SessionRefreshResult{static_cast(SessionCloseReason::stale_grant), 0}, SessionClose{SessionCloseReason::superseded}, - SessionClose{SessionCloseReason::shutdown}}; + SessionClose{SessionCloseReason::shutdown}, + SessionIntention{1, 2, 3, 4, -1000, 7}, + IntentionReceipt{3, AdmitStatus::not_ready, 9}, + SimulatedThrough{2, 3, 4}, + SessionAction{1, 2, 77, 1, 5}, + ActionReceipt{77, AdmitStatus::duplicate, 4, 5}, + ActionOutcome{77, ActionResult::committed_no_effect, 5, 12}, + ActionQuery{77}}; for (const auto& m : messages) { const auto bytes = encode_session(m); CHECK(bytes.at(0) == 'E' && bytes.at(1) == 'V' && bytes.at(2) == 'S' && bytes.at(3) == 'N'); @@ -359,7 +367,7 @@ void session_codec() { mutated = bytes; mutated.at(7) = 1; CHECK(refused(decode_session(mutated), SessionCodecError::reserved_flags)); - for (const auto type : std::array{0, 6, 255}) { + for (const auto type : std::array{0, 13, 255}) { mutated = bytes; mutated.at(6) = type; CHECK(refused(decode_session(mutated), SessionCodecError::unknown_type)); @@ -378,12 +386,140 @@ void session_codec() { CHECK(refused(decode_session(result), SessionCodecError::invalid_value)); } } + // Decoded values survive exactly (signed vectors, every field). + const SessionIntention intent{9, 8, 7, 6, -1000, 999}; + CHECK(std::get(*decode_session(encode_session(intent))) == intent); + const ActionOutcome outcome{5, ActionResult::not_committed, 0, 0}; + CHECK(std::get(*decode_session(encode_session(outcome))) == outcome); + // A state claim appended to an intention (position, energy) is not a valid message. + auto claimed = encode_session(intent); + for (int i = 0; i < 16; ++i) + claimed.push_back(0x7F); + CHECK(refused(decode_session(claimed), SessionCodecError::wrong_length)); + for (const auto bad : std::array{11, 200, 255}) { + auto receipt = encode_session(IntentionReceipt{1, AdmitStatus::admitted, 1}); + receipt.at(session_header_bytes + 8) = bad; + CHECK(refused(decode_session(receipt), SessionCodecError::invalid_value)); + } + for (const auto bad : std::array{0, 5, 255}) { + auto o = encode_session(outcome); + o.at(session_header_bytes + 8) = bad; + CHECK(refused(decode_session(o), SessionCodecError::invalid_value)); + } for (const auto zero : {0, 1}) { auto w = welcome; (zero == 0 ? w.session : w.epoch) = 0; CHECK(refused(decode_session(encode_session(w)), SessionCodecError::invalid_value)); } } +void intent_admission() { + IntentLimits limits; + limits.max_unresolved = 6; + limits.max_finals = 4; + CHECK(refused(IntentAdmission::create(IntentLimits{0}), IntentConfigError::invalid)); + auto a = *IntentAdmission::create(limits); + const auto alice = account(1), bob = account(2); + CHECK(a.open(1, alice) && a.open(2, bob) && !a.open(1, alice) && !a.open(0, alice)); + AdmissionFacts f{true, 5, 100}; + const auto intention = [&](std::uint64_t session, std::uint64_t seq, std::uint64_t tick, + std::int16_t x = 0, std::uint64_t epoch = 5) { + return a.intention(session, SessionIntention{session, epoch, seq, tick, x, 0}, f).status; + }; + // Every refusal, in the order admission applies them. + CHECK(intention(1, 1, 101) == AdmitStatus::admitted); + CHECK(a.intention(1, SessionIntention{2, 5, 2, 102, 0, 0}, f).status == + AdmitStatus::unknown_session); // Names another session. + CHECK(a.intention(9, SessionIntention{9, 5, 2, 102, 0, 0}, f).status == + AdmitStatus::unknown_session); // No such session. + CHECK(intention(1, 2, 102, 0, 4) == AdmitStatus::stale_epoch); + CHECK(intention(1, 2, 102, 1001) == AdmitStatus::invalid_vector); + CHECK(intention(1, 1, 102) == AdmitStatus::replayed); + CHECK(intention(1, 2, 100) == AdmitStatus::outside_window); // Not in the future. + CHECK(intention(1, 2, 109) == AdmitStatus::outside_window); // Beyond 8 ticks. + CHECK(intention(1, 2, 101) == AdmitStatus::outside_window); // Same tick as before. + CHECK(intention(1, 2, 102) == AdmitStatus::rate_limited); // 8 attempts this window. + f.server_tick = 108; // New window. + f.ready = false; + CHECK(intention(1, 2, 109) == AdmitStatus::not_ready); + f.ready = true; + CHECK(intention(1, 2, 109) == AdmitStatus::admitted); + CHECK(intention(1, 3, 110) == AdmitStatus::admitted); + // Simulated watermark: only intentions whose tick ran, cumulatively. + f.server_tick = 109; + auto marks = a.simulated(f); + CHECK(marks.size() == 1 && marks[0].first == 1 && + marks[0].second == SimulatedThrough{5, 2, 109}); + CHECK(a.simulated(f).empty()); // Unchanged: not repeated yet. + f.server_tick = 110; + marks = a.simulated(f); + CHECK(marks.size() == 1 && marks[0].second.sequence == 3); + f.server_tick = 130; + marks = a.simulated(f); // Repeated after 20 ticks so a lost datagram is covered. + CHECK(marks.size() == 1 && marks[0].second == SimulatedThrough{5, 3, 130}); + + // Actions: receipt, carried with its tick's batch, final after the commit. + const auto action = [&](std::uint64_t session, std::uint64_t id, std::uint64_t tick, + std::uint16_t kind = 1) { + return a.action(session, SessionAction{session, 5, id, kind, tick}, f); + }; + f.server_tick = 200; + auto r = action(1, 10, 203); + CHECK(r.status == AdmitStatus::admitted && r.tick == 203 && r.server_tick == 200); + CHECK(a.query(1, {10}).result == ActionResult::pending); + CHECK(action(1, 0, 203).status == AdmitStatus::invalid_action); + CHECK(action(1, 11, 203, 9).status == AdmitStatus::invalid_action); + { // Wire kind 257 must not truncate to a known kind. + auto other = *IntentAdmission::create(IntentLimits{}); + CHECK(other.open(1, alice)); + CHECK(other.action(1, SessionAction{1, 5, 1, 257, 101}, AdmissionFacts{true, 5, 100}) + .status == AdmitStatus::invalid_action); + } + r = action(1, 10, 204); // Retry with another tick: the original stands. + CHECK(r.status == AdmitStatus::duplicate && r.tick == 203); + CHECK(action(1, 12, 203).status == AdmitStatus::rate_limited); // 4 action attempts. + CHECK(a.carry(202).empty()); + const auto carried = a.carry(203); + CHECK(carried.size() == 1 && carried[0] == CarriedAction{alice, 10, 203, ActionKind::probe}); + CHECK(a.carry(203).empty()); // Each action is carried once. + CHECK(a.committed(202, 7).empty()); + auto outcomes = a.committed(203, 8); + CHECK(outcomes.size() == 1 && outcomes[0].account == alice && + outcomes[0].outcome == ActionOutcome{10, ActionResult::committed_no_effect, 203, 8}); + CHECK(a.query(1, {10}) == outcomes[0].outcome); + CHECK(a.query(2, {10}).result == ActionResult::unknown); // Bob's account has no action 10. + // A reconnect of the same account (new session) sees the same outcome. + a.close(1); + CHECK(a.query(1, {10}).result == ActionResult::unknown); // Closed session asks nothing. + CHECK(a.open(3, alice) && a.session_of(alice) == 3u); + CHECK(a.query(3, {10}) == outcomes[0].outcome); + f.server_tick = 300; + CHECK(action(3, 10, 301).status == AdmitStatus::duplicate); // Never admitted twice. + // Unresolved cap counts intentions and actions; abandon finalizes only uncarried actions. + CHECK(action(3, 20, 301).status == AdmitStatus::admitted); + CHECK(action(3, 21, 308).status == AdmitStatus::admitted); + (void)a.carry(301); + for (std::uint64_t i = 0; i < 4; ++i) + CHECK(a.intention(3, SessionIntention{3, 5, i + 1, 302 + i, 0, 0}, f).status == + AdmitStatus::admitted); + CHECK(a.unresolved(3) == 6); + CHECK(a.intention(3, SessionIntention{3, 5, 9, 307, 0, 0}, f).status == + AdmitStatus::too_many_unresolved); + outcomes = a.abandon(); + CHECK(outcomes.size() == 1 && + outcomes[0].outcome == ActionOutcome{21, ActionResult::not_committed, 0, 0}); + CHECK(a.query(3, {20}).result == ActionResult::pending); // Carried: awaits its record. + CHECK(a.unresolved(3) == 1); + CHECK(a.committed(301, 9).size() == 1); // Its batch turned out durable. + // Final outcomes are kept within a bound; older ones become unknown here. + for (std::uint64_t id = 30; id < 34; ++id) { + f.server_tick += 8; + CHECK(action(3, id, f.server_tick + 1).status == AdmitStatus::admitted); + (void)a.carry(f.server_tick + 1); + CHECK(a.committed(f.server_tick + 1, id).size() == 1); + } + CHECK(a.query(3, {10}).result == ActionResult::unknown); + CHECK(a.query(3, {33}).result == ActionResult::committed_no_effect); +} } // namespace void control_tests() { @@ -391,5 +527,6 @@ void control_tests() { identity_adapter(); control_rules(); session_codec(); + intent_admission(); } } // namespace evo::network_test diff --git a/tests/quic_sessions.cpp b/tests/quic_sessions.cpp index 07271d3..94e9d49 100644 --- a/tests/quic_sessions.cpp +++ b/tests/quic_sessions.cpp @@ -150,7 +150,7 @@ struct Harness { return std::move(*made); } void pump() { - server->poll(epoch, now_seconds, Clock::now()); + server->poll({ready, epoch, tick}, now_seconds, Clock::now()); for (auto& e : server->take_events()) events.push_back(std::move(e)); for (auto* c : clients) @@ -189,7 +189,8 @@ struct Harness { std::unique_ptr server; std::vector clients; std::vector events; - std::uint64_t epoch{5}, now_seconds{start}; + std::uint64_t epoch{5}, now_seconds{start}, tick{100}; + bool ready{true}; }; bool refused_with(Harness& h, const WireGrant& grant, Reason reason) { @@ -370,6 +371,103 @@ struct FakeLedger final : ControlLedger { std::vector renewed, released; }; +// M10.4: intentions, actions and their distinct answers against a simulated host. +void intentions_and_actions(const Files& f) { + Harness h{f}; + const auto alice = account(1); + auto a = h.connect(h.issuer.grant(alice, 1)); + CHECK(h.settled(*a) && must(a->welcome()).server_tick == 100 && a->server_tick() == 100); + // Intention: a receipt, then the simulated watermark once its tick runs. + CHECK(a->send_intention(101, 10, -10) == 1u); + std::vector receipts; + CHECK(h.until([&] { return !(receipts = a->take_intention_receipts()).empty(); })); + CHECK(receipts[0] == IntentionReceipt{1, AdmitStatus::admitted, 100}); + CHECK(!a->simulated()); + CHECK(a->send_intention(150, 0, 0) == 2u); + CHECK(h.until([&] { return !(receipts = a->take_intention_receipts()).empty(); })); + CHECK(receipts[0].status == AdmitStatus::outside_window); + h.tick = 101; + CHECK(h.until([&] { return a->simulated() && a->simulated()->sequence == 1; })); + CHECK(must(a->simulated()) == SimulatedThrough{5, 1, 101} && a->server_tick() == 101); + h.ready = false; + CHECK(a->send_intention(103, 0, 0) == 3u); + CHECK(h.until([&] { return !(receipts = a->take_intention_receipts()).empty(); })); + CHECK(receipts[0].status == AdmitStatus::not_ready); + h.ready = true; + // Action: receipt (scheduled), carried with its tick's batch, final after the commit. + CHECK(a->send_action(7, ActionKind::probe, 103)); + std::vector action_receipts; + CHECK(h.until([&] { return !(action_receipts = a->take_action_receipts()).empty(); })); + CHECK(action_receipts[0] == ActionReceipt{7, AdmitStatus::admitted, 101, 103}); + CHECK(a->query_action(7)); + std::vector outcomes; + CHECK(h.until([&] { return !(outcomes = a->take_action_outcomes()).empty(); })); + CHECK(outcomes[0].result == ActionResult::pending); + CHECK(h.server->carry(102).empty()); + const auto carried = h.server->carry(103); + CHECK(carried.size() == 1 && carried[0] == CarriedAction{alice, 7, 103, ActionKind::probe}); + h.server->committed(103, 4); + CHECK(h.until([&] { return !(outcomes = a->take_action_outcomes()).empty(); })); + CHECK(outcomes[0] == ActionOutcome{7, ActionResult::committed_no_effect, 103, 4}); + // A retry gets a duplicate receipt and the same final outcome. + CHECK(a->send_action(7, ActionKind::probe, 104)); + CHECK(h.until([&] { return !(outcomes = a->take_action_outcomes()).empty(); })); + CHECK(outcomes[0] == ActionOutcome{7, ActionResult::committed_no_effect, 103, 4}); + // The stream is ordered: the duplicate receipt arrived before the repeated outcome. + const auto duplicates = a->take_action_receipts(); + CHECK(duplicates.size() == 1 && + duplicates[0] == ActionReceipt{7, AdmitStatus::duplicate, 101, 103}); + // Reconnect (lost connection, new grant): the account's action resolves the same way. + auto b = h.connect(h.issuer.grant(alice, 2)); + CHECK(h.settled(*b) && b->state() == RegionSessionState::established); + CHECK(b->query_action(7)); + CHECK(h.until([&] { return !(outcomes = b->take_action_outcomes()).empty(); })); + CHECK(outcomes[0] == ActionOutcome{7, ActionResult::committed_no_effect, 103, 4}); + // An action scheduled but never carried when the epoch moves on is final: not committed. + CHECK(b->send_action(8, ActionKind::probe, 108)); + CHECK(h.until([&] { return !b->take_action_receipts().empty(); })); + h.epoch = 6; + CHECK(h.until([&] { return b->state() == RegionSessionState::closed; })); + auto c = h.connect(h.issuer.grant(alice, 3)); + CHECK(h.settled(*c) && c->state() == RegionSessionState::established); + CHECK(c->query_action(8)); + CHECK(h.until([&] { return !(outcomes = c->take_action_outcomes()).empty(); })); + CHECK(outcomes[0].result == ActionResult::not_committed); + // Intentions of an old epoch are refused. + CHECK(c->send_intention(h.tick + 1, 0, 0)); + CHECK(h.until([&] { return !(receipts = c->take_intention_receipts()).empty(); })); + CHECK(receipts[0].status == AdmitStatus::admitted); // c is in epoch 6. + + // A peer that appends state claims (position, energy) to an intention is closed. + auto peer = h.raw(); + quic::ConnectionId id = 0; + std::optional welcome; + std::optional reason; + CHECK(h.until([&] { + for (auto& e : peer->poll()) { + if (e.kind == quic::EventKind::connected) { + id = e.connection; + CHECK(peer->send_message( + id, encode_session(SessionHello{0, h.issuer.grant(account(4), 1)}))); + } else if (e.kind == quic::EventKind::message) { + const auto m = decode_session(e.bytes); + if (m && std::holds_alternative(*m)) { + welcome = std::get(*m); + auto claim = encode_session( + SessionIntention{welcome->session, welcome->epoch, 1, h.tick + 1, 0, 0}); + for (int i = 0; i < 16; ++i) + claim.push_back(0x7F); // "position" and "energy" + CHECK(peer->send_datagram(id, claim)); + } else if (m && std::holds_alternative(*m)) { + reason = std::get(*m).reason; + } + } + } + return reason.has_value(); + })); + CHECK(welcome && reason == Reason::protocol); +} + void durable_control(const Files& f) { FakeLedger ledger; Harness h{f, 4, 64, &ledger}; @@ -444,6 +542,7 @@ int main() try { login_rules(files); limits(files); durable_control(files); + intentions_and_actions(files); std::filesystem::remove_all(files.dir); std::puts("quic session tests passed"); return 0;