Route cellular logins to existing life owners
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 39s
Foundation / checks (ecs) (push) Successful in 2m1s
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 (postgres) (push) Canceled after 22s
Foundation / checks (network) (push) Canceled after 1m58s
Foundation / checks (client) (push) Canceled after 2m39s

This commit is contained in:
dingo
2026-10-11 01:32:14 -04:00
parent 636740bc55
commit a6b1c62168
11 changed files with 273 additions and 106 deletions
+21 -20
View File
@@ -29,9 +29,10 @@ namespace evo::server_app {
// owner-filtered v8 perception.
class CellularBridge {
public:
static std::optional<CellularBridge>
open(const M10Options& options, server::CellularRegionHost& host,
persistence::RegionKey key, std::uint64_t frame, const persistence::PgOptions& pg) {
static std::optional<CellularBridge> open(const M10Options& options,
server::CellularRegionHost& host,
persistence::RegionKey key, std::uint64_t frame,
const persistence::PgOptions& pg) {
if (!options.complete())
return fail("error cellular-session-config");
CellularBridge bridge;
@@ -54,16 +55,19 @@ class CellularBridge {
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.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;
const auto life_routes = parse_life_owner_routes(options);
if (!life_routes || life_routes->empty())
return fail("error cellular-life-routes");
config.life_owner_routes = *life_routes;
network::GrantPublicKey public_key{};
std::copy(issuer.begin(), issuer.end(), public_key.begin());
config.issuer_keys.push_back({1, public_key});
@@ -73,19 +77,16 @@ class CellularBridge {
const auto lease = [&host] { return host.authority(); };
bridge.control_ =
std::make_unique<server::PostgresControlLedger>(*bridge.slot_, key, lease);
bridge.actions_ =
std::make_unique<server::PostgresActionLedger>(*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();
config.accept_cellular_actions = true;
config.create_primitive_life = [&host](const network::AccountId& account,
std::uint64_t generation,
std::uint64_t request) {
std::uint64_t generation, std::uint64_t request) {
return host.create_primitive_life(account.bytes, generation, request);
};
config.query_primitive_life = [&host](const network::AccountId& account,
std::uint64_t generation,
std::uint64_t request) {
std::uint64_t generation, std::uint64_t request) {
return host.query_primitive_life(account.bytes, generation, request);
};
auto sessions = server::RegionSessions::create(std::move(config));
@@ -126,7 +127,7 @@ class CellularBridge {
std::printf("cellular %s session=%llu account=%s reason=%u\n",
event.kind == server::RegionSessionEvent::Kind::opened ? "opened"
: event.kind == server::RegionSessionEvent::Kind::closed ? "closed"
: "refused",
: "refused",
static_cast<unsigned long long>(event.session), event.account.c_str(),
static_cast<unsigned>(event.reason));
}
@@ -155,12 +156,12 @@ class CellularBridge {
const auto genome = state.archive().find(life.identity.genome);
if (!genome)
continue;
const biology::EnvironmentState environment{
state.ambient_temperature_millikelvin(), life.reserve};
const biology::EnvironmentState environment{state.ambient_temperature_millikelvin(),
life.reserve};
auto cell = client::present_organism(
life.identity.organism, voxel,
{life.position.x_um % 1'000'000}, {life.position.y_um % 1'000'000}, *genome,
life.growth, environment, client::OrganismState::alive);
life.identity.organism, voxel, {life.position.x_um % 1'000'000},
{life.position.y_um % 1'000'000}, *genome, life.growth, environment,
client::OrganismState::alive);
if (cell)
result.organisms.push_back(*cell);
}
+30 -1
View File
@@ -63,10 +63,14 @@ struct M10Options {
// neighbours "REGION=X0,Y0,X1,Y1=HOST:PORT=SERVER_NAME=PUBLIC_KEY_FILE".
std::string area, handoff_key;
std::vector<std::string> neighbours;
// M11 owner routing, independent of --m10-neighbour:
// REGION=HOST:PORT=TLS_NAME, one entry per region in the world.
std::vector<std::string> life_routes;
[[nodiscard]] bool any() const noexcept {
return !listen.empty() || !certificate.empty() || !key.empty() || !issuer.empty() ||
!environment.empty() || !session_window.empty() || max_grant_lifetime != 0 ||
!area.empty() || !handoff_key.empty() || !neighbours.empty() || !load_governor;
!area.empty() || !handoff_key.empty() || !neighbours.empty() ||
!life_routes.empty() || !load_governor;
}
[[nodiscard]] bool complete() const noexcept {
return !listen.empty() && !certificate.empty() && !key.empty() && !issuer.empty() &&
@@ -80,6 +84,27 @@ inline constexpr std::uint64_t m10_carry_ahead_ticks = 8;
inline constexpr std::size_t m10_max_sessions = 2000;
#ifdef EVO_SERVER_M10
inline std::optional<std::vector<server::LifeOwnerRoute>>
parse_life_owner_routes(const M10Options& options) {
std::vector<server::LifeOwnerRoute> routes;
routes.reserve(options.life_routes.size());
for (const auto& item : options.life_routes) {
const auto first = item.find('=');
const auto second =
first == std::string::npos ? std::string::npos : item.find('=', first + 1);
if (first == std::string::npos || second == std::string::npos ||
item.find('=', second + 1) != std::string::npos)
return std::nullopt;
std::uint64_t region{};
const auto [end, error] = std::from_chars(item.data(), item.data() + first, region);
if (error != std::errc{} || end != item.data() + first || region == 0)
return std::nullopt;
routes.push_back({network::RegionAddress{region, item.substr(first + 1, second - first - 1),
item.substr(second + 1)}});
}
return routes;
}
inline constexpr bool m10_available = true;
template <typename Host> class M10Bridge {
public:
@@ -185,6 +210,10 @@ template <typename Host> class M10Bridge {
config.handoff = bridge.handoff_.get();
std::printf("m10 handoff neighbours=%zu\n", config.neighbours.size());
}
const auto life_routes = parse_life_owner_routes(o);
if (!life_routes)
return fail("error m10-life-routes");
config.life_owner_routes = *life_routes;
auto sessions = server::RegionSessions::create(std::move(config));
if (!sessions)
return fail(sessions.error() == server::RegionSessionsError::keys ? "error m10-issuer"
+37 -38
View File
@@ -171,9 +171,8 @@ std::optional<Options> parse(int argc, char** argv) {
return std::nullopt;
const std::string_view value = argv[++i];
const auto n = number(value);
if (flag == "--profile" &&
(value == "lineage" || value == "environmental" || value == "primitive" ||
value == "cellular"))
if (flag == "--profile" && (value == "lineage" || value == "environmental" ||
value == "primitive" || value == "cellular"))
o.profile = value;
else if (flag == "--world" && n)
o.host.key.world = *n;
@@ -267,6 +266,8 @@ std::optional<Options> parse(int argc, char** argv) {
o.m10.handoff_key = value;
else if (flag == "--m10-neighbour" && o.m10.neighbours.size() < 8)
o.m10.neighbours.emplace_back(value);
else if (flag == "--life-route" && o.m10.life_routes.size() < 4096)
o.m10.life_routes.emplace_back(value);
else if (flag == "--m10-load-governor" && (value == "on" || value == "off"))
o.m10.load_governor = value == "on";
else if (flag == "--primitive-listen")
@@ -321,10 +322,9 @@ std::optional<Options> parse(int argc, char** argv) {
return std::nullopt;
if (o.profile == "cellular" &&
(!server_app::m10_available || !o.m10.complete() || o.primitive_session.any() ||
o.synthetic || !o.crash_point.empty() || o.session.any() ||
!o.m10.area.empty() || !o.m10.handoff_key.empty() || !o.m10.neighbours.empty() ||
o.m10.max_grant_lifetime != 0 || !o.m10.load_governor ||
o.host.flush_interval != 1000ms || o.drain != 10000ms))
o.synthetic || !o.crash_point.empty() || o.session.any() || !o.m10.area.empty() ||
!o.m10.handoff_key.empty() || !o.m10.neighbours.empty() || o.m10.max_grant_lifetime != 0 ||
!o.m10.load_governor || o.host.flush_interval != 1000ms || o.drain != 10000ms))
return std::nullopt;
if (std::ranges::find(o.host.retained_builds, o.host.build) == o.host.retained_builds.end())
o.host.retained_builds.push_back(o.host.build);
@@ -946,8 +946,7 @@ int serve_cellular(Options& o) {
set_ready(false);
const auto& status = host.status();
std::printf("phase %s epoch=%llu committed=%llu simulated=%llu\n",
server::phase_name(status.phase),
static_cast<unsigned long long>(status.epoch),
server::phase_name(status.phase), static_cast<unsigned long long>(status.epoch),
static_cast<unsigned long long>(status.committed_tick),
static_cast<unsigned long long>(status.simulated_tick));
std::printf("stats commits=%llu store_failures=%llu\n",
@@ -964,10 +963,10 @@ int serve_cellular(Options& o) {
return finish(0);
}
const auto& status = host.step();
const auto wall = static_cast<std::uint64_t>(
std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::system_clock::now().time_since_epoch())
.count());
const auto wall =
static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::system_clock::now().time_since_epoch())
.count());
static_cast<void>(bridge->accepting(wall));
bridge->poll(status, wall);
deliver_finalized();
@@ -1024,8 +1023,8 @@ int serve_cellular(Options& o) {
baseline.push_back({life.identity.life, {}});
std::ranges::sort(baseline, {}, &server::CellularLifeIntent::life_id);
auto actions = bridge->carry(tick);
auto builder = server::CellularSessionBatchBuilder::create(
*state, host.committed()->head);
auto builder =
server::CellularSessionBatchBuilder::create(*state, host.committed()->head);
if (!builder) {
bridge->dropped(actions, true);
} else {
@@ -1047,9 +1046,9 @@ int serve_cellular(Options& o) {
deliver_finalized();
}
}
*next_tick = std::chrono::steady_clock::now() + std::chrono::microseconds{
static_cast<std::chrono::microseconds::rep>(
biology::cellular_motion_tick_microseconds)};
*next_tick = std::chrono::steady_clock::now() +
std::chrono::microseconds{static_cast<std::chrono::microseconds::rep>(
biology::cellular_motion_tick_microseconds)};
}
} else {
next_tick.reset(); // A disconnected life does not accumulate offline ticks.
@@ -1066,26 +1065,26 @@ int serve_cellular(Options& o) {
int main(int argc, char** argv) {
auto options = parse(argc, argv);
if (!options) {
std::fputs(
"usage: evo-server --profile lineage|environmental|primitive|"
"cellular --world N --region N "
"--frame N --pg-host H --pg-port P --pg-database D --pg-user U "
"--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 "
"--session-grant-ledger F --session-environment dev]] [--m10-listen "
"ADDRESS:PORT --m10-cert F --m10-key F --m10-issuer F "
"--m10-environment dev|stage|world0 --session-window ACTIVATION:UTC_EXPIRY "
"[--m10-max-grant-lifetime 60..14400] [--m10-area X0,Y0,X1,Y1] "
"[--m10-handoff-key F [--m10-neighbour "
"REGION=X0,Y0,X1,Y1=HOST:PORT=NAME=PUBFILE]...] "
"[--m10-load-governor on|off]]\\n",
stderr);
std::fputs("usage: evo-server --profile lineage|environmental|primitive|"
"cellular --world N --region N "
"--frame N --pg-host H --pg-port P --pg-database D --pg-user U "
"--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 "
"--session-grant-ledger F --session-environment dev]] [--m10-listen "
"ADDRESS:PORT --m10-cert F --m10-key F --m10-issuer F "
"--m10-environment dev|stage|world0 --session-window ACTIVATION:UTC_EXPIRY "
"[--m10-max-grant-lifetime 60..14400] [--m10-area X0,Y0,X1,Y1] "
"[--m10-handoff-key F [--m10-neighbour "
"REGION=X0,Y0,X1,Y1=HOST:PORT=NAME=PUBFILE]...] "
"[--life-route REGION=HOST:PORT=TLS_NAME ...] "
"[--m10-load-governor on|off]]\\n",
stderr);
return 2;
}
struct sigaction action{};
+8 -7
View File
@@ -137,13 +137,14 @@ Local checks do not close ADR-0097's reference-worker qualification.
reservations route to their original region and a refused/cancelled-only
history has no active owner. PostgreSQL and migration CI execution remain
pending.
- Cross-region owner routing and reconnect-to-existing-life remain unimplemented.
[ADR-0116](../adr/0116-cellular-life-owner-routing.md) resolves the contract:
resolve the durable world/account owner before claiming control, then reuse
the existing SessionRedirect and an operator-provisioned complete region route
catalog. Missing owner data or route fails closed; client endpoints are never
authoritative. Do not claim 11.2 complete until redirect/client switching,
process-kill qualification and restart retry pass.
- 11.2d-7b implementation: grant login resolves the active life owner after
signature/scope checks and before durable control claim. A different owner
uses the v4+ SessionRedirect from an explicit `--life-route` per world region,
then closes as moved. Cellular startup requires a route catalog containing
this region; malformed, duplicate, unavailable, and missing-owner routes fail
closed. QUIC tests cover redirect-before-claim and missing-route refusal.
PostgreSQL and migration CI, client switching, and process-kill qualification
remain pending. Do not claim 11.2 complete until redirect/restart gates pass.
No deployed world has been provisioned or changed by this work.
+19
View File
@@ -6555,3 +6555,22 @@ because the Windows environment lacks POSIX `poll.h`. PostgreSQL/psql, CTest,
and CI have not run for this segment. The CI migration, privilege, and
PostgreSQL integration results remain required before closing the database
gate.
## 2026-10-11 — M11.2d-7b owner routing (CI and runtime pending)
The QUIC session path now resolves the durable life owner after grant
verification/scope checks and before calling the durable control claim. A
different owner is looked up only in the operator-provided `--life-route`
catalog; the listener sends the existing `SessionRedirect` for v4 and later,
then `Close(moved)`. An incomplete catalog or database lookup failure does not
claim control. Cellular server startup requires at least its own route entry.
GCC 13.2 strict-warning syntax compilation passed for
`src/server/session/region_sessions.cpp`,
`src/server/session/postgres_control_ledger.cpp`, and
`tests/quic_sessions.cpp`. A translation unit including the cellular bridge
also compiled, and the Visual Studio LLVM `clang-format` check and
`git diff --check` passed. The full `evo-server` source could not be compiled
locally because this Windows environment lacks POSIX `poll.h`; the QUIC test
binary, PostgreSQL integration suite, and CI have not run. The database owner
lookup and route behavior still require CI/runtime qualification.
+6
View File
@@ -186,6 +186,12 @@ class ControlLedger {
virtual ~ControlLedger() = default;
[[nodiscard]] virtual std::expected<ControlLease, ControlLedgerError>
claim(const AccountId& account, std::uint64_t serial, std::uint64_t session) = 0;
// Optional M11 lookup, called before claim() when the host has an operator-provisioned
// life-owner route catalog. Implementations without durable life reservations fail closed.
[[nodiscard]] virtual std::expected<std::optional<std::uint64_t>, ControlLedgerError>
primitive_life_owner(const AccountId&) {
return std::unexpected(ControlLedgerError::unavailable);
}
[[nodiscard]] virtual std::expected<std::chrono::milliseconds, ControlLedgerError>
renew(const AccountId& account, std::uint64_t generation) = 0;
virtual void release(const AccountId& account, std::uint64_t generation) = 0;
@@ -1,6 +1,7 @@
#pragma once
#include "evo/network/session_control.hpp"
#include "evo/persistence/account_control_store.hpp"
#include "evo/persistence/life_reservation_store.hpp"
#include "evo/server/pg_slot.hpp"
#include <chrono>
#include <functional>
@@ -22,6 +23,8 @@ class PostgresControlLedger final : public network::ControlLedger {
: db_{&db}, key_{key}, lease_{std::move(lease)}, duration_{duration}, timeout_{timeout} {}
[[nodiscard]] std::expected<network::ControlLease, network::ControlLedgerError>
claim(const network::AccountId& account, std::uint64_t serial, std::uint64_t session) override;
[[nodiscard]] std::expected<std::optional<std::uint64_t>, network::ControlLedgerError>
primitive_life_owner(const network::AccountId& account) override;
[[nodiscard]] std::expected<std::chrono::milliseconds, network::ControlLedgerError>
renew(const network::AccountId& account, std::uint64_t generation) override;
void release(const network::AccountId& account, std::uint64_t generation) override;
+10 -2
View File
@@ -59,6 +59,11 @@ struct HandoffKey {
std::uint32_t key_id{};
network::GrantPublicKey public_key{};
};
// Operator-provisioned destination for a durable primitive life. This world catalog is
// independent of physical neighbours and is consulted only before a grant claims control.
struct LifeOwnerRoute {
network::RegionAddress address;
};
struct RegionSessionsConfig {
network::quic::ServerConfig transport;
network::ControlConfig control; // `epoch` is the initial ownership epoch.
@@ -70,6 +75,9 @@ struct RegionSessionsConfig {
// 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{};
// When present, every entry must be supplied by the operator, including this region.
// A life in another region is redirected before durable control can move here.
std::vector<LifeOwnerRoute> life_owner_routes;
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.
@@ -157,8 +165,8 @@ class RegionSessions {
const network::Perceives& perceives = {});
// V8 reliable cellular perception is unicast to the current established session
// for the supplied authenticated account. Empty views clear that owner's stale view.
[[nodiscard]] bool send_cellular_perception(
const network::AccountId& account, const network::CellularPerception& perception);
[[nodiscard]] bool send_cellular_perception(const network::AccountId& account,
const network::CellularPerception& perception);
void clear_cellular_perceptions(std::uint64_t tick);
[[nodiscard]] network::ReplicationStats replication_stats() const;
// M10.9a (ADR-0097): the host's load governor output. While `refuse_logins`, a Hello
@@ -45,6 +45,33 @@ PostgresControlLedger::claim(const network::AccountId& account, std::uint64_t se
return network::ControlLease{claimed->generation, claimed->wait, claimed->granted};
}
std::expected<std::optional<std::uint64_t>, network::ControlLedgerError>
PostgresControlLedger::primitive_life_owner(const network::AccountId& account) {
const auto lease = lease_();
if (!lease)
return std::unexpected(network::ControlLedgerError::fenced);
auto* db = db_->get();
if (!db)
return std::unexpected(network::ControlLedgerError::unavailable);
const auto owner =
persistence::primitive_life_owner(*db, key_, *lease, uuid(account), timeout_);
if (!owner) {
note(*db_, owner.error().kind == persistence::LifeReservationError::store
? ControlStoreError::store
: owner.error().kind == persistence::LifeReservationError::unknown
? ControlStoreError::unknown
: owner.error().kind == persistence::LifeReservationError::fenced
? ControlStoreError::fenced
: ControlStoreError::invalid);
return std::unexpected(owner.error().kind == persistence::LifeReservationError::fenced
? network::ControlLedgerError::fenced
: owner.error().kind == persistence::LifeReservationError::invalid
? network::ControlLedgerError::fenced
: network::ControlLedgerError::unavailable);
}
return *owner;
}
std::expected<std::chrono::milliseconds, ControlLedgerError>
PostgresControlLedger::renew(const network::AccountId& account, std::uint64_t generation) {
const auto lease = lease_();
+49 -11
View File
@@ -1,5 +1,6 @@
#include "evo/server/region_sessions.hpp"
#include <algorithm>
#include <set>
#include <utility>
namespace evo::server {
@@ -63,6 +64,10 @@ SessionCloseReason reason_for(SessionGrantError e) {
return e == SessionGrantError::wrong_environment ? SessionCloseReason::wrong_scope
: SessionCloseReason::unauthenticated;
}
bool valid_route_text(const std::string& value) {
return !value.empty() && value.size() <= network::session_address_bytes &&
std::ranges::all_of(value, [](char ch) { return ch > 0x20 && ch < 0x7F; });
}
} // namespace
struct RegionSessions::Impl {
@@ -232,6 +237,24 @@ struct RegionSessions::Impl {
c.account = network::log_label(claims.account);
if (const auto checked = control.check(*grant, now_seconds); !checked)
return close(c, reason_for(checked.error()), now);
if (!config.life_owner_routes.empty()) {
if (!config.ledger)
return close(c, SessionCloseReason::capacity, now);
const auto owner = config.ledger->primitive_life_owner(claims.account);
if (!owner)
return close(c, reason_for(owner.error()), now);
if (*owner && **owner != config.control.region) {
const auto route = std::ranges::find_if(
config.life_owner_routes, [&](const LifeOwnerRoute& candidate) {
return candidate.address.region == **owner;
});
if (route == config.life_owner_routes.end())
return close(c, SessionCloseReason::capacity, now);
if (c.protocol_version >= network::session_protocol_version)
send(c, network::SessionRedirect{route->address});
return close(c, SessionCloseReason::moved, now);
}
}
// Durable control first, so the world never has two controlling regions; then the
// local admission, which check() has just confirmed.
std::optional<network::ControlLease> lease;
@@ -395,11 +418,11 @@ struct RegionSessions::Impl {
const auto decoded = network::decode_session(bytes, &wire_version);
if (c.state != State::established || !decoded || wire_version != c.protocol_version ||
(c.protocol_version != network::session_protocol_version &&
!((config.accept_cellular_intentions &&
c.protocol_version == network::session_protocol_v6) ||
(config.accept_cellular_actions &&
(c.protocol_version == network::session_protocol_v7 ||
c.protocol_version == network::session_protocol_v8)))))
!((config.accept_cellular_intentions &&
c.protocol_version == network::session_protocol_v6) ||
(config.accept_cellular_actions &&
(c.protocol_version == network::session_protocol_v7 ||
c.protocol_version == network::session_protocol_v8)))))
return close(c, SessionCloseReason::protocol, now);
if (const auto* ack = std::get_if<network::SnapshotAck>(&*decoded))
return replication.acknowledge(c.session, *ack);
@@ -566,7 +589,8 @@ struct RegionSessions::Impl {
(wire_version == network::session_protocol_v5 && !primitive_v5) ||
(wire_version == network::session_protocol_v6 && !cellular_v6) ||
((wire_version == network::session_protocol_v7 ||
wire_version == network::session_protocol_v8) && !cellular_actions) ||
wire_version == network::session_protocol_v8) &&
!cellular_actions) ||
wire_version > network::session_protocol_v8)
return close(c, SessionCloseReason::unsupported_version, now);
} else if (wire_version != c.protocol_version) {
@@ -642,8 +666,22 @@ RegionSessions::~RegionSessions() = default;
std::expected<std::unique_ptr<RegionSessions>, RegionSessionsError>
RegionSessions::create(RegionSessionsConfig config) {
bool has_own_life_route = config.life_owner_routes.empty();
std::set<std::uint64_t> life_route_regions;
for (const auto& route : config.life_owner_routes) {
const auto& address = route.address;
if (address.region == 0 || !valid_route_text(address.endpoint) ||
!valid_route_text(address.server_name) ||
!life_route_regions.insert(address.region).second)
return std::unexpected(RegionSessionsError::configuration);
has_own_life_route |= address.region == config.control.region;
}
// Connections beyond sessions are headroom for logins and closes still flushing.
if (config.issuer_keys.empty() || (config.handoff != nullptr && config.ledger == nullptr) ||
if (config.issuer_keys.empty() ||
(!config.life_owner_routes.empty() &&
(config.ledger == nullptr || config.life_owner_routes.size() > 4096 ||
!has_own_life_route)) ||
(config.handoff != nullptr && config.ledger == nullptr) ||
(config.handoff_key != nullptr && config.probes == nullptr) ||
config.ticket_lifetime == 0 || config.ticket_lifetime > network::max_ticket_lifetime ||
((config.create_primitive_life || config.query_primitive_life) &&
@@ -838,12 +876,12 @@ void RegionSessions::replicate(
m.send_datagram(*c, chunk); // A refused chunk leaves the snapshot unacknowledged.
}
bool RegionSessions::send_cellular_perception(
const network::AccountId& account, const network::CellularPerception& perception) {
bool RegionSessions::send_cellular_perception(const network::AccountId& account,
const network::CellularPerception& perception) {
auto& m = *impl_;
for (const auto& c : m.connections) {
if (c.state != Impl::State::established || c.protocol_version != network::session_protocol_v8 ||
c.account_id != account)
if (c.state != Impl::State::established ||
c.protocol_version != network::session_protocol_v8 || c.account_id != account)
continue;
return m.endpoint
->send_message(c.id, network::encode_session(perception, c.protocol_version))
+63 -27
View File
@@ -374,6 +374,12 @@ struct FakeLedger final : ControlLedger {
claims.push_back({account, serial, session});
return ControlLease{next_generation++, wait, granted};
}
std::expected<std::optional<std::uint64_t>, ControlLedgerError>
primitive_life_owner(const AccountId& /*account*/) override {
if (owner_error)
return std::unexpected(*owner_error);
return life_owner;
}
std::expected<std::chrono::milliseconds, ControlLedgerError>
renew(const AccountId& /*account*/, std::uint64_t generation) override {
renewed.push_back(generation);
@@ -384,13 +390,43 @@ struct FakeLedger final : ControlLedger {
void release(const AccountId& /*account*/, std::uint64_t generation) override {
released.push_back(generation);
}
std::optional<ControlLedgerError> claim_error, renew_error;
std::optional<ControlLedgerError> claim_error, renew_error, owner_error;
std::optional<std::uint64_t> life_owner;
std::chrono::milliseconds wait{}, granted{std::chrono::milliseconds{20000}};
std::uint64_t next_generation{1};
std::vector<Claim> claims;
std::vector<std::uint64_t> renewed, released;
};
void durable_life_owner_redirects_before_control_claim(const Files& f) {
FakeLedger ledger;
ledger.life_owner = 12;
Harness h{f, 4, 64, &ledger, [](server::RegionSessionsConfig& c) {
c.life_owner_routes = {
server::LifeOwnerRoute{RegionAddress{region, "region-11.example.test:7400",
"region-11.example.test"}},
server::LifeOwnerRoute{RegionAddress{12, "region-12.example.test:7400",
"region-12.example.test"}}};
}};
const auto alice = account(0xB4);
auto client = h.connect(h.issuer.grant(alice, 1), session_protocol_v8);
CHECK(h.settled(*client) && client->state() == RegionSessionState::closed);
CHECK(client->close_reason() == Reason::moved && client->redirect());
CHECK(must(client->redirect()) ==
RegionAddress{12, "region-12.example.test:7400", "region-12.example.test"});
CHECK(ledger.claims.empty()); // The redirect happened before durable control was claimed.
FakeLedger incomplete_ledger;
incomplete_ledger.life_owner = 12;
Harness incomplete{f, 4, 64, &incomplete_ledger, [](server::RegionSessionsConfig& c) {
c.life_owner_routes = {server::LifeOwnerRoute{RegionAddress{
region, "region-11.example.test:7400", "region-11.example.test"}}};
}};
auto no_route = incomplete.connect(incomplete.issuer.grant(alice, 2), session_protocol_v8);
CHECK(incomplete.settled(*no_route) && no_route->close_reason() == Reason::capacity);
CHECK(!no_route->redirect() && incomplete_ledger.claims.empty());
}
void primitive_v5_session(const Files& f) {
FakeLedger ledger;
Harness h{f, 4, 64, &ledger, [](server::RegionSessionsConfig& c) {
@@ -512,12 +548,13 @@ void cellular_v7_action_session(const Files& f) {
const auto carried = h.server->carry(101);
CHECK(carried.size() == 1 && carried.front().account == alice &&
carried.front().action_id == 88 && carried.front().tick == 101 &&
carried.front().kind == ActionKind::cellular && carried.front().cellular_input ==
carried.front().kind == ActionKind::cellular &&
carried.front().cellular_input ==
std::optional{encode_cellular_action_input({101, 0, 0, false, 0, 0})});
actions.owner = alice;
actions.id = 88;
actions.record = DurableActionRecord{
ActionOutcome{88, ActionResult::committed, 101, 1}, carried.front().cellular_input};
actions.record = DurableActionRecord{ActionOutcome{88, ActionResult::committed, 101, 1},
carried.front().cellular_input};
h.server->committed(carried, 1);
std::vector<ActionOutcome> outcomes;
CHECK(h.until([&] { return !(outcomes = client->take_action_outcomes()).empty(); }));
@@ -540,25 +577,23 @@ void cellular_v7_action_session(const Files& f) {
c.actions = &actions;
c.accept_cellular_actions = true;
}};
auto reconnected = restarted.connect(restarted.issuer.grant(alice, 2),
session_protocol_v7);
auto reconnected = restarted.connect(restarted.issuer.grant(alice, 2), session_protocol_v7);
CHECK(restarted.settled(*reconnected) &&
reconnected->state() == RegionSessionState::established);
CHECK(reconnected->send_cellular_action(88, 101, 0, 0));
CHECK(restarted.until(
[&] { return !(receipts = reconnected->take_action_receipts()).empty(); }));
CHECK(
restarted.until([&] { return !(receipts = reconnected->take_action_receipts()).empty(); }));
CHECK(receipts.front().status == AdmitStatus::duplicate);
CHECK(restarted.until(
[&] { return !(outcomes = reconnected->take_action_outcomes()).empty(); }));
CHECK(
restarted.until([&] { return !(outcomes = reconnected->take_action_outcomes()).empty(); }));
CHECK(outcomes.front() == ActionOutcome{88, ActionResult::committed, 101, 1});
CHECK(reconnected->send_cellular_action(88, 101, 1, 0));
CHECK(restarted.until(
[&] { return !(receipts = reconnected->take_action_receipts()).empty(); }));
CHECK(
restarted.until([&] { return !(receipts = reconnected->take_action_receipts()).empty(); }));
CHECK(receipts.front().status == AdmitStatus::invalid_action);
Harness refused{f, 4, 64, &control};
auto unsupported = refused.connect(refused.issuer.grant(account(0xA9), 1),
session_protocol_v7);
auto unsupported = refused.connect(refused.issuer.grant(account(0xA9), 1), session_protocol_v7);
CHECK(refused.settled(*unsupported) && unsupported->state() == RegionSessionState::closed &&
unsupported->close_reason() == SessionCloseReason::unsupported_version);
}
@@ -575,18 +610,17 @@ void cellular_v5_spawn_and_v7_action_share_region_sessions(const Files& f) {
}
} actions;
FakeLedger control;
Harness h{f, 4, 64, &control, [&](server::RegionSessionsConfig& c) {
c.actions = &actions;
c.accept_cellular_actions = true;
c.create_primitive_life = [](const AccountId&, std::uint64_t,
std::uint64_t request) {
return PrimitiveLifeOutcome{request, PrimitiveLifeResult::born, 901, 5};
};
c.query_primitive_life = [](const AccountId&, std::uint64_t,
std::uint64_t request) {
return PrimitiveLifeOutcome{request, PrimitiveLifeResult::pending, 0, 0};
};
}};
Harness h{
f, 4, 64, &control, [&](server::RegionSessionsConfig& c) {
c.actions = &actions;
c.accept_cellular_actions = true;
c.create_primitive_life = [](const AccountId&, std::uint64_t, std::uint64_t request) {
return PrimitiveLifeOutcome{request, PrimitiveLifeResult::born, 901, 5};
};
c.query_primitive_life = [](const AccountId&, std::uint64_t, std::uint64_t request) {
return PrimitiveLifeOutcome{request, PrimitiveLifeResult::pending, 0, 0};
};
}};
auto spawn_client = h.connect(h.issuer.grant(account(0xB5), 1), session_protocol_v5);
auto action_client = h.connect(h.issuer.grant(account(0xB7), 1), session_protocol_v7);
const auto owner_account = account(0xB8);
@@ -600,7 +634,8 @@ void cellular_v5_spawn_and_v7_action_share_region_sessions(const Files& f) {
CHECK(spawn_client->request_primitive_life(44));
std::vector<PrimitiveLifeOutcome> birth_outcomes;
CHECK(h.until([&] { return !(birth_outcomes = spawn_client->take_primitive_life_outcomes()).empty(); }));
CHECK(h.until(
[&] { return !(birth_outcomes = spawn_client->take_primitive_life_outcomes()).empty(); }));
CHECK(birth_outcomes.front() == PrimitiveLifeOutcome{44, PrimitiveLifeResult::born, 901, 5});
CHECK(action_client->send_cellular_action(55, 101, 0, 0));
@@ -1469,6 +1504,7 @@ void storm(const Files& f) {
int main() try {
const auto files = credentials();
login_rules(files);
durable_life_owner_redirects_before_control_claim(files);
primitive_v5_session(files);
cellular_v6_session(files);
cellular_v7_action_session(files);