#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. #include "evo/persistence/postgres.hpp" #include "evo/persistence/region_lease.hpp" #include #include #include #ifdef EVO_SERVER_M10 #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 #include #include #include #include #include #include #include #include #endif namespace evo::server_app { struct M10Options { std::string listen, certificate, key, issuer, environment, session_window; [[nodiscard]] bool any() const noexcept { return !listen.empty() || !certificate.empty() || !key.empty() || !issuer.empty() || !environment.empty() || !session_window.empty(); } [[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 class M10Bridge { public: // Empty bridge without M10 options; nullopt on a startup failure (the caller exits). static std::optional 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; 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(pg, std::chrono::seconds{2}); const auto lease = [h = &host] { return h->authority(); }; bridge.control_ = std::make_unique(*bridge.slot_, key, lease); bridge.actions_ = std::make_unique(*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(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) 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(a.kind)}; if (!host.submit_action(record)) // Never reached the host: final. sessions_->dropped(std::span{&a, 1}, true); } std::map> 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(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(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(e.session), e.account.c_str(), static_cast(e.reason)); } void shutdown() { if (sessions_) sessions_->shutdown(std::chrono::steady_clock::now()); } private: 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::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()) .count()); } static std::optional 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{file}, std::istreambuf_iterator{}}; } Host* host_{}; // Heap-held so the sessions' pointers stay valid when the bridge moves. std::unique_ptr slot_; std::unique_ptr control_; std::unique_ptr actions_; std::unique_ptr sessions_; // Destroyed first: uses the ledgers. std::optional window_; bool window_closed_{}; }; #else inline constexpr bool m10_available = false; template class M10Bridge { public: static std::optional 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