Add M10.5b snapshot wiring: sessions, evo-server, client and probe
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m54s
Foundation / checks (client) (push) Successful in 12m40s
Foundation / checks (network) (push) Successful in 11m27s
Foundation / checks (tsan) (push) Successful in 8m6s
Foundation / checks (checks) (push) Successful in 31m54s
Foundation / checks (postgres) (push) Successful in 40m43s
Foundation / server-image (push) Successful in 25s
Foundation / postgres-tools (push) Successful in 1m2s
Foundation / image (push) Successful in 2m32s

RegionSessions owns the replication server: interest and acks per session, a
host-set default interest, and per-tick snapshots sized to each connection's
datagram limit. evo-server builds each interest's view from the region's own
habitat sites (default: the first site, radius 7). RegionSessionClient assembles,
acknowledges and presents snapshots and can change its interest; the probe prints
them. Loopback and real-process evidence. ADR-0093.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dingo
2026-10-06 10:47:47 -04:00
co-authored by Claude Opus 5.5
parent e640b6d3a3
commit 33e91458e7
15 changed files with 428 additions and 23 deletions
+64 -4
View File
@@ -7,6 +7,8 @@
// scheduled for upcoming ticks are submitted to the host, which commits them with the batch
// of the tick they ride; the host's action acknowledgements and drops become outcomes.
// Session control and action records use their own connection under the host's lease.
// M10.5 (ADR-0093): once per simulated tick every session's snapshot is built from the
// region's own stores for its interest (default: the region's first habitat site, radius 7).
#include "evo/persistence/postgres.hpp"
#include "evo/persistence/region_lease.hpp"
#include <cstdint>
@@ -14,6 +16,8 @@
#include <string>
#ifdef EVO_SERVER_M10
#include "evo/client/environment_view.hpp"
#include "evo/processes/lineage_region.hpp"
#include "evo/server/pg_slot.hpp"
#include "evo/server/postgres_action_ledger.hpp"
#include "evo/server/postgres_control_ledger.hpp"
@@ -61,9 +65,9 @@ template <typename Host> class M10Bridge {
if (!window)
return fail(window.error() == server::SessionWindow::Error::expired
? "error m10-window-expired"
: window.error() == server::SessionWindow::Error::too_long
? "error m10-window-too-long"
: "error m10-window");
: window.error() == server::SessionWindow::Error::too_long
? "error m10-window-too-long"
: "error m10-window");
const auto colon = o.listen.rfind(':');
std::uint16_t port = 0;
if (colon == std::string::npos ||
@@ -129,6 +133,19 @@ template <typename Host> class M10Bridge {
const server::HostFacts facts{s.ready && s.phase == server::HostPhase::running, s.epoch,
s.simulated_tick};
sessions_->poll(facts, wall_seconds(), std::chrono::steady_clock::now());
if (facts.ready && host.state() != nullptr && s.simulated_tick > replicated_) {
replicated_ = s.simulated_tick;
const auto& c = community(*host.state());
if (!default_interest_)
if (const auto& sites = c.resources().fields().sites(); !sites.empty()) {
const auto v = sites.front().voxel;
default_interest_ = network::SessionInterest{v.x, v.y, v.z, 7};
sessions_->set_default_interest(*default_interest_);
}
sessions_->replicate(s.simulated_tick, [&](const network::SessionInterest& in) {
return source(c, in, s.simulated_tick);
});
}
if (facts.ready)
for (const auto& a : sessions_->carry(s.simulated_tick + m10_carry_ahead_ticks)) {
const persistence::ActionRecord record{a.account.bytes, a.action_id, a.tick,
@@ -164,6 +181,44 @@ template <typename Host> class M10Bridge {
}
private:
static const processes::EnvironmentalCommunity&
community(const processes::EnvironmentalCommunity& c) {
return c;
}
static const processes::EnvironmentalCommunity& community(const processes::LineageRegion& r) {
return r.community();
}
// A read-only copy of the region's stores within one interest: the habitat sites of its
// square in its slice. The region has no placed individuals: organisms stay empty.
network::ReplicationSource source(const processes::EnvironmentalCommunity& c,
const network::SessionInterest& in, std::uint64_t tick) {
network::ReplicationSource src;
src.mask = world::all_environment_fields;
const auto& fields = c.resources().fields();
std::vector<world::VoxelAddress> footprint;
for (const auto& site : fields.sites()) {
const auto v = site.voxel;
if (v.z == in.z && v.x >= in.x - in.radius && v.x <= in.x + in.radius &&
v.y >= in.y - in.radius && v.y <= in.y + in.radius &&
footprint.size() < world::max_environment_footprint)
footprint.push_back(v);
}
if (footprint.empty())
return src;
const auto view = world::query_environment(fields, c.resources().terrain(), tick, footprint,
world::all_environment_fields);
if (!view) {
if (!warned_)
std::printf("m10 view-unavailable %u\n", static_cast<unsigned>(view.error()));
warned_ = true;
return src;
}
src.identity = view->identity();
src.field_revision = view->field_revision();
if (const auto cells = client::present_environment(*view, in.z))
src.environment.assign(cells->cells().begin(), cells->cells().end());
return src;
}
static network::CarriedAction carried(const persistence::ActionRecord& r) {
network::CarriedAction a;
a.account.bytes = r.account;
@@ -193,6 +248,9 @@ template <typename Host> class M10Bridge {
std::unique_ptr<server::RegionSessions> sessions_; // Destroyed first: uses the ledgers.
std::optional<server::SessionWindow> window_;
bool window_closed_{};
std::uint64_t replicated_{};
std::optional<network::SessionInterest> default_interest_;
bool warned_{};
};
#else
inline constexpr bool m10_available = false;
@@ -205,7 +263,9 @@ template <typename Host> class M10Bridge {
[[nodiscard]] bool enabled() const noexcept {
return false;
}
[[nodiscard]] bool accepting(std::uint64_t) const noexcept { return false; }
[[nodiscard]] bool accepting(std::uint64_t) const noexcept {
return false;
}
void after_step() {}
void shutdown() {}
};
+51 -2
View File
@@ -6,12 +6,15 @@
// evo-session-probe run --connect HOST:PORT --server-name NAME --ca FILE --issuer-key FILE
// --world N --frame N --region N --account HEX32 --serial N [--lifetime S]
// [--intents N] [--actions N --action-base ID] [--query ID]... [--timeout-ms N]
// [--interest X,Y,Z,R] [--snapshots N]
// Signs a dev grant for the account and serial, logs in over QUIC, sends N intentions
// (one per tick, two ticks ahead) and N probe actions (three ticks ahead), queries the
// given action ids, and prints one line per answer:
// welcome SESSION EPOCH TICK | intention SEQ STATUS | simulated SEQ TICK
// receipt ID STATUS TICK | outcome ID RESULT TICK COMMIT | done
// resolved HOST ADDRESS (a host name was looked up; IPv4)
// snapshot TICK CELLS ORGANISMS MINX MINY MAXX MAXY Z (each newly applied snapshot;
// --snapshots N waits for N; --interest asks for another focus than the default)
// closed REASON TRANSPORT (TRANSPORT names why QUIC ended: untrusted means the server
// answered but failed the pinned CA/name check; idle means nothing answered)
// Statuses, results and reasons are the session-v1 wire values. Exits 0 once every
@@ -160,7 +163,24 @@ struct RunOptions {
action_base{1}, timeout_ms{20000};
std::optional<AccountId> account;
std::vector<std::uint64_t> queries;
std::optional<SessionInterest> interest;
std::uint64_t snapshots{};
};
std::optional<SessionInterest> interest_of(std::string_view v) {
std::array<std::int64_t, 4> parts{};
for (std::size_t i = 0; i < parts.size(); ++i) {
const auto comma = v.find(',');
const auto part = v.substr(0, comma);
const auto [end, ec] = std::from_chars(part.data(), part.data() + part.size(), parts.at(i));
if (ec != std::errc{} || end != part.data() + part.size() ||
(comma == std::string_view::npos) != (i + 1 == parts.size()))
return std::nullopt;
v.remove_prefix(comma == std::string_view::npos ? v.size() : comma + 1);
}
if (parts[3] < 0 || parts[3] > 65535)
return std::nullopt;
return SessionInterest{parts[0], parts[1], parts[2], static_cast<std::uint16_t>(parts[3])};
}
int run(const RunOptions& o) {
const auto scalar = read(o.issuer_key);
@@ -219,6 +239,7 @@ int run(const RunOptions& o) {
const auto deadline = Clock::now() + std::chrono::milliseconds{o.timeout_ms};
bool welcomed = false, queried = false;
std::uint64_t sent_intents = 0, sent_actions = 0, last_tick = 0, simulated = 0;
std::uint64_t seen_snapshot = 0, snapshots = 0;
std::set<std::uint64_t> pending_actions, pending_queries(o.queries.begin(), o.queries.end());
for (std::uint64_t i = 0; i < o.actions; ++i)
pending_actions.insert(o.action_base + i);
@@ -253,6 +274,8 @@ int run(const RunOptions& o) {
}
if (!queried) {
queried = true;
if (o.interest && !c.set_interest(*o.interest))
std::puts("error interest");
for (const auto query : o.queries)
(void)c.query_action(query);
}
@@ -264,6 +287,23 @@ int run(const RunOptions& o) {
std::printf("simulated %llu %llu\n", static_cast<unsigned long long>(s->sequence),
static_cast<unsigned long long>(s->tick));
}
if (const auto* v = c.view(); v && v->tick != seen_snapshot) {
seen_snapshot = v->tick;
++snapshots;
std::int64_t min_x = 0, min_y = 0, max_x = 0, max_y = 0;
for (std::size_t i = 0; i < v->environment.size(); ++i) {
const auto& voxel = v->environment[i].voxel;
min_x = i == 0 ? voxel.x : std::min(min_x, voxel.x);
min_y = i == 0 ? voxel.y : std::min(min_y, voxel.y);
max_x = i == 0 ? voxel.x : std::max(max_x, voxel.x);
max_y = i == 0 ? voxel.y : std::max(max_y, voxel.y);
}
std::printf("snapshot %llu %zu %zu %lld %lld %lld %lld %lld\n",
static_cast<unsigned long long>(v->tick), v->environment.size(),
v->organisms.size(), static_cast<long long>(min_x),
static_cast<long long>(min_y), static_cast<long long>(max_x),
static_cast<long long>(max_y), static_cast<long long>(v->slice_z));
}
for (const auto& r : c.take_action_receipts())
std::printf("receipt %llu %u %llu\n", static_cast<unsigned long long>(r.action_id),
static_cast<unsigned>(r.status), static_cast<unsigned long long>(r.tick));
@@ -279,7 +319,11 @@ int run(const RunOptions& o) {
}
std::fflush(stdout);
if (sent_actions == o.actions && pending_actions.empty() && pending_queries.empty() &&
sent_intents == o.intents && simulated >= std::min<std::uint64_t>(o.intents, 1)) {
sent_intents == o.intents && simulated >= std::min<std::uint64_t>(o.intents, 1) &&
snapshots >= o.snapshots) {
std::printf("snapshot-bytes %llu chunks %llu\n",
static_cast<unsigned long long>(c.snapshot_bytes()),
static_cast<unsigned long long>(c.snapshot_chunks()));
std::puts("done");
c.close();
return 0;
@@ -338,6 +382,10 @@ int main(int argc, char** argv) {
o.action_base = *n;
else if (n && flag == "--timeout-ms" && *n > 0)
o.timeout_ms = *n;
else if (n && flag == "--snapshots" && *n <= 100000)
o.snapshots = *n;
else if (flag == "--interest")
ok = (o.interest = interest_of(value)).has_value();
else
ok = false;
}
@@ -346,7 +394,8 @@ int main(int argc, char** argv) {
std::fputs("usage: evo-session-probe keys --out DIR | run --connect HOST:PORT "
"--server-name NAME --ca FILE --issuer-key FILE --world N --frame N "
"--region N --account HEX32 --serial N [--lifetime S] [--intents N] "
"[--actions N --action-base ID] [--query ID]... [--timeout-ms N]\n",
"[--actions N --action-base ID] [--query ID]... [--timeout-ms N] "
"[--interest X,Y,Z,R] [--snapshots N]\n",
stderr);
return 2;
}
+2 -1
View File
@@ -526,7 +526,8 @@ session control done; 10.3b QUIC session login (schemas/network/session-v1.md) d
(schema v11, same transaction as the checkpoint) done; 10.4c evo-server QUIC listener and
headless client with process kill tests done. The engineering GUI client still uses the
M9 dev path. 10.5 split (ADR-0093): 10.5a session protocol v2 and the replication core
done; 10.5b wiring and process evidence and 10.5c the GUI client switch follow.
done; 10.5b wiring (sessions, evo-server, client, probe) with process evidence done; 10.5c
the GUI client switch follows.
10.6-10.9 planned.
**Entry:** M9 client/session evidence and M7/M8 dev/stage durability. Read
+4 -2
View File
@@ -45,8 +45,10 @@ route is not yet verified end to end: the edge firewall rule (UDP 7400 from
M10.5a (ADR-0093) adds session protocol v2 (interest, snapshot chunks, snapshot acks; v1 is
refused) and the replication core: server-capped interest with a perception boundary,
entity deltas against the acknowledged baseline, nearest first within 16 KiB per tick with
a slower distant tier, datagram chunks and client assembly. Next: 10.5b wiring, then the
GUI client switch (10.5c).
a slower distant tier, datagram chunks and client assembly. M10.5b wires it end to end:
evo-server replicates the region's environment for each session's interest (default: the
first habitat site), the client assembles and acknowledges snapshots, and the probe prints
them. Next: the GUI client switch (10.5c).
## Previous gate - 2026-10-02
@@ -58,3 +58,26 @@ are ignored; malformed records, a slice mismatch or disagreeing chunk headers ar
are not needed at this size and are left for measurement (10.9).
- Wiring into RegionSessions, evo-server and the clients is 10.5b; until then v2 messages
exist but no server sends snapshots.
## M10.5b wiring (2026-10-06)
- **RegionSessions** owns the `ReplicationServer`: replication opens with Welcome and
closes with the session; `Interest` arrives on the stream, `SnapshotAck` as a datagram.
The host calls `replicate(tick, source)` once per simulated tick; each session's chunks
are sized to its connection's current datagram limit (no snapshot while the datagram
extension is not negotiated). A refused chunk leaves the snapshot unacknowledged.
- **Default interest:** until a client sends its own, a session has the interest the host
set: evo-server uses the region's first habitat site with radius 7, so a new session
sees the region at once. Clients learn the slice and square from the snapshot itself.
- **evo-server source:** for each distinct interest, the habitat sites of the square in
the slice are queried from the region's own stores (`query_environment`, all fields) and
copied through `present_environment`, the same read-only path as the M9 view; organisms
stay empty (no placed individuals). A failed query sends an empty source and logs once.
- **Client:** `RegionSessionClient` assembles and acknowledges snapshots, exposes the view
and validated presentations, sends `Interest`, and closes the session (protocol) on a
malformed or unpresentable snapshot. Chunks arriving before Welcome are dropped (the
channels are not ordered); the next tick resends.
- **Probe:** `--interest X,Y,Z,R` and `--snapshots N`; one `snapshot` line per applied
snapshot (tick, cells, organisms, bounding square, slice) and `snapshot-bytes`.
- Evidence: the test region's default interest holds one habitat site, so the process test
shows a one-cell view refreshed every tick (40 chunks, 8,888 bytes in 40 ticks); the
225-cell and 32-session figures come from synthetic sources.
+26
View File
@@ -4380,3 +4380,29 @@ tests; format check (only unrelated uncommitted files of the maintainer fail it)
MSVC 19.44 preset `quic` build and CTest 4/4 (binaries rebuilt, timestamps checked).
Not done: wiring into RegionSessions, evo-server and the clients (10.5b); the GUI client
(10.5c).
## 2026-10-06 — M10.5b snapshot wiring (ADR-0093)
Implemented replication in `RegionSessions` (open/close with the session, `Interest`,
`SnapshotAck`, default interest, `replicate` with per-connection datagram limits),
snapshot assembly and acknowledgement in `RegionSessionClient`, the evo-server source (the
region's habitat sites in the interest square, `query_environment` and
`present_environment`), and probe options `--interest` and `--snapshots`.
Loopback QUIC (`evo-quic-session-tests`): a 21 x 21 synthetic slice; the default interest
(clamped to radius 7) arriving as 225 cells, none outside the square; a change reaching the
client; acknowledgements keeping deltas (fresh baselines fewer than snapshots); a new
interest replacing the view with the 25-cell square; the session staying open.
Real processes (`tools/ci/postgres-check.sh`, evo-server with QUIC): snapshots of the test
region's default interest (one habitat site), every cell in one slice and one 15 x 15
square, a snapshot every tick (40 chunks, 8,888 bytes in 40 ticks); the probe printing
snapshots and `snapshot-bytes` with three snapshots.
Found and fixed during development: test cells requesting water without moisture (the
client correctly refused the snapshot and closed); a local name hiding the fixture's
`env()`; clang-tidy optional and return-value findings.
Executed: Linux GCC 14 `postgres-check.sh` with EVO_BUILD_QUIC (20 suites); GCC preset
`quic` CTest 4/4; session tests 10/10 repeated; Clang 19 ASan/UBSan session and network
tests; clang-tidy 19 on sessions, client, replication, bridge, probe and tests; Windows MSVC
19.44 preset `quic` build (including the probe) and CTest 4/4 (binaries rebuilt, timestamps
checked). The repository format check fails only on `include/evo/server/session_window.hpp`
(already on main, not part of this change).
Not done: the GUI client (10.5c); deployment of v2 (the dev server still runs v1).
+15 -1
View File
@@ -1,5 +1,6 @@
#pragma once
#include "evo/network/quic_transport.hpp"
#include "evo/network/replication.hpp"
#include "evo/network/session_protocol.hpp"
#include <chrono>
#include <cstdint>
@@ -15,7 +16,9 @@
// the Welcome deadline or a lost transport ends the session; reconnecting needs a new
// 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.
// The client never treats a receipt or the watermark as a final outcome.
// M10.5 (ADR-0093): snapshot chunks are assembled and acknowledged here; the newest complete
// snapshot is available as a view and as validated presentations.
namespace evo::client {
struct RegionSessionClientConfig {
network::quic::ClientConfig transport;
@@ -57,6 +60,17 @@ class RegionSessionClient {
[[nodiscard]] std::optional<network::SimulatedThrough> simulated() const noexcept;
// Latest server tick seen (Welcome, receipts, watermarks); 0 before Welcome.
[[nodiscard]] std::uint64_t server_tick() const noexcept;
// Asks for another spatial focus (the server clamps it and restarts from a fresh
// baseline). False unless established and sent.
[[nodiscard]] bool set_interest(const network::SessionInterest& interest);
// The newest complete snapshot, or null before the first.
[[nodiscard]] const network::ReplicatedView* view() const noexcept;
[[nodiscard]] std::expected<client::EnvironmentPresentation, client::ViewError>
environment() const;
[[nodiscard]] std::expected<client::OrganismPresentation, client::ViewError> organisms() const;
// Snapshot datagrams and bytes received (whole messages), for reporting.
[[nodiscard]] std::uint64_t snapshot_chunks() const noexcept;
[[nodiscard]] std::uint64_t snapshot_bytes() const noexcept;
[[nodiscard]] RegionSessionState state() const noexcept;
[[nodiscard]] const std::optional<network::SessionWelcome>& welcome() const noexcept;
[[nodiscard]] std::optional<network::SessionCloseReason> close_reason() const noexcept;
+4
View File
@@ -75,6 +75,10 @@ class ReplicationServer {
[[nodiscard]] std::vector<std::pair<std::uint64_t, std::vector<SnapshotChunk>>>
tick(std::uint64_t tick, const std::function<ReplicationSource(const SessionInterest&)>& source,
const Perceives& perceives, std::size_t payload = session_datagram_bytes);
// The same with each session's own largest datagram (its path's current limit).
[[nodiscard]] std::vector<std::pair<std::uint64_t, std::vector<SnapshotChunk>>>
tick(std::uint64_t tick, const std::function<ReplicationSource(const SessionInterest&)>& source,
const Perceives& perceives, const std::function<std::size_t(std::uint64_t)>& payload);
[[nodiscard]] ReplicationStats stats() const;
private:
+15
View File
@@ -1,6 +1,7 @@
#pragma once
#include "evo/network/intent_admission.hpp"
#include "evo/network/quic_transport.hpp"
#include "evo/network/replication.hpp"
#include "evo/network/session_control.hpp"
#include "evo/network/session_grant.hpp"
#include "evo/network/session_protocol.hpp"
@@ -25,6 +26,9 @@
// 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.
// M10.5 (ADR-0093): every established session has a spatial interest (the default set by
// the host until the client sends its own); the host calls replicate() once per simulated
// tick and each session receives its snapshot chunks as datagrams sized to its path.
// 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`.
@@ -48,6 +52,7 @@ struct RegionSessionsConfig {
network::IntentLimits intents{}; // max_sessions follows control.max_sessions.
// Durable action records (10.4b), owned by the host; null keeps outcomes in memory only.
network::ActionLedger* actions{};
network::ReplicationLimits replication{}; // max_sessions follows control.max_sessions.
};
// The region host's authority, read once per poll.
struct HostFacts {
@@ -83,6 +88,16 @@ class RegionSessions {
// The host dropped these carried actions: final ones are reported not_committed; the
// others await their durable record (their batch outcome was unknown).
void dropped(std::span<const network::CarriedAction> actions, bool final);
// Interest given to each new session until it sends its own (none: no snapshots until it
// does). Sessions already open without an interest receive it too.
void set_default_interest(network::SessionInterest interest);
// Sends every interested session its snapshot for `tick` (call once per simulated tick).
// `source` reads the host's state for one interest; `perceives` hides organisms.
void replicate(
std::uint64_t tick,
const std::function<network::ReplicationSource(const network::SessionInterest&)>& source,
const network::Perceives& perceives = {});
[[nodiscard]] network::ReplicationStats replication_stats() const;
// Closes every connection with `shutdown` (flushed by later polls).
void shutdown(std::chrono::steady_clock::time_point now);
[[nodiscard]] std::vector<RegionSessionEvent> take_events();
+2 -1
View File
@@ -77,7 +77,8 @@ Close reasons (wire 1..13): 1 client_closed, 2 superseded, 3 expired, 4 stale_ep
after a duplicate of a final action, and in answer to `ActionQuery`.
- Interest (ADR-0093): the server clamps the radius to 7 and sends only entities in that
square of the slice that the session may perceive. A new interest restarts from a fresh
baseline.
baseline. Until a client sends one, the server may apply a default interest (evo-server:
the region's first habitat site, radius 7); snapshots then start right after Welcome.
- SnapshotChunk: epoch and tick nonzero; baseline 0 (fresh) or an earlier tick; 1 <= count
<= 16; index < count. Records are whole entities, concatenated:
+52
View File
@@ -23,6 +23,8 @@ struct RegionSessionClient::Impl {
std::vector<network::IntentionReceipt> intention_receipts;
std::vector<network::ActionReceipt> action_receipts;
std::vector<network::ActionOutcome> action_outcomes;
std::optional<network::SnapshotAssembler> snapshots;
std::uint64_t snapshot_chunks{}, snapshot_bytes{};
static constexpr std::size_t max_kept = 1024; // Per kind, until taken; oldest dropped.
template <typename T> static void keep(std::vector<T>& list, const T& item) {
@@ -44,6 +46,21 @@ struct RegionSessionClient::Impl {
seen_tick(m->server_tick);
return keep(intention_receipts, *m);
}
if (const auto* m = std::get_if<network::SnapshotChunk>(&*decoded)) {
++snapshot_chunks;
snapshot_bytes += bytes.size();
seen_tick(m->tick);
if (!snapshots)
return; // Before Welcome (channels are not ordered): the next tick resends.
const auto accepted = snapshots->accept(*m);
if (!accepted)
return end(SessionCloseReason::protocol, true); // Malformed snapshot.
if (const auto ack = accepted.value_or(std::nullopt); ack && connection != 0)
// A lost ack only means the next delta is against an older baseline.
(void)endpoint->send_datagram(connection, network::encode_session(*ack))
.has_value();
return;
}
if (const auto* m = std::get_if<network::SimulatedThrough>(&*decoded)) {
if (!welcome || m->epoch != welcome->epoch)
return; // Another epoch's watermark says nothing about this session.
@@ -80,6 +97,7 @@ struct RegionSessionClient::Impl {
if (state == RegionSessionState::awaiting_welcome) {
if (const auto* m = std::get_if<network::SessionWelcome>(&*decoded)) {
welcome = *m;
snapshots.emplace(world::WorldIdentity{m->world, m->frame}, m->epoch);
seen_tick(m->server_tick);
state = RegionSessionState::established;
return;
@@ -206,6 +224,40 @@ std::uint64_t RegionSessionClient::server_tick() const noexcept {
return impl_->server_tick;
}
bool RegionSessionClient::set_interest(const network::SessionInterest& interest) {
auto& m = *impl_;
return m.state == RegionSessionState::established && m.send(interest);
}
const network::ReplicatedView* RegionSessionClient::view() const noexcept {
const auto& snapshots = impl_->snapshots;
return snapshots ? snapshots->latest() : nullptr;
}
std::expected<client::EnvironmentPresentation, client::ViewError>
RegionSessionClient::environment() const {
const auto& snapshots = impl_->snapshots;
if (!snapshots)
return std::unexpected(client::ViewError::empty_slice);
return snapshots->environment();
}
std::expected<client::OrganismPresentation, client::ViewError>
RegionSessionClient::organisms() const {
const auto& snapshots = impl_->snapshots;
if (!snapshots)
return std::unexpected(client::ViewError::empty_slice);
return snapshots->organisms();
}
std::uint64_t RegionSessionClient::snapshot_chunks() const noexcept {
return impl_->snapshot_chunks;
}
std::uint64_t RegionSessionClient::snapshot_bytes() const noexcept {
return impl_->snapshot_bytes;
}
RegionSessionState RegionSessionClient::state() const noexcept {
return impl_->state;
}
+11 -3
View File
@@ -190,16 +190,24 @@ std::vector<std::pair<std::uint64_t, std::vector<SnapshotChunk>>>
ReplicationServer::tick(std::uint64_t tick,
const std::function<ReplicationSource(const SessionInterest&)>& source,
const Perceives& perceives, std::size_t payload) {
return this->tick(tick, source, perceives, [payload](std::uint64_t) { return payload; });
}
std::vector<std::pair<std::uint64_t, std::vector<SnapshotChunk>>> ReplicationServer::tick(
std::uint64_t tick, const std::function<ReplicationSource(const SessionInterest&)>& source,
const Perceives& perceives, const std::function<std::size_t(std::uint64_t)>& payload_of) {
std::vector<std::pair<std::uint64_t, std::vector<SnapshotChunk>>> out;
payload = std::min(payload, session_datagram_bytes);
const auto overhead = session_header_bytes + snapshot_chunk_header_bytes;
if (tick == 0 || payload <= overhead)
if (tick == 0)
return out;
const auto capacity = payload - overhead; // Record bytes per chunk.
std::vector<std::pair<SessionInterest, ReplicationSource>> sources;
for (auto& s : sessions_) {
if (!s.interest || (!s.baselines.empty() && s.baselines.back().tick >= tick))
continue;
const auto payload = std::min(payload_of(s.id), session_datagram_bytes);
if (payload <= overhead)
continue; // No datagram channel yet (or a path too small): nothing to send.
const auto capacity = payload - overhead; // Record bytes per chunk.
const auto& in = *s.interest;
auto cached = std::ranges::find_if(sources, [&](const auto& e) { return e.first == in; });
if (cached == sources.end()) {
+59 -7
View File
@@ -62,15 +62,18 @@ struct RegionSessions::Impl {
};
Impl(RegionSessionsConfig c, std::unique_ptr<network::quic::Endpoint> e,
network::GrantVerifier v, network::SessionControl s, network::IntentAdmission i)
network::GrantVerifier v, network::SessionControl s, network::IntentAdmission i,
network::ReplicationServer r)
: config{std::move(c)}, endpoint{std::move(e)}, verifier{std::move(v)},
control{std::move(s)}, intents{std::move(i)} {}
control{std::move(s)}, intents{std::move(i)}, replication{std::move(r)} {}
RegionSessionsConfig config;
std::unique_ptr<network::quic::Endpoint> endpoint;
network::GrantVerifier verifier;
network::SessionControl control;
network::IntentAdmission intents;
network::ReplicationServer replication;
std::optional<network::SessionInterest> default_interest;
HostFacts facts;
std::vector<Connection> connections;
std::vector<RegionSessionEvent> events;
@@ -110,8 +113,10 @@ struct RegionSessions::Impl {
event.account = c.account;
event.reason = reason;
events.push_back(std::move(event));
if (c.state == State::established)
if (c.state == State::established) {
intents.close(c.session);
replication.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.
@@ -183,6 +188,12 @@ struct RegionSessions::Impl {
void welcome(Connection& c, Clock::time_point now) {
if (!intents.open(c.session, c.account_id))
return close(c, SessionCloseReason::capacity, now);
if (!replication.open(c.session, c.welcome.epoch)) {
intents.close(c.session);
return close(c, SessionCloseReason::capacity, now);
}
if (default_interest)
(void)replication.set_interest(c.session, *default_interest).has_value();
c.state = State::established;
c.welcome.server_tick = facts.simulated_tick;
send(c, c.welcome);
@@ -244,8 +255,12 @@ struct RegionSessions::Impl {
if (c.state == State::closing)
return;
const auto decoded = network::decode_session(bytes);
const auto* m = decoded ? std::get_if<network::SessionIntention>(&*decoded) : nullptr;
if (c.state != State::established || !m)
if (c.state != State::established || !decoded)
return close(c, SessionCloseReason::protocol, now);
if (const auto* ack = std::get_if<network::SnapshotAck>(&*decoded))
return replication.acknowledge(c.session, *ack);
const auto* m = std::get_if<network::SessionIntention>(&*decoded);
if (!m)
return close(c, SessionCloseReason::protocol, now);
send_datagram(c, intents.intention(c.session, *m, admission()));
}
@@ -290,6 +305,10 @@ struct RegionSessions::Impl {
}
if (const auto* m = std::get_if<network::ActionQuery>(&*decoded))
return send(c, intents.query(c.session, *m, admission()));
if (const auto* m = std::get_if<network::SessionInterest>(&*decoded)) {
(void)replication.set_interest(c.session, *m).has_value(); // Clamped by the server.
return;
}
if (const auto* m = std::get_if<network::SessionClose>(&*decoded);
m && m->reason == SessionCloseReason::client_closed) {
close(c, SessionCloseReason::client_closed, now);
@@ -324,13 +343,17 @@ RegionSessions::create(RegionSessionsConfig config) {
auto intents = network::IntentAdmission::create(config.intents);
if (!intents)
return std::unexpected(RegionSessionsError::configuration);
config.replication.max_sessions = config.control.max_sessions;
auto replication = network::ReplicationServer::create(config.replication);
if (!replication)
return std::unexpected(RegionSessionsError::configuration);
intents->attach(config.actions);
auto endpoint = network::quic::Endpoint::serve(config.transport);
if (!endpoint)
return std::unexpected(RegionSessionsError::transport);
return std::unique_ptr<RegionSessions>{new RegionSessions{
std::make_unique<Impl>(std::move(config), std::move(*endpoint), std::move(*verifier),
std::move(*control), std::move(*intents))}};
std::move(*control), std::move(*intents), std::move(*replication))}};
}
void RegionSessions::poll(const HostFacts& facts, std::uint64_t now_seconds,
@@ -362,8 +385,10 @@ void RegionSessions::poll(const HostFacts& facts, std::uint64_t now_seconds,
m.connections, [&](const Impl::Connection& c) { return c.id == e.connection; });
if (it == m.connections.end())
continue;
if (it->state == Impl::State::established)
if (it->state == Impl::State::established) {
m.intents.close(it->session);
m.replication.close(it->session);
}
if (it->state == Impl::State::pending) {
(void)m.control.close(it->session).has_value();
if (m.config.ledger && it->generation != 0)
@@ -417,6 +442,33 @@ void RegionSessions::dropped(std::span<const network::CarriedAction> actions, bo
impl_->deliver(impl_->intents.dropped(actions, final));
}
void RegionSessions::set_default_interest(network::SessionInterest interest) {
auto& m = *impl_;
m.default_interest = interest;
for (const auto& c : m.connections)
if (c.state == Impl::State::established && !m.replication.interest(c.session))
(void)m.replication.set_interest(c.session, interest).has_value();
}
void RegionSessions::replicate(
std::uint64_t tick,
const std::function<network::ReplicationSource(const network::SessionInterest&)>& source,
const network::Perceives& perceives) {
auto& m = *impl_;
const auto payload = [&](std::uint64_t session) -> std::size_t {
const auto* c = m.by_session(session);
return c && c->state == Impl::State::established ? m.endpoint->datagram_limit(c->id) : 0;
};
for (const auto& [session, chunks] : m.replication.tick(tick, source, perceives, payload))
if (const auto* c = m.by_session(session); c && c->state == Impl::State::established)
for (const auto& chunk : chunks)
m.send_datagram(*c, chunk); // A refused chunk leaves the snapshot unacknowledged.
}
network::ReplicationStats RegionSessions::replication_stats() const {
return impl_->replication.stats();
}
void RegionSessions::shutdown(Clock::time_point now) {
for (auto& c : impl_->connections)
impl_->close(c, SessionCloseReason::shutdown, now);
+76
View File
@@ -151,6 +151,10 @@ struct Harness {
}
void pump() {
server->poll({ready, epoch, tick}, now_seconds, Clock::now());
if (source && tick != replicated) { // One snapshot per simulated tick (ADR-0093).
replicated = tick;
server->replicate(tick, source);
}
for (auto& e : server->take_events())
events.push_back(std::move(e));
for (auto* c : clients)
@@ -191,6 +195,8 @@ struct Harness {
std::vector<RegionSessionEvent> events;
std::uint64_t epoch{5}, now_seconds{start}, tick{100};
bool ready{true};
std::function<ReplicationSource(const SessionInterest&)> source;
std::uint64_t replicated{};
};
bool refused_with(Harness& h, const WireGrant& grant, Reason reason) {
@@ -471,6 +477,75 @@ void intentions_and_actions(const Files& f) {
CHECK(welcome && reason == Reason::protocol);
}
// M10.5: snapshots over QUIC from a simulated host's 21 x 21 slice.
client::EnvironmentCell grid_cell(std::int64_t x, std::int64_t y, std::uint64_t quantity) {
client::EnvironmentCell c;
c.voxel = {x, y, -7};
c.chunk_revision = 40;
c.habitat = {{100}, {200}, {0}, {1000}, {500}, {10}};
c.volume = {1000ULL * 500 * 10};
c.substrate = {1};
c.terrain_material = {2};
c.terrain_fill = 1000;
c.presence[0] = client::FieldPresence::present;
c.quantity[0] = quantity;
c.presence[1] = client::FieldPresence::missing;
c.presence[7] = client::FieldPresence::present;
c.quantity[7] = 5;
c.moisture_status = world::MoistureStatus::available;
c.moisture = {3, 50};
return c;
}
void snapshots_over_quic(const Files& f) {
Harness h{f};
std::uint64_t quantity = 30;
h.source = [&](const SessionInterest&) {
ReplicationSource s;
s.identity = world_id;
s.field_revision = h.tick;
s.mask = (1U << 0) | (1U << 1) | (1U << 7); // Water requested: moisture is present.
for (std::int64_t x = -10; x <= 10; ++x)
for (std::int64_t y = -10; y <= 10; ++y)
s.environment.push_back(grid_cell(x, y, quantity));
return s;
};
h.server->set_default_interest({0, 0, -7, 30}); // Clamped to radius 7.
auto a = h.connect(h.issuer.grant(account(1), 1));
CHECK(h.settled(*a) && a->state() == RegionSessionState::established);
const auto ticks_until = [&](const std::function<bool()>& done) {
for (int i = 0; i < 400 && !done(); ++i) {
++h.tick;
h.until(done, std::chrono::milliseconds{20});
}
return done();
};
// The default interest's 225 cells arrive within the per-tick budget.
CHECK(ticks_until([&] { return a->view() && a->view()->environment.size() == 225; }));
const auto env = a->environment();
CHECK(env && env->cells().size() == 225 && env->revision().identity == world_id);
CHECK(std::ranges::all_of(env->cells(), [](const auto& c) {
return c.voxel.x >= -7 && c.voxel.x <= 7 && c.voxel.y >= -7 && c.voxel.y <= 7;
}));
CHECK(a->snapshot_chunks() > 0 && a->snapshot_bytes() > std::uint64_t{225} * 50);
// A change reaches the client; acknowledgements keep deltas small.
quantity = 31;
CHECK(ticks_until([&] {
return a->view() && std::ranges::all_of(a->view()->environment,
[](const auto& c) { return c.quantity[0] == 31; });
}));
const auto stats = h.server->replication_stats();
CHECK(stats.snapshots > 2 && stats.fresh_baselines < stats.snapshots);
// Another interest: only the new square.
CHECK(a->set_interest({5, 5, -7, 2}));
CHECK(ticks_until([&] { return a->view() && a->view()->environment.size() == 25; }));
CHECK(std::ranges::all_of(a->view()->environment, [](const auto& c) {
return c.voxel.x >= 3 && c.voxel.x <= 7 && c.voxel.y >= 3 && c.voxel.y <= 7;
}));
// A snapshot ack datagram is accepted (not a protocol error); the session stays open.
CHECK(a->state() == RegionSessionState::established);
}
void durable_control(const Files& f) {
FakeLedger ledger;
Harness h{f, 4, 64, &ledger};
@@ -546,6 +621,7 @@ int main() try {
limits(files);
durable_control(files);
intentions_and_actions(files);
snapshots_over_quic(files);
std::filesystem::remove_all(files.dir);
std::puts("quic session tests passed");
return 0;
+24 -2
View File
@@ -8,6 +8,7 @@
#include "evo/network/dev_credentials.hpp"
#include "evo/network/session_grant.hpp"
#include "fixtures/server_process.hpp"
#include <algorithm>
#include <chrono>
#include <fcntl.h>
#include <functional>
@@ -219,6 +220,25 @@ void end_to_end() {
auto server = std::make_unique<Server>(s);
auto a = connect(s, *server, s.grant(alice, 1));
CHECK(established(*server, *a));
// Snapshots of the real region (ADR-0093): the default interest is the first habitat
// site with radius 7; every cell lies in one slice and one 15 x 15 square.
const auto first_tick = a->server_tick();
CHECK(until(*server, *a, [&] { return a->view() && !a->view()->environment.empty(); }));
const auto shown = a->environment();
CHECK(shown && !shown->cells().empty() && shown->cells().size() <= 225);
const auto [min_x, max_x] =
std::ranges::minmax(shown->cells(), {}, [](const auto& c) { return c.voxel.x; });
const auto [min_y, max_y] =
std::ranges::minmax(shown->cells(), {}, [](const auto& c) { return c.voxel.y; });
CHECK(max_x.voxel.x - min_x.voxel.x <= 14 && max_y.voxel.y - min_y.voxel.y <= 14);
CHECK(std::ranges::all_of(shown->cells(),
[&](const auto& c) { return c.voxel.z == shown->slice_z(); }));
CHECK(until(*server, *a, [&] { return a->server_tick() >= first_tick + 40; }));
std::printf("m10 snapshot report cells=%zu ticks=%llu chunks=%llu bytes=%llu\n",
shown->cells().size(),
static_cast<unsigned long long>(a->server_tick() - first_tick),
static_cast<unsigned long long>(a->snapshot_chunks()),
static_cast<unsigned long long>(a->snapshot_bytes()));
// Intentions: receipts, then the watermark.
// Datagrams may be refused until the QUIC datagram extension is negotiated: retry.
std::optional<std::uint64_t> sequence;
@@ -298,7 +318,8 @@ void end_to_end() {
"--intents", "3",
"--actions", "2",
"--action-base", "10",
"--query", "10"}};
"--query", "10",
"--snapshots", "3"}};
int code = -1;
for (const auto end = Clock::now() + 30s; Clock::now() < end && code < 0;) {
server->pump();
@@ -307,7 +328,8 @@ void end_to_end() {
code = p.wait_exit(10s);
}
CHECK(code == 0 && p.printed("welcome ") && p.printed("intention 1 0") &&
p.printed("outcome 10 1 ") && p.printed("outcome 11 1 "));
p.printed("outcome 10 1 ") && p.printed("outcome 11 1 ") && p.printed("snapshot ") &&
p.printed("snapshot-bytes "));
CHECK(!record(bob, 10).empty() && !record(bob, 11).empty());
server->child->signal(SIGTERM);
CHECK(server->child->wait_exit(30s) == 0);