Enable authenticated primitive life sessions
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m59s
Foundation / checks (postgres) (push) Canceled after 0s
Foundation / checks (tsan) (push) Canceled after 0s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (checks) (push) Canceled after 6m2s
Foundation / checks (network) (push) Canceled after 3m53s
Foundation / checks (client) (push) Canceled after 6m8s

This commit is contained in:
dingo
2026-10-10 20:46:30 -04:00
parent 7da7ef2a6c
commit 0bb8b50c9c
10 changed files with 329 additions and 19 deletions
+172 -5
View File
@@ -48,9 +48,11 @@
// --crash-at <point>:<n> (tests only, M7.7) SIGKILLs this process at the n-th
// occurrence of before-upload, before-transaction, after-commit or after-ack (right
// after a step's acknowledgements are written and flushed).
// --profile primitive (M11.2d-5) starts the creation-only profile-3 host. It requires
// an owner-provisioned checkpoint, becomes ready only after recovery, and does not
// accept M9/M10 sessions, synthetic tick input or genesis provisioning.
// --profile primitive (M11.2d) starts the creation-only profile-3 host. It requires
// an owner-provisioned checkpoint and becomes ready only after recovery. Optional
// --primitive-* flags enable the v5 new-life listener; biology ticks and genesis
// provisioning remain disabled.
#include "evo/biology/founder.hpp"
#include "evo/processes/development_opening.hpp"
#include "evo/server/lifecycle/primitive_lives.hpp"
#include "evo/server/ops_http.hpp"
@@ -58,15 +60,22 @@
#include "evo/server/region_host.hpp"
#include "m10_bridge.hpp"
#include "session_bridge.hpp"
#ifdef EVO_SERVER_M10
#include "evo/server/pg_slot.hpp"
#include "evo/server/postgres_control_ledger.hpp"
#include "evo/server/region_sessions.hpp"
#endif
#include <algorithm>
#include <array>
#include <cerrno>
#include <charconv>
#include <chrono>
#include <csignal>
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <optional>
#include <poll.h>
#include <signal.h>
@@ -99,6 +108,17 @@ struct Options {
std::uint64_t objects_reserve_mib{1024};
server_app::SessionOptions session;
server_app::M10Options m10;
struct PrimitiveSessionOptions {
std::string listen, certificate, key, issuer, environment;
[[nodiscard]] bool any() const noexcept {
return !listen.empty() || !certificate.empty() || !key.empty() || !issuer.empty() ||
!environment.empty();
}
[[nodiscard]] bool complete() const noexcept {
return !listen.empty() && !certificate.empty() && !key.empty() && !issuer.empty() &&
!environment.empty();
}
} primitive_session;
};
// Kills this process without any cleanup: the real SIGKILL, at a chosen boundary.
@@ -246,6 +266,17 @@ std::optional<Options> parse(int argc, char** argv) {
o.m10.neighbours.emplace_back(value);
else if (flag == "--m10-load-governor" && (value == "on" || value == "off"))
o.m10.load_governor = value == "on";
else if (flag == "--primitive-listen")
o.primitive_session.listen = value;
else if (flag == "--primitive-cert")
o.primitive_session.certificate = value;
else if (flag == "--primitive-key")
o.primitive_session.key = value;
else if (flag == "--primitive-issuer")
o.primitive_session.issuer = value;
else if (flag == "--primitive-environment" &&
(value == "dev" || value == "stage" || value == "world0"))
o.primitive_session.environment = value;
else if (flag == "--crash-at") {
const auto colon = value.find(':');
const auto ordinal =
@@ -276,8 +307,11 @@ std::optional<Options> parse(int argc, char** argv) {
// M10 sessions (ADR-0091/0092) need every setting and the QUIC build.
if (o.m10.any() && (!server_app::m10_available || !o.m10.complete()))
return std::nullopt;
// Primitive profile serves only the creation-only host in this slice. It
// cannot accept M9/M10 sessions or synthetic biological ticks.
// Primitive profile serves only the creation-only host. Its optional listener
// uses a separate v5 contract and never enables the M9/M10 action path.
if (o.primitive_session.any() &&
(!server_app::m10_available || !o.primitive_session.complete() || o.profile != "primitive"))
return std::nullopt;
if (o.profile == "primitive" &&
(o.synthetic || !o.crash_point.empty() || o.session.any() || o.m10.any() ||
o.host.flush_interval != 1000ms || o.drain != 10000ms))
@@ -605,6 +639,118 @@ template <typename State> int serve(Options& o) {
}
}
#ifdef EVO_SERVER_M10
namespace {
using PrimitiveWireOutcome = network::PrimitiveLifeOutcome;
PrimitiveWireOutcome primitive_wire_outcome(std::uint64_t request,
const server::PrimitiveHostReply& reply) {
using network::PrimitiveLifeResult;
PrimitiveLifeResult result = PrimitiveLifeResult::unknown;
std::uint64_t identity = 0, sequence = 0;
if (reply.kind == server::PrimitiveHostReplyKind::born && reply.published) {
result = PrimitiveLifeResult::born;
identity = reply.published->identity;
sequence = reply.published->commit_sequence;
} else if (reply.kind == server::PrimitiveHostReplyKind::pending) {
result = PrimitiveLifeResult::pending;
} else if (reply.kind == server::PrimitiveHostReplyKind::refused) {
switch (reply.reservation.refusal) {
case persistence::LifeRefusal::insufficient_funding:
result = PrimitiveLifeResult::insufficient_funding;
break;
case persistence::LifeRefusal::no_placement:
result = PrimitiveLifeResult::no_placement;
break;
case persistence::LifeRefusal::cancelled:
result = PrimitiveLifeResult::cancelled;
break;
case persistence::LifeRefusal::existing_life:
result = PrimitiveLifeResult::existing_life;
break;
case persistence::LifeRefusal::none:
result = PrimitiveLifeResult::unknown;
break;
}
}
// A reservation owned by another region is never asserted as a birth here. The current
// session can query again after it reaches the owner; region routing stays explicit.
return {request, result, identity, sequence};
}
struct PrimitiveSessionBridge {
std::unique_ptr<server::PgSlot> slot;
std::unique_ptr<server::PostgresControlLedger> ledger;
std::unique_ptr<server::RegionSessions> sessions;
};
std::optional<PrimitiveSessionBridge>
open_primitive_sessions(const Options::PrimitiveSessionOptions& options,
server::PrimitiveRegionHost& host, persistence::RegionKey key,
std::uint64_t frame, const persistence::PgOptions& pg) {
PrimitiveSessionBridge bridge;
if (!options.any())
return bridge;
const auto colon = options.listen.rfind(':');
std::uint16_t port{};
if (colon == std::string::npos ||
std::from_chars(options.listen.data() + colon + 1,
options.listen.data() + options.listen.size(), port)
.ec != std::errc{}) {
std::puts("error primitive-listen");
return std::nullopt;
}
std::ifstream issuer_file(options.issuer, std::ios::binary);
std::vector<char> issuer((std::istreambuf_iterator<char>(issuer_file)), {});
if (issuer.size() != network::grant_public_key_bytes) {
std::puts("error primitive-issuer");
return std::nullopt;
}
network::RegionSessionsConfig config;
config.transport.listen_address = options.listen.substr(0, colon);
config.transport.port = port;
config.transport.certificate_pem_file = options.certificate;
config.transport.key_pem_file = options.key;
config.control.environment = options.environment == "dev" ? network::DeploymentEnvironment::dev
: options.environment == "stage"
? network::DeploymentEnvironment::stage
: network::DeploymentEnvironment::world0;
config.control.world = {key.world, frame};
config.control.region = key.region;
config.control.epoch = 1;
config.control.max_sessions = 512;
config.transport.limits.max_connections = 576;
network::GrantPublicKey issuer_key{};
std::copy(issuer.begin(), issuer.end(), issuer_key.begin());
config.issuer_keys.push_back({1, issuer_key});
bridge.slot = std::make_unique<server::PgSlot>(pg, std::chrono::seconds{2});
bridge.ledger = std::make_unique<server::PostgresControlLedger>(
*bridge.slot, key, [&host] { return host.authority(); });
config.ledger = bridge.ledger.get();
config.create_primitive_life = [&host](const network::AccountId& account,
std::uint64_t generation, std::uint64_t request) {
const auto result =
host.new_life(account.bytes, generation, request, biology::founder_life_rules);
return primitive_wire_outcome(request, result);
};
config.query_primitive_life = [&host](const network::AccountId& account,
std::uint64_t generation, std::uint64_t request) {
return primitive_wire_outcome(request, host.query_life(account.bytes, generation, request));
};
auto sessions = server::RegionSessions::create(std::move(config));
if (!sessions) {
std::puts(sessions.error() == server::RegionSessionsError::transport
? "error primitive-listen"
: "error primitive-session");
return std::nullopt;
}
bridge.sessions = std::move(*sessions);
std::printf("primitive listening %u\n", static_cast<unsigned>(bridge.sessions->port()));
return bridge;
}
} // namespace
#endif
int serve_primitive(Options& o) {
auto objects = persistence::FilesystemObjectStore::open(
o.objects, o.host.key, server::max_primitive_lives_bytes, nullptr,
@@ -624,6 +770,12 @@ int serve_primitive(Options& o) {
return 2;
}
auto& host = **made;
#ifdef EVO_SERVER_M10
auto primitive_sessions =
open_primitive_sessions(o.primitive_session, host, o.host.key, o.host.frame, o.pg);
if (!primitive_sessions)
return 2;
#endif
std::unique_ptr<server::OpsServer> ops;
if (!o.ops_listen.empty()) {
auto listening = server::OpsServer::listen(o.ops_listen);
@@ -667,10 +819,23 @@ int serve_primitive(Options& o) {
};
for (;;) {
if (stop_requested) {
#ifdef EVO_SERVER_M10
if (primitive_sessions->sessions)
primitive_sessions->sessions->shutdown(std::chrono::steady_clock::now());
#endif
host.drain();
return finish(0);
}
const auto& status = host.step();
#ifdef EVO_SERVER_M10
if (primitive_sessions->sessions)
primitive_sessions->sessions->poll(
{status.ready, status.epoch, status.simulated_tick},
static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::system_clock::now().time_since_epoch())
.count()),
std::chrono::steady_clock::now());
#endif
set_ready(status.ready);
if (!phase || *phase != status.phase) {
phase = status.phase;
@@ -716,6 +881,8 @@ int main(int argc, char** argv) {
"--objects DIR --build HEX64 [--retained HEX64]... [--pg-hostaddr A "
"--pg-passfile F --pg-ca F] [--flush-ms N] [--drain-ms N] "
"[--lease-profile default|fast] [--ready-file PATH] "
"[--primitive-listen ADDRESS:PORT --primitive-cert F --primitive-key F "
"--primitive-issuer F --primitive-environment dev|stage|world0] "
"[--ops-listen ADDRESS:PORT] [--synthetic-inputs development-v1 "
"[--synthetic-until TICK] [--accelerate N] [--session-listen ADDRESS:PORT "
"--session-cert F --session-key F --session-grant-key F "