Foundation / checks (checks) (push) Successful in 32m47s
Foundation / checks (client) (push) Failing after 10m1s
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m53s
Foundation / checks (network) (push) Successful in 11m18s
Foundation / checks (postgres) (push) Successful in 40m20s
Foundation / checks (tsan) (push) Successful in 7m46s
Foundation / postgres-tools (push) Skipped
Foundation / image (push) Skipped
Foundation / server-image (push) Skipped
evo-client's remote mode now runs over RegionSessionClient (QUIC, session v2): snapshot-fed environment and organism views, the camera following the server's view until the user moves it and then driving the interest, intention records with a simulated state, and reconnects with the next grant of a bundle. The launcher reads 160-byte M10 grants and defaults to the dev route. - quic::resolve_ipv4 shared by the client and evo-session-probe - evo-session-probe grants: owner-only bundles of 1-64 grants - evo-server --m10-max-grant-lifetime (dev only, 60..3600 s) - presets client-network/client-package build QUIC; msquic links the CRT fully static; msquic.dll and msquic/OpenSSL licences in the Windows package - client-remote-session test against a loopback region - ADR-0093/0091/0086 amendments, M10_CLIENT_SESSIONS guide, validation Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
282 lines
13 KiB
C++
282 lines
13 KiB
C++
#pragma once
|
|
// M10.4c QUIC session listener for evo-server (ADR-0091, ADR-0092). Compiled only with
|
|
// EVO_SERVER_M10 (EVO_BUILD_QUIC with the PostgreSQL build); otherwise the flags are refused
|
|
// at parse time. Opt-in, development and test only: nothing deploys it yet.
|
|
//
|
|
// Each loop iteration after the host's step: the sessions see the host's authority; actions
|
|
// 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>
|
|
#include <optional>
|
|
#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"
|
|
#include "evo/server/region_host.hpp"
|
|
#include "evo/server/region_sessions.hpp"
|
|
#include "evo/server/session_window.hpp"
|
|
#include <algorithm>
|
|
#include <charconv>
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <fstream>
|
|
#include <iterator>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <vector>
|
|
#endif
|
|
|
|
namespace evo::server_app {
|
|
struct M10Options {
|
|
std::string listen, certificate, key, issuer, environment, session_window;
|
|
// M10.5c: dev only, 60..3600 s; 0 keeps the default (300 s, ADR-0091).
|
|
std::uint64_t max_grant_lifetime{};
|
|
[[nodiscard]] bool any() const noexcept {
|
|
return !listen.empty() || !certificate.empty() || !key.empty() || !issuer.empty() ||
|
|
!environment.empty() || !session_window.empty() || max_grant_lifetime != 0;
|
|
}
|
|
[[nodiscard]] bool complete() const noexcept {
|
|
return !listen.empty() && !certificate.empty() && !key.empty() && !issuer.empty() &&
|
|
!environment.empty() && !session_window.empty();
|
|
}
|
|
};
|
|
// Actions are handed to the host as soon as they are scheduled (at most 8 ticks ahead).
|
|
inline constexpr std::uint64_t m10_carry_ahead_ticks = 8;
|
|
|
|
#ifdef EVO_SERVER_M10
|
|
inline constexpr bool m10_available = true;
|
|
template <typename Host> class M10Bridge {
|
|
public:
|
|
// Empty bridge without M10 options; nullopt on a startup failure (the caller exits).
|
|
static std::optional<M10Bridge> open(const M10Options& o, Host& host,
|
|
persistence::RegionKey key, std::uint64_t frame,
|
|
const persistence::PgOptions& pg) {
|
|
M10Bridge bridge;
|
|
if (!o.any())
|
|
return bridge;
|
|
const auto window = server::SessionWindow::open(o.session_window, wall_seconds());
|
|
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");
|
|
const auto colon = o.listen.rfind(':');
|
|
std::uint16_t port = 0;
|
|
if (colon == std::string::npos ||
|
|
std::from_chars(o.listen.data() + colon + 1, o.listen.data() + o.listen.size(), port)
|
|
.ec != std::errc{})
|
|
return fail("error m10-listen");
|
|
const auto issuer = read(o.issuer);
|
|
if (issuer.size() != network::grant_public_key_bytes)
|
|
return fail("error m10-issuer");
|
|
server::RegionSessionsConfig config;
|
|
config.transport.listen_address = o.listen.substr(0, colon);
|
|
config.transport.port = port;
|
|
config.transport.certificate_pem_file = o.certificate;
|
|
config.transport.key_pem_file = o.key;
|
|
config.control.environment = o.environment == "dev" ? network::DeploymentEnvironment::dev
|
|
: o.environment == "stage"
|
|
? network::DeploymentEnvironment::stage
|
|
: network::DeploymentEnvironment::world0;
|
|
if (o.max_grant_lifetime != 0) {
|
|
// Longer grants let a tester's bundle outlive a coffee break; never outside dev.
|
|
if (config.control.environment != network::DeploymentEnvironment::dev)
|
|
return fail("error m10-grant-lifetime");
|
|
config.control.max_grant_lifetime = o.max_grant_lifetime;
|
|
}
|
|
config.control.world = {key.world, frame};
|
|
config.control.region = key.region;
|
|
config.control.epoch = 1; // Follows the host's epoch from the first poll.
|
|
server::IssuerKey issuer_key;
|
|
issuer_key.key_id = 1;
|
|
std::copy(issuer.begin(), issuer.end(), issuer_key.public_key.begin());
|
|
config.issuer_keys.push_back(issuer_key);
|
|
bridge.host_ = &host;
|
|
bridge.window_ = *window;
|
|
bridge.slot_ = std::make_unique<server::PgSlot>(pg, std::chrono::seconds{2});
|
|
const auto lease = [h = &host] { return h->authority(); };
|
|
bridge.control_ =
|
|
std::make_unique<server::PostgresControlLedger>(*bridge.slot_, key, lease);
|
|
bridge.actions_ = std::make_unique<server::PostgresActionLedger>(*bridge.slot_, key, lease);
|
|
config.ledger = bridge.control_.get();
|
|
config.actions = bridge.actions_.get();
|
|
auto sessions = server::RegionSessions::create(std::move(config));
|
|
if (!sessions)
|
|
return fail(sessions.error() == server::RegionSessionsError::keys ? "error m10-issuer"
|
|
: sessions.error() == server::RegionSessionsError::transport
|
|
? "error m10-listen"
|
|
: "error m10-config");
|
|
bridge.sessions_ = std::move(*sessions);
|
|
std::printf("m10 listening %u\n", static_cast<unsigned>(bridge.sessions_->port()));
|
|
return bridge;
|
|
}
|
|
[[nodiscard]] bool enabled() const noexcept {
|
|
return sessions_ != nullptr;
|
|
}
|
|
[[nodiscard]] bool accepting(std::uint64_t now_seconds) {
|
|
if (!sessions_ || window_closed_)
|
|
return sessions_ != nullptr && !window_closed_;
|
|
if (window_ && window_->accepting(now_seconds))
|
|
return sessions_ != nullptr;
|
|
window_closed_ = true;
|
|
sessions_->shutdown(std::chrono::steady_clock::now());
|
|
std::printf("m10 window closed activation=%s\n", window_->activation_id().c_str());
|
|
return false;
|
|
}
|
|
void after_step() {
|
|
if (!sessions_ || !accepting(wall_seconds()))
|
|
return;
|
|
auto& host = *host_;
|
|
const auto& s = host.status();
|
|
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,
|
|
static_cast<std::uint16_t>(a.kind)};
|
|
if (!host.submit_action(record)) // Never reached the host: final.
|
|
sessions_->dropped(std::span{&a, 1}, true);
|
|
}
|
|
std::map<std::uint64_t, std::vector<network::CarriedAction>> committed;
|
|
for (const auto& ack : host.take_action_acks())
|
|
committed[ack.commit_sequence].push_back(carried(ack.record));
|
|
for (const auto& [sequence, actions] : committed) {
|
|
sessions_->committed(actions, sequence);
|
|
std::printf("m10 committed actions=%zu commit=%llu\n", actions.size(),
|
|
static_cast<unsigned long long>(sequence));
|
|
}
|
|
for (const auto& d : host.take_dropped_actions()) {
|
|
const auto a = carried(d.record);
|
|
sessions_->dropped(std::span{&a, 1}, d.final);
|
|
std::printf("m10 dropped action=%llu final=%d\n",
|
|
static_cast<unsigned long long>(d.record.action_id), d.final ? 1 : 0);
|
|
}
|
|
for (const auto& e : sessions_->take_events())
|
|
std::printf("m10 %s session=%llu account=%s reason=%u\n",
|
|
e.kind == server::RegionSessionEvent::Kind::opened ? "opened"
|
|
: e.kind == server::RegionSessionEvent::Kind::closed ? "closed"
|
|
: "refused",
|
|
static_cast<unsigned long long>(e.session), e.account.c_str(),
|
|
static_cast<unsigned>(e.reason));
|
|
}
|
|
void shutdown() {
|
|
if (sessions_)
|
|
sessions_->shutdown(std::chrono::steady_clock::now());
|
|
}
|
|
|
|
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;
|
|
a.action_id = r.action_id;
|
|
a.tick = r.tick;
|
|
a.kind = network::ActionKind::probe;
|
|
return a;
|
|
}
|
|
static std::uint64_t wall_seconds() {
|
|
return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
|
|
std::chrono::system_clock::now().time_since_epoch())
|
|
.count());
|
|
}
|
|
static std::optional<M10Bridge> fail(const char* message) {
|
|
std::puts(message);
|
|
return std::nullopt;
|
|
}
|
|
static std::string read(const std::string& path) {
|
|
std::ifstream file{path, std::ios::binary};
|
|
return {std::istreambuf_iterator<char>{file}, std::istreambuf_iterator<char>{}};
|
|
}
|
|
Host* host_{};
|
|
// Heap-held so the sessions' pointers stay valid when the bridge moves.
|
|
std::unique_ptr<server::PgSlot> slot_;
|
|
std::unique_ptr<server::PostgresControlLedger> control_;
|
|
std::unique_ptr<server::PostgresActionLedger> actions_;
|
|
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;
|
|
template <typename Host> class M10Bridge {
|
|
public:
|
|
static std::optional<M10Bridge> open(const M10Options&, Host&, persistence::RegionKey,
|
|
std::uint64_t, const persistence::PgOptions&) {
|
|
return M10Bridge{};
|
|
}
|
|
[[nodiscard]] bool enabled() const noexcept {
|
|
return false;
|
|
}
|
|
[[nodiscard]] bool accepting(std::uint64_t) const noexcept {
|
|
return false;
|
|
}
|
|
void after_step() {}
|
|
void shutdown() {}
|
|
};
|
|
#endif
|
|
} // namespace evo::server_app
|