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>
115 lines
6.2 KiB
C++
115 lines
6.2 KiB
C++
#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"
|
|
#include <chrono>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <expected>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <span>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
// M10.3b region-side session login over QUIC (ADR-0091, schemas/network/session-v1.md).
|
|
// Owned by the region host's thread, which calls poll(). A connection must send Hello
|
|
// with a grant before the deadline; the grant is verified with the region's issuer
|
|
// 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.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.
|
|
// 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`.
|
|
namespace evo::server {
|
|
struct IssuerKey {
|
|
std::uint32_t key_id{};
|
|
network::GrantPublicKey public_key{};
|
|
};
|
|
struct RegionSessionsConfig {
|
|
network::quic::ServerConfig transport;
|
|
network::ControlConfig control; // `epoch` is the initial ownership epoch.
|
|
std::vector<IssuerKey> issuer_keys;
|
|
std::chrono::milliseconds hello_deadline{5000}; // Connected to Hello (ADR-0089).
|
|
std::chrono::milliseconds close_flush{1000}; // Close sent to connection closed.
|
|
// Durable per-world control (10.3c), owned by the host; null keeps control in memory
|
|
// only (tests, tools). With a ledger, a session is admitted only after its durable
|
|
// claim, waits out another region's control before Welcome, renews every
|
|
// `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.
|
|
// 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 {
|
|
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 {
|
|
enum class Kind : std::uint8_t { opened, closed, refused } kind{};
|
|
std::uint64_t session{}; // 0 for refusals.
|
|
std::string account; // log_label, empty when unauthenticated.
|
|
network::SessionCloseReason reason{};
|
|
};
|
|
|
|
class RegionSessions {
|
|
public:
|
|
[[nodiscard]] static std::expected<std::unique_ptr<RegionSessions>, RegionSessionsError>
|
|
create(RegionSessionsConfig config);
|
|
RegionSessions(const RegionSessions&) = delete;
|
|
RegionSessions& operator=(const RegionSessions&) = delete;
|
|
~RegionSessions();
|
|
// 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<network::CarriedAction> carry(std::uint64_t tick);
|
|
// These carried actions are durable in `commit_sequence` (each with the tick it rode):
|
|
// their outcomes go to each account's current session.
|
|
void committed(std::span<const network::CarriedAction> actions, std::uint64_t commit_sequence);
|
|
// 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();
|
|
[[nodiscard]] std::optional<std::uint64_t> holder(const network::AccountId& account) const;
|
|
[[nodiscard]] std::size_t sessions() const noexcept;
|
|
[[nodiscard]] std::size_t connections() const noexcept;
|
|
[[nodiscard]] std::uint16_t port() const noexcept;
|
|
|
|
private:
|
|
struct Impl;
|
|
explicit RegionSessions(std::unique_ptr<Impl> impl);
|
|
std::unique_ptr<Impl> impl_;
|
|
};
|
|
} // namespace evo::server
|