Add M10.8c-2 client handoff switch and evo-server handoff configuration
Foundation / checks (deploy) (push) Successful in 3m20s
Foundation / checks (ecs) (push) Successful in 2m0s
Foundation / checks (client) (push) Failing after 12m9s
Foundation / checks (network) (push) Successful in 13m2s
Foundation / checks (tsan) (push) Successful in 8m7s
Foundation / checks (checks) (push) Successful in 32m1s
Foundation / checks (postgres) (push) Successful in 42m43s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped
Foundation / checks (deploy) (push) Successful in 3m20s
Foundation / checks (ecs) (push) Successful in 2m0s
Foundation / checks (client) (push) Failing after 12m9s
Foundation / checks (network) (push) Successful in 13m2s
Foundation / checks (tsan) (push) Successful in 8m7s
Foundation / checks (checks) (push) Successful in 32m1s
Foundation / checks (postgres) (push) Successful in 42m43s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped
ADR-0096. The engineering client follows a HandoffOffer into the next region with its ticket (no grant, no pause, the view kept) and a Redirect to the probe's owner, picking grants by region claim in rising serial order. evo-server gains --m10-area, --m10-handoff-key and --m10-neighbour (dev only), wiring the PostgreSQL probe and handoff ledgers; the probe tool writes multi-region bundles and reports handoffs and redirects. Refreshes the dev session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -346,6 +346,7 @@ void session(const PanelView& v) {
|
||||
if (ImGui::BeginTable("status", 3, ImGuiTableFlags_SizingFixedFit)) {
|
||||
row("Connection", s.phase);
|
||||
row("Session / epoch", std::to_string(s.session) + " / " + std::to_string(s.epoch));
|
||||
row("Region", std::to_string(s.region) + " (" + std::to_string(s.handoffs) + " crossings)");
|
||||
row("Server tick", std::to_string(s.server_tick));
|
||||
row("Simulated through", std::to_string(s.simulated_tick));
|
||||
row("Grants left", std::to_string(s.grants_left));
|
||||
|
||||
@@ -23,6 +23,13 @@
|
||||
// `delay` ticks behind (adaptive), extrapolated at most two ticks, then marked stale. When the
|
||||
// session is lost the last view stays frozen and stale: the own marker at its last
|
||||
// authoritative position, nothing predicted or sent. A new session starts afresh.
|
||||
//
|
||||
// M10.8c-2 (ADR-0096): a HandoffOffer (the probe crossed into another region) is followed at
|
||||
// once: the frozen view stays on screen, no grant is used, and the next connection goes to
|
||||
// the destination with the offer's ticket. A Redirect at login (the probe lives elsewhere)
|
||||
// is followed with a grant for that region. Grants are picked by their region claim (the
|
||||
// session-grant-v1 layout is public; the claim only routes, the region still verifies), so a
|
||||
// bundle may hold grants for several regions.
|
||||
#include "evo/client/camera.hpp"
|
||||
#include "evo/client/environment_view.hpp"
|
||||
#include "evo/client/input.hpp"
|
||||
@@ -45,8 +52,11 @@
|
||||
#include "evo/network/quic_transport.hpp"
|
||||
#include "evo/world/coordinates.hpp"
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <charconv>
|
||||
#include <cmath>
|
||||
#include <deque>
|
||||
#include <map>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
@@ -74,6 +84,7 @@ struct RemoteStatus {
|
||||
// Interpolation (ADR-0095): the current delay in ticks, markers shown stale, and whether
|
||||
// the whole view is a frozen copy from a lost session.
|
||||
double interpolation_delay{}, remote_render_tick{}; // Ticks: delay, clock - delay.
|
||||
std::uint64_t region{}, handoffs{}; // Region of the current session; crossings followed.
|
||||
std::size_t stale_markers{};
|
||||
bool stale_view{};
|
||||
};
|
||||
@@ -106,6 +117,10 @@ class RemoteSession {
|
||||
session.transport_.authority_pem = m.authority_pem;
|
||||
session.transport_.authority_pem_file = m.authority_path;
|
||||
session.grants_ = m.grants;
|
||||
session.used_.assign(m.grants.size(), false);
|
||||
// The endpoint typed in the launcher is the first grant's region.
|
||||
session.target_region_ = grant_region(m.grants.front());
|
||||
session.routes_[session.target_region_] = session.transport_;
|
||||
return session;
|
||||
}
|
||||
RemoteSession(RemoteSession&&) noexcept = default;
|
||||
@@ -117,6 +132,8 @@ class RemoteSession {
|
||||
client_->close(); // Close{client_closed}; unresolved intentions stay unknown.
|
||||
for (auto& g : grants_)
|
||||
g.fill(0);
|
||||
if (ticket_)
|
||||
ticket_->fill(0);
|
||||
}
|
||||
[[nodiscard]] const client::EnvironmentLayer& environment() const noexcept {
|
||||
return environment_;
|
||||
@@ -138,7 +155,11 @@ class RemoteSession {
|
||||
s.epoch = epoch_;
|
||||
s.server_tick = server_tick_;
|
||||
s.simulated_tick = simulated_tick_;
|
||||
s.grants_left = grants_.size() - next_;
|
||||
s.grants_left = static_cast<std::size_t>(std::ranges::count(used_, false));
|
||||
s.region = region_;
|
||||
s.handoffs = handoffs_;
|
||||
if (ticket_ || (client_ && handing_off_ && !live))
|
||||
s.phase = "handing off";
|
||||
s.welcomed = welcomed_;
|
||||
s.snapshot_tick = seen_snapshot_;
|
||||
s.snapshot_bytes = snapshot_bytes_ + (client_ ? client_->snapshot_bytes() : 0);
|
||||
@@ -258,22 +279,85 @@ class RemoteSession {
|
||||
static_cast<void>(ui.notify(text, level).has_value()); // Bounded; overflow evicts.
|
||||
}
|
||||
// Opens the next connection with the next grant; false while pausing or out of grants.
|
||||
// The region claim of a session-grant-v1 record (marker "EVO-GRANT", region at offset
|
||||
// 72), read only to route; anything else has no region (0).
|
||||
static std::uint64_t grant_field(const network::WireGrant& g, std::size_t at) {
|
||||
static constexpr std::array<std::uint8_t, 9> marker{'E', 'V', 'O', '-', 'G',
|
||||
'R', 'A', 'N', 'T'};
|
||||
if (!std::equal(marker.begin(), marker.end(), g.begin()))
|
||||
return 0;
|
||||
std::uint64_t v = 0;
|
||||
for (std::size_t i = 0; i < 8; ++i)
|
||||
v |= static_cast<std::uint64_t>(g.at(at + i)) << (8 * i);
|
||||
return v;
|
||||
}
|
||||
static std::uint64_t grant_region(const network::WireGrant& g) {
|
||||
return grant_field(g, 72);
|
||||
}
|
||||
// Serials must rise world-wide (durable account control): never use a lower one after a
|
||||
// higher one, whichever region it is for.
|
||||
static std::uint64_t grant_serial(const network::WireGrant& g) {
|
||||
return grant_field(g, 48);
|
||||
}
|
||||
// How to dial a region named by an offer or redirect ("host:port" and its certificate
|
||||
// name), resolved once; nothing when the address cannot be used.
|
||||
[[nodiscard]] bool learn_route(const network::RegionAddress& a) {
|
||||
const auto colon = a.endpoint.rfind(':');
|
||||
if (colon == std::string::npos)
|
||||
return false;
|
||||
std::uint16_t port = 0;
|
||||
const auto* begin = a.endpoint.data() + colon + 1;
|
||||
const auto* end = a.endpoint.data() + a.endpoint.size();
|
||||
if (const auto [at, ec] = std::from_chars(begin, end, port);
|
||||
ec != std::errc{} || at != end || port == 0)
|
||||
return false;
|
||||
const auto address = network::quic::resolve_ipv4(a.endpoint.substr(0, colon));
|
||||
if (!address)
|
||||
return false;
|
||||
auto route = transport_; // Same pinned CA: one world, one dev CA.
|
||||
route.server_address = *address;
|
||||
route.port = port;
|
||||
route.server_name = a.server_name;
|
||||
routes_[a.region] = std::move(route);
|
||||
return true;
|
||||
}
|
||||
bool start(Clock::time_point now, client::Launcher& launcher) {
|
||||
if (now < retry_at_)
|
||||
return false;
|
||||
if (next_ >= grants_.size()) {
|
||||
if (!exhausted_) {
|
||||
exhausted_ = true;
|
||||
launcher.observe(client::ConnectSignal::exhausted);
|
||||
std::puts("session grants exhausted; issue a new bundle to reconnect");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
client::RegionSessionClientConfig config;
|
||||
config.transport = transport_;
|
||||
config.grant = grants_[next_];
|
||||
grants_[next_].fill(0);
|
||||
++next_;
|
||||
const auto route = routes_.find(target_region_);
|
||||
config.transport = route != routes_.end() ? route->second : transport_;
|
||||
if (ticket_) { // A handoff: the ticket replaces a grant, once.
|
||||
config.grant = *ticket_;
|
||||
ticket_->fill(0);
|
||||
ticket_.reset();
|
||||
} else {
|
||||
std::size_t pick = grants_.size();
|
||||
for (std::size_t i = 0; i < grants_.size(); ++i)
|
||||
if (!used_[i] && grant_serial(grants_[i]) < newest_serial_) {
|
||||
grants_[i].fill(0); // Outdated by a grant already used: unusable.
|
||||
used_[i] = true;
|
||||
}
|
||||
for (std::size_t i = 0; i < grants_.size(); ++i)
|
||||
if (!used_[i] &&
|
||||
(target_region_ == 0 || grant_region(grants_[i]) == target_region_) &&
|
||||
(pick == grants_.size() ||
|
||||
grant_serial(grants_[i]) < grant_serial(grants_[pick])))
|
||||
pick = i; // The lowest usable serial for the region.
|
||||
if (pick == grants_.size()) {
|
||||
if (!exhausted_) {
|
||||
exhausted_ = true;
|
||||
launcher.observe(client::ConnectSignal::exhausted);
|
||||
std::printf("session grants for region %llu exhausted; issue a new bundle\n",
|
||||
static_cast<unsigned long long>(target_region_));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
newest_serial_ = std::max(newest_serial_, grant_serial(grants_[pick]) + 1);
|
||||
config.grant = grants_[pick];
|
||||
grants_[pick].fill(0);
|
||||
used_[pick] = true;
|
||||
}
|
||||
auto made = client::RegionSessionClient::connect(std::move(config), now);
|
||||
if (!made) {
|
||||
launcher.observe(client::ConnectSignal::lost);
|
||||
@@ -293,13 +377,15 @@ class RemoteSession {
|
||||
established_ = true;
|
||||
welcomed_ = true;
|
||||
backoff_ = std::chrono::seconds{2};
|
||||
if (w.epoch != epoch_) { // Another authority lineage: start the views afresh.
|
||||
handing_off_ = false;
|
||||
if (w.epoch != epoch_ || w.region != region_) { // Another lineage or region: afresh.
|
||||
environment_.reset();
|
||||
organisms_.reset();
|
||||
seen_snapshot_ = 0;
|
||||
}
|
||||
session_ = w.session;
|
||||
epoch_ = w.epoch;
|
||||
region_ = w.region;
|
||||
sent_tick_.reset(); // New session: resend the current intention.
|
||||
sent_ = {};
|
||||
sent_interest_.reset(); // The server starts from its default interest.
|
||||
@@ -468,6 +554,8 @@ class RemoteSession {
|
||||
void end(Clock::time_point now, client::UiState& ui, client::Launcher& launcher) {
|
||||
using network::SessionCloseReason;
|
||||
const auto reason = client_->close_reason().value_or(SessionCloseReason::connection_lost);
|
||||
const auto offer = client_->take_handoff();
|
||||
const auto redirect = client_->redirect();
|
||||
const bool was_established = established_;
|
||||
snapshot_bytes_ += client_->snapshot_bytes();
|
||||
for (const auto& p : pending_)
|
||||
@@ -490,6 +578,30 @@ class RemoteSession {
|
||||
predictor_.reset(); // The marker ended with its session.
|
||||
client_.reset();
|
||||
established_ = false;
|
||||
// A crossing or a redirect is followed at once: no grant for a handoff, no pause.
|
||||
if (reason == SessionCloseReason::handed_off && offer && learn_route(offer->destination)) {
|
||||
ticket_ = offer->ticket;
|
||||
target_region_ = offer->destination.region;
|
||||
handing_off_ = true;
|
||||
++handoffs_;
|
||||
stale_view_ = false; // A switch, not a loss: the view stays as it was.
|
||||
launcher.observe(client::ConnectSignal::not_ready);
|
||||
notify(ui, "Crossing into a neighbouring region.", client::NoticeLevel::info);
|
||||
std::printf("session handoff region=%llu\n",
|
||||
static_cast<unsigned long long>(target_region_));
|
||||
retry_at_ = now;
|
||||
return;
|
||||
}
|
||||
if (reason == SessionCloseReason::moved && redirect && learn_route(*redirect)) {
|
||||
target_region_ = redirect->region;
|
||||
launcher.observe(client::ConnectSignal::not_ready);
|
||||
notify(ui, "Your probe is in another region; connecting there.",
|
||||
client::NoticeLevel::info);
|
||||
std::printf("session redirect region=%llu\n",
|
||||
static_cast<unsigned long long>(target_region_));
|
||||
retry_at_ = now;
|
||||
return;
|
||||
}
|
||||
const bool not_ready =
|
||||
reason == SessionCloseReason::shutdown || reason == SessionCloseReason::capacity;
|
||||
const bool lost = reason == SessionCloseReason::connection_lost ||
|
||||
@@ -517,7 +629,11 @@ class RemoteSession {
|
||||
}
|
||||
network::quic::ClientConfig transport_;
|
||||
std::vector<network::WireGrant> grants_;
|
||||
std::size_t next_{};
|
||||
std::vector<bool> used_;
|
||||
std::map<std::uint64_t, network::quic::ClientConfig> routes_; // Region -> how to dial it.
|
||||
std::uint64_t target_region_{}, region_{}, handoffs_{}, newest_serial_{};
|
||||
std::optional<network::WireGrant> ticket_; // A handoff ticket for the next connection.
|
||||
bool handing_off_{};
|
||||
std::unique_ptr<client::RegionSessionClient> client_;
|
||||
client::EnvironmentLayer environment_;
|
||||
client::OrganismLayer organisms_;
|
||||
|
||||
@@ -9,23 +9,29 @@
|
||||
// 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).
|
||||
// M10.6 (ADR-0094): sessions' probe markers move within the habitat sites' bounding cells.
|
||||
// M10.6 (ADR-0094): sessions' probe markers move within the habitat sites' bounding cells,
|
||||
// or within --m10-area. M10.8c (ADR-0096): with --m10-handoff-key, markers are durable probe
|
||||
// records and a marker crossing into a --m10-neighbour's area is handed over with a ticket.
|
||||
#include "evo/persistence/postgres.hpp"
|
||||
#include "evo/persistence/region_lease.hpp"
|
||||
#include <cstdint>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#ifdef EVO_SERVER_M10
|
||||
#include "evo/client/environment_view.hpp"
|
||||
#include "evo/network/handoff_ticket.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/postgres_handoff_ledger.hpp"
|
||||
#include "evo/server/region_host.hpp"
|
||||
#include "evo/server/region_sessions.hpp"
|
||||
#include "evo/server/session_window.hpp"
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <charconv>
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
@@ -33,6 +39,9 @@
|
||||
#include <iterator>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <span>
|
||||
#include <string_view>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#endif
|
||||
|
||||
@@ -41,9 +50,15 @@ 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{};
|
||||
// M10.8c (ADR-0096, dev only): this region's marker area in cells "X0,Y0,X1,Y1"
|
||||
// (inclusive), its handoff key (32-byte P-256 scalar; key id = region id) and up to 8
|
||||
// neighbours "REGION=X0,Y0,X1,Y1=HOST:PORT=SERVER_NAME=PUBLIC_KEY_FILE".
|
||||
std::string area, handoff_key;
|
||||
std::vector<std::string> neighbours;
|
||||
[[nodiscard]] bool any() const noexcept {
|
||||
return !listen.empty() || !certificate.empty() || !key.empty() || !issuer.empty() ||
|
||||
!environment.empty() || !session_window.empty() || max_grant_lifetime != 0;
|
||||
!environment.empty() || !session_window.empty() || max_grant_lifetime != 0 ||
|
||||
!area.empty() || !handoff_key.empty() || !neighbours.empty();
|
||||
}
|
||||
[[nodiscard]] bool complete() const noexcept {
|
||||
return !listen.empty() && !certificate.empty() && !key.empty() && !issuer.empty() &&
|
||||
@@ -95,6 +110,13 @@ template <typename Host> class M10Bridge {
|
||||
return fail("error m10-grant-lifetime");
|
||||
config.control.max_grant_lifetime = o.max_grant_lifetime;
|
||||
}
|
||||
std::optional<std::array<std::int64_t, 4>> area_cells;
|
||||
if (!o.area.empty() && !(area_cells = cells_of(o.area)))
|
||||
return fail("error m10-area");
|
||||
if ((!o.handoff_key.empty() || !o.neighbours.empty()) &&
|
||||
(config.control.environment != network::DeploymentEnvironment::dev ||
|
||||
o.handoff_key.empty() || o.neighbours.empty() || !area_cells))
|
||||
return fail("error m10-handoff"); // Dev only; key, neighbours and area together.
|
||||
config.control.world = {key.world, frame};
|
||||
config.control.region = key.region;
|
||||
config.control.epoch = 1; // Follows the host's epoch from the first poll.
|
||||
@@ -111,6 +133,33 @@ template <typename Host> class M10Bridge {
|
||||
bridge.actions_ = std::make_unique<server::PostgresActionLedger>(*bridge.slot_, key, lease);
|
||||
config.ledger = bridge.control_.get();
|
||||
config.actions = bridge.actions_.get();
|
||||
bridge.area_cells_ = area_cells;
|
||||
if (!o.handoff_key.empty()) {
|
||||
const auto scalar = read(o.handoff_key);
|
||||
auto signer = network::HandoffSigningKey::import(
|
||||
config.control.environment, static_cast<std::uint32_t>(key.region),
|
||||
std::span{reinterpret_cast<const std::uint8_t*>(scalar.data()), scalar.size()});
|
||||
if (!signer)
|
||||
return fail("error m10-handoff-key");
|
||||
config.handoff_key =
|
||||
std::make_shared<const network::HandoffSigningKey>(std::move(*signer));
|
||||
for (const auto& spec : o.neighbours) {
|
||||
auto n = neighbour_of(spec);
|
||||
if (!n || n->first.address.region == key.region)
|
||||
return fail("error m10-neighbour");
|
||||
config.handoff_keys.push_back({n->first.address.region,
|
||||
static_cast<std::uint32_t>(n->first.address.region),
|
||||
n->second});
|
||||
config.neighbours.push_back(std::move(n->first));
|
||||
}
|
||||
bridge.probes_ =
|
||||
std::make_unique<server::PostgresProbeLedger>(*bridge.slot_, key, lease);
|
||||
bridge.handoff_ =
|
||||
std::make_unique<server::PostgresHandoffLedger>(*bridge.slot_, key, lease);
|
||||
config.probes = bridge.probes_.get();
|
||||
config.handoff = bridge.handoff_.get();
|
||||
std::printf("m10 handoff neighbours=%zu\n", config.neighbours.size());
|
||||
}
|
||||
auto sessions = server::RegionSessions::create(std::move(config));
|
||||
if (!sessions)
|
||||
return fail(sessions.error() == server::RegionSessionsError::keys ? "error m10-issuer"
|
||||
@@ -204,6 +253,18 @@ template <typename Host> class M10Bridge {
|
||||
constexpr auto cell = network::motion::micrometres_per_cell;
|
||||
network::motion::Area area{first.x * cell, first.y * cell, (first.x * cell) + cell - 1,
|
||||
(first.y * cell) + cell - 1, first.z};
|
||||
if (area_cells_) { // --m10-area: this region's cells, inclusive.
|
||||
const auto& c = *area_cells_;
|
||||
area = {c[0] * cell, c[1] * cell, (c[2] * cell) + cell - 1, (c[3] * cell) + cell - 1,
|
||||
first.z};
|
||||
if (sessions_->set_motion_area(area, ((c[0] + c[2] + 1) * cell) / 2,
|
||||
((c[1] + c[3] + 1) * cell) / 2))
|
||||
std::printf("m10 motion area %lld %lld %lld %lld z=%lld\n",
|
||||
static_cast<long long>(area.min_x), static_cast<long long>(area.min_y),
|
||||
static_cast<long long>(area.max_x), static_cast<long long>(area.max_y),
|
||||
static_cast<long long>(area.z));
|
||||
return;
|
||||
}
|
||||
for (const auto& site : sites)
|
||||
if (site.voxel.z == first.z) {
|
||||
area.min_x = std::min(area.min_x, site.voxel.x * cell);
|
||||
@@ -249,6 +310,53 @@ template <typename Host> class M10Bridge {
|
||||
src.environment.assign(cells->cells().begin(), cells->cells().end());
|
||||
return src;
|
||||
}
|
||||
// "X0,Y0,X1,Y1" in cells, X0 <= X1 and Y0 <= Y1, each within +-2^40.
|
||||
static std::optional<std::array<std::int64_t, 4>> cells_of(std::string_view text) {
|
||||
std::array<std::int64_t, 4> v{};
|
||||
for (std::size_t i = 0; i < v.size(); ++i) {
|
||||
const auto comma = text.find(',');
|
||||
const auto part = text.substr(0, comma);
|
||||
const auto [end, ec] = std::from_chars(part.data(), part.data() + part.size(), v.at(i));
|
||||
if (ec != std::errc{} || end != part.data() + part.size() ||
|
||||
(comma == std::string_view::npos) != (i + 1 == v.size()) ||
|
||||
v.at(i) < -(std::int64_t{1} << 40) || v.at(i) > (std::int64_t{1} << 40))
|
||||
return std::nullopt;
|
||||
text.remove_prefix(comma == std::string_view::npos ? text.size() : comma + 1);
|
||||
}
|
||||
if (v[0] > v[2] || v[1] > v[3])
|
||||
return std::nullopt;
|
||||
return v;
|
||||
}
|
||||
// "REGION=X0,Y0,X1,Y1=HOST:PORT=SERVER_NAME=PUBLIC_KEY_FILE".
|
||||
static std::optional<std::pair<server::Neighbour, network::GrantPublicKey>>
|
||||
neighbour_of(std::string_view spec) {
|
||||
std::array<std::string_view, 5> part{};
|
||||
for (std::size_t i = 0; i < part.size(); ++i) {
|
||||
const auto eq = spec.find('=');
|
||||
if ((eq == std::string_view::npos) != (i + 1 == part.size()))
|
||||
return std::nullopt;
|
||||
part.at(i) = spec.substr(0, eq);
|
||||
spec.remove_prefix(eq == std::string_view::npos ? spec.size() : eq + 1);
|
||||
}
|
||||
std::uint64_t region = 0;
|
||||
if (const auto [end, ec] =
|
||||
std::from_chars(part[0].data(), part[0].data() + part[0].size(), region);
|
||||
ec != std::errc{} || end != part[0].data() + part[0].size() || region == 0)
|
||||
return std::nullopt;
|
||||
const auto cells = cells_of(part[1]);
|
||||
const auto key = read(std::string{part[4]});
|
||||
if (!cells || part[2].empty() || part[3].empty() || part[2].size() > 64 ||
|
||||
part[3].size() > 64 || key.size() != network::grant_public_key_bytes)
|
||||
return std::nullopt;
|
||||
constexpr auto cell = network::motion::micrometres_per_cell;
|
||||
const auto& c = *cells;
|
||||
server::Neighbour n{
|
||||
{region, std::string{part[2]}, std::string{part[3]}},
|
||||
{c[0] * cell, c[1] * cell, (c[2] * cell) + cell - 1, (c[3] * cell) + cell - 1, 0}};
|
||||
network::GrantPublicKey pub{};
|
||||
std::copy(key.begin(), key.end(), pub.begin());
|
||||
return std::pair{std::move(n), pub};
|
||||
}
|
||||
static network::CarriedAction carried(const persistence::ActionRecord& r) {
|
||||
network::CarriedAction a;
|
||||
a.account.bytes = r.account;
|
||||
@@ -275,6 +383,9 @@ template <typename Host> class M10Bridge {
|
||||
std::unique_ptr<server::PgSlot> slot_;
|
||||
std::unique_ptr<server::PostgresControlLedger> control_;
|
||||
std::unique_ptr<server::PostgresActionLedger> actions_;
|
||||
std::unique_ptr<server::PostgresProbeLedger> probes_; // Handoff mode only.
|
||||
std::unique_ptr<server::PostgresHandoffLedger> handoff_; // Handoff mode only.
|
||||
std::optional<std::array<std::int64_t, 4>> area_cells_;
|
||||
std::unique_ptr<server::RegionSessions> sessions_; // Destroyed first: uses the ledgers.
|
||||
std::optional<server::SessionWindow> window_;
|
||||
bool window_closed_{};
|
||||
|
||||
@@ -231,6 +231,12 @@ std::optional<Options> parse(int argc, char** argv) {
|
||||
o.m10.session_window = value;
|
||||
else if (flag == "--m10-max-grant-lifetime" && n && *n >= 60 && *n <= 3600)
|
||||
o.m10.max_grant_lifetime = *n;
|
||||
else if (flag == "--m10-area")
|
||||
o.m10.area = value;
|
||||
else if (flag == "--m10-handoff-key")
|
||||
o.m10.handoff_key = value;
|
||||
else if (flag == "--m10-neighbour" && o.m10.neighbours.size() < 8)
|
||||
o.m10.neighbours.emplace_back(value);
|
||||
else if (flag == "--crash-at") {
|
||||
const auto colon = value.find(':');
|
||||
const auto ordinal =
|
||||
@@ -596,7 +602,9 @@ int main(int argc, char** argv) {
|
||||
"--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..3600]]\n",
|
||||
"[--m10-max-grant-lifetime 60..3600] [--m10-area X0,Y0,X1,Y1] "
|
||||
"[--m10-handoff-key F [--m10-neighbour "
|
||||
"REGION=X0,Y0,X1,Y1=HOST:PORT=NAME=PUBFILE]...]]\n",
|
||||
stderr);
|
||||
return 2;
|
||||
}
|
||||
|
||||
@@ -11,6 +11,10 @@
|
||||
// account supersedes an earlier one without bookkeeping. The file is created new and
|
||||
// owner-only (a credential: never commit or share it); the issuer key stays here.
|
||||
// The region refuses grants longer than its --m10-max-grant-lifetime (default 300).
|
||||
// M10.8c (ADR-0096): --region may repeat; COUNT grants are written per region,
|
||||
// interleaved in serial order, so a client crossing between regions always has a newer
|
||||
// serial for the next one (serials must rise world-wide). A handoff key is a key pair
|
||||
// from `keys` (issuer.key for --m10-handoff-key, issuer.pub for --m10-neighbour).
|
||||
// evo-session-probe run --connect HOST:PORT --server-name NAME --ca FILE --issuer-key FILE
|
||||
// --world N --frame N --region N --account HEX32 --serial N [--lifetime S]
|
||||
// [--intents N] [--actions N --action-base ID] [--query ID]... [--timeout-ms N]
|
||||
@@ -25,6 +29,7 @@
|
||||
// --snapshots N waits for N; --interest asks for another focus than the default)
|
||||
// marker TICK X Y APPLIED (the session's own probe marker in each new snapshot: um
|
||||
// position after TICK and the newest applied intention sequence; ADR-0094)
|
||||
// handoff REGION ENDPOINT | redirect REGION ENDPOINT (v4, ADR-0096; then closed)
|
||||
// closed REASON TRANSPORT (TRANSPORT names why QUIC ended: untrusted means the server
|
||||
// answered but failed the pinned CA/name check; idle means nothing answered)
|
||||
// Statuses, results and reasons are the session-v1 wire values. Exits 0 once every
|
||||
@@ -162,6 +167,7 @@ struct RunOptions {
|
||||
action_base{1}, timeout_ms{20000};
|
||||
std::optional<AccountId> account;
|
||||
std::vector<std::uint64_t> queries;
|
||||
std::vector<std::uint64_t> more_regions; // grants: further --region values.
|
||||
std::optional<SessionInterest> interest;
|
||||
std::uint64_t snapshots{};
|
||||
};
|
||||
@@ -202,20 +208,29 @@ int grants(const RunOptions& o, const std::string& out, std::uint64_t count) {
|
||||
GrantClaims claims;
|
||||
claims.account = *o.account;
|
||||
claims.world = {o.world, o.frame};
|
||||
claims.region = o.region;
|
||||
claims.issued_at = now_seconds();
|
||||
claims.expires_at = claims.issued_at + o.lifetime;
|
||||
const auto first = o.serial != 0 ? o.serial : claims.issued_at * 64;
|
||||
std::vector<std::uint8_t> bundle;
|
||||
for (std::uint64_t i = 0; i < count; ++i) {
|
||||
claims.serial = first + i;
|
||||
const auto grant = sign(*key, claims);
|
||||
if (!grant) {
|
||||
std::puts("error grant");
|
||||
return 2;
|
||||
}
|
||||
bundle.insert(bundle.end(), grant->begin(), grant->end());
|
||||
std::vector<std::uint64_t> regions{o.region};
|
||||
regions.insert(regions.end(), o.more_regions.begin(), o.more_regions.end());
|
||||
if (count * regions.size() > 64) {
|
||||
std::puts("error count (at most 64 grants in all)");
|
||||
return 2;
|
||||
}
|
||||
std::vector<std::uint8_t> bundle;
|
||||
std::uint64_t serial = first;
|
||||
for (std::uint64_t i = 0; i < count; ++i)
|
||||
for (const auto region : regions) {
|
||||
claims.region = region;
|
||||
claims.serial = serial++;
|
||||
const auto grant = sign(*key, claims);
|
||||
if (!grant) {
|
||||
std::puts("error grant");
|
||||
return 2;
|
||||
}
|
||||
bundle.insert(bundle.end(), grant->begin(), grant->end());
|
||||
}
|
||||
count *= regions.size();
|
||||
if (!write_new(out, bundle)) {
|
||||
std::puts("error out (exists or unwritable)");
|
||||
return 1;
|
||||
@@ -277,6 +292,13 @@ int run(const RunOptions& o) {
|
||||
while (Clock::now() < deadline) {
|
||||
c.poll(Clock::now());
|
||||
if (c.state() == client::RegionSessionState::closed) {
|
||||
if (const auto offer = c.take_handoff())
|
||||
std::printf("handoff %llu %s\n",
|
||||
static_cast<unsigned long long>(offer->destination.region),
|
||||
offer->destination.endpoint.c_str());
|
||||
if (const auto& to = c.redirect())
|
||||
std::printf("redirect %llu %s\n", static_cast<unsigned long long>(to->region),
|
||||
to->endpoint.c_str());
|
||||
std::printf("closed %u %s\n",
|
||||
static_cast<unsigned>(
|
||||
c.close_reason().value_or(SessionCloseReason::connection_lost)),
|
||||
@@ -410,6 +432,8 @@ int main(int argc, char** argv) {
|
||||
o.world = *n;
|
||||
else if (n && flag == "--frame")
|
||||
o.frame = *n;
|
||||
else if (n && *n != 0 && flag == "--region" && bundle && o.region != 0)
|
||||
o.more_regions.push_back(*n);
|
||||
else if (n && flag == "--region")
|
||||
o.region = *n;
|
||||
else if (n && flag == "--serial")
|
||||
|
||||
@@ -12,7 +12,7 @@ spec:
|
||||
env:
|
||||
- {name: REGION_SESSION, value: "dev"}
|
||||
- {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"}
|
||||
- {name: REGION_SESSION_WINDOW, value: "dev-20261007T011838-10712:1791337118"}
|
||||
- {name: REGION_SESSION_WINDOW, value: "dev-20261007T015045-2140:1791339045"}
|
||||
ports:
|
||||
# QUIC (ADR-0090): UDP only; nothing listens on TCP 7400.
|
||||
- {name: session, containerPort: 7400, protocol: UDP}
|
||||
|
||||
+2
-1
@@ -538,7 +538,8 @@ handoff ADR; EXPERIMENT durable probe records): 10.8a schema v12 probe records a
|
||||
transfer state machine with a PostgreSQL fault matrix done; 10.8b signed handoff tickets and
|
||||
ticket admission (durable stage, commit and control move) done; 10.8c-1 session protocol v4,
|
||||
durable probes in sessions, edge crossing, ghosts (schema v13) and a two-region loopback test
|
||||
done; 10.8c-2 client switch and server configuration, 10.8d two-process kill tests follow. 10.9 planned.
|
||||
done; 10.8c-2 client switch (offers, redirects, multi-region grants) and evo-server/probe
|
||||
configuration done; 10.8d two-process kill tests follow. 10.9 planned.
|
||||
|
||||
**Entry:** M9 client/session evidence and M7/M8 dev/stage durability. Read
|
||||
NETWORK_ARCHITECTURE, PERSISTENCE_ARCHITECTURE and ADR-0017. The M9 transport is
|
||||
|
||||
+4
-1
@@ -84,7 +84,10 @@ the session. M10.8c-1 wires the regions:
|
||||
- the destination shows arriving probes as ghosts (schema v13) and opens the marker where it
|
||||
crossed.
|
||||
|
||||
Next: 10.8c-2, the client switch and server configuration.
|
||||
M10.8c-2 has the engineering client follow crossings (ticket, no loading screen) and
|
||||
redirects, with grants picked by region in rising serial order. evo-server gains
|
||||
`--m10-area`, `--m10-handoff-key` and `--m10-neighbour`; the probe tool writes multi-region
|
||||
bundles. Next: 10.8d, two evo-server processes on PostgreSQL with kills at each step.
|
||||
|
||||
## Previous gate - 2026-10-02
|
||||
|
||||
|
||||
@@ -187,3 +187,36 @@ controllable before M11.
|
||||
It passed 3 times in a row on Linux and also passes on Windows.
|
||||
- Not yet: the engineering client's switch (offer, redirect, multi-region grants),
|
||||
evo-server and probe configuration (10.8c-2), and real processes on PostgreSQL (10.8d).
|
||||
|
||||
## M10.8c-2 client switch and configuration (2026-10-06)
|
||||
- **Engineering client** (`apps/evo-client/remote_session.hpp`):
|
||||
- On `Close(handed_off)` after a HandoffOffer it learns the destination's address (one
|
||||
lookup), keeps the frozen view, uses no grant and connects at once with the ticket. The
|
||||
panel shows "handing off", then the region and the count of crossings.
|
||||
- On `Close(moved)` after a Redirect it connects to the owner with a grant for that
|
||||
region.
|
||||
- Grants are picked by their region claim. They are used in rising serial order
|
||||
world-wide (durable control refuses a serial not above the newest), and a grant
|
||||
outdated by one already used is discarded.
|
||||
- A new region or epoch resets the views.
|
||||
- **evo-server** (dev only, with the M10 listener):
|
||||
- `--m10-area X0,Y0,X1,Y1`: the region's cells.
|
||||
- `--m10-handoff-key FILE`: this region's P-256 scalar; the key id is the region id.
|
||||
- `--m10-neighbour REGION=X0,Y0,X1,Y1=HOST:PORT=SERVER_NAME=PUBLIC_KEY_FILE`: up to 8;
|
||||
the neighbour's key id is its region id.
|
||||
|
||||
A handoff key needs neighbours and an area, and runs with the PostgreSQL probe and
|
||||
handoff ledgers on the host's connection slot. Without these flags behaviour is as
|
||||
before (in-memory markers).
|
||||
- **Probe tool:**
|
||||
- `grants` accepts `--region` several times (COUNT per region, serials interleaved in
|
||||
order);
|
||||
- `keys` makes handoff key pairs too;
|
||||
- `run` prints `handoff` and `redirect` lines.
|
||||
- **Evidence:**
|
||||
- `client-remote-session`: the GUI session crosses into region 2 with the ticket (no
|
||||
grant used, connected, marker past the border, probe owned there); a second client
|
||||
with a newer bundle logging in at region 1 is redirected and takes over at region 2.
|
||||
It passed 3 times in a row on Linux and also passes on Windows.
|
||||
- The test fixture `tests/fixtures/fake_handoff_world.hpp` (the v12 state machine) is
|
||||
shared by both handoff tests.
|
||||
|
||||
@@ -4823,3 +4823,38 @@ Not done:
|
||||
|
||||
Deployed v3 servers refuse v4 clients until redeployed; v12 and v13 need a rebuilt
|
||||
migrations image.
|
||||
|
||||
## 2026-10-06 — M10.8c-2 client switch and handoff configuration (ADR-0096)
|
||||
|
||||
Implemented:
|
||||
- the engineering client follows handoff offers (ticket, no grant, no pause, view kept) and
|
||||
redirects;
|
||||
- grants are picked by region claim in rising serial order, and outdated grants are
|
||||
discarded;
|
||||
- views reset on a new region;
|
||||
- evo-server `--m10-area`, `--m10-handoff-key` and `--m10-neighbour` (dev only), wiring the
|
||||
PostgreSQL probe and handoff ledgers;
|
||||
- the probe tool's multi-region `grants` and its `handoff`/`redirect` lines;
|
||||
- the shared fixture `tests/fixtures/fake_handoff_world.hpp`.
|
||||
|
||||
Tests:
|
||||
- `client-remote-session` `crossing_regions`:
|
||||
- the GUI session walks into region 2 and continues there with the ticket (no grant used,
|
||||
connected, marker past the border, probe owned by region 2);
|
||||
- a second client's login at region 1 is redirected to region 2 and takes over.
|
||||
|
||||
It passed 3 times in a row on Linux, plus once more after a tidy fix.
|
||||
|
||||
Executed:
|
||||
- **Linux GCC 14:**
|
||||
- `postgres-check.sh` with QUIC: 21 suites;
|
||||
- presets `quic` 4/4 and `client-network` 16/16.
|
||||
- **Linux Clang 19:** clang-tidy 19 on the client app, panels, remote test, probe, QUIC
|
||||
session test and evo-server `main.cpp` with the bridge (one finding fixed); clang-format
|
||||
19.
|
||||
- **Windows MSVC 19.44:** presets `quic` 4/4 and `client-network` 14/14.
|
||||
|
||||
Not done:
|
||||
- real two-process handoffs on PostgreSQL with kills (10.8d);
|
||||
- a GUI run across regions on evolution-dev (one dev region only; needs v4 and v13
|
||||
deployed).
|
||||
|
||||
@@ -41,5 +41,23 @@ evo-client --connect void.aeternalisgames.com:7400 --server-name NAME --ca dev-c
|
||||
until the reconnect brings a fresh view. Nothing you press is sent meanwhile.
|
||||
- Each reconnect uses the next grant. A second client with a bundle for the same account
|
||||
takes the session over; the first stops (do not share bundles).
|
||||
- A server on an older session protocol (v1, v2) refuses the client
|
||||
(`unsupported_version`): deploy a v3 server first.
|
||||
- A server on an older session protocol (v1-v3) refuses the client
|
||||
(`unsupported_version`): deploy a v4 server first.
|
||||
|
||||
## Two regions (M10.8, ADR-0096, EXPERIMENT)
|
||||
|
||||
Regions with adjacent areas hand a probe over when it walks across the edge. The client
|
||||
follows on its own: the view stays on screen, no grant is used, and the Session panel
|
||||
counts the crossings. Each region needs:
|
||||
- `--m10-area X0,Y0,X1,Y1` (its cells);
|
||||
- `--m10-handoff-key issuer.key` (a pair from `evo-session-probe keys`);
|
||||
- one `--m10-neighbour REGION=X0,Y0,X1,Y1=HOST:PORT=SERVER_NAME=neighbour.pub` per
|
||||
neighbour.
|
||||
|
||||
All of them need schema v13. Issue bundles with one `--region` per region:
|
||||
|
||||
```sh
|
||||
evo-session-probe grants --issuer-key issuer.key --world 100 --frame 9 --region 1 --region 2 --account <hex> --count 8 --lifetime 3600 --out tester.grants
|
||||
```
|
||||
|
||||
A login at a region that does not own the probe is redirected to the one that does.
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
#include "evo/network/dev_credentials.hpp"
|
||||
#include "evo/network/session_grant.hpp"
|
||||
#include "evo/server/region_sessions.hpp"
|
||||
#include "fixtures/fake_handoff_world.hpp"
|
||||
#include "remote_session.hpp"
|
||||
#include <algorithm>
|
||||
#include <chrono>
|
||||
@@ -13,6 +14,7 @@
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <source_location>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
@@ -327,6 +329,131 @@ void refusals(Region& r) {
|
||||
CHECK(!RemoteSession::open(bad));
|
||||
CHECK(!RemoteSession::open(r.material({})));
|
||||
}
|
||||
// M10.8c-2 (ADR-0096): the client follows a crossing into the next region with the offer's
|
||||
// ticket (no grant, no pause, the view kept) and follows a redirect at login, picking grants
|
||||
// by region from a two-region bundle in rising serial order.
|
||||
void crossing_regions(const Files& f) {
|
||||
using evo::test::RegionDb;
|
||||
using evo::test::WorldDb;
|
||||
constexpr std::int64_t m = 1'000'000;
|
||||
const auto area = [](std::int64_t x0) {
|
||||
return network::motion::Area{x0, 0, x0 + (10 * m) - 1, (10 * m) - 1, 0};
|
||||
};
|
||||
WorldDb world;
|
||||
RegionDb db1{world, 1}, db2{world, 2};
|
||||
auto key1 = std::make_shared<const HandoffSigningKey>(
|
||||
*HandoffSigningKey::generate(DeploymentEnvironment::dev, 41));
|
||||
auto key2 = std::make_shared<const HandoffSigningKey>(
|
||||
*HandoffSigningKey::generate(DeploymentEnvironment::dev, 42));
|
||||
auto imported = GrantSigningKey::import(DeploymentEnvironment::dev, 1, scalar());
|
||||
CHECK(imported.has_value());
|
||||
const auto& issuer = *imported;
|
||||
const auto make = [&](std::uint64_t id, RegionDb& db,
|
||||
std::shared_ptr<const HandoffSigningKey> own,
|
||||
const HandoffSigningKey& neighbour_key, std::uint64_t neighbour,
|
||||
std::uint16_t neighbour_port, std::uint16_t port) {
|
||||
server::RegionSessionsConfig c;
|
||||
c.transport.certificate_pem_file = f.certificate.string();
|
||||
c.transport.key_pem_file = f.key.string();
|
||||
c.transport.port = port;
|
||||
c.control.environment = DeploymentEnvironment::dev;
|
||||
c.control.world = world_id;
|
||||
c.control.region = id;
|
||||
c.control.epoch = 3;
|
||||
c.control.max_account_attempts = 16;
|
||||
c.issuer_keys.push_back({1, *issuer.public_key()});
|
||||
c.ledger = &db;
|
||||
c.handoff = &db;
|
||||
c.probes = &db;
|
||||
c.handoff_key = std::move(own);
|
||||
c.handoff_keys.push_back(
|
||||
{neighbour, static_cast<std::uint32_t>(neighbour + 40), *neighbour_key.public_key()});
|
||||
c.neighbours.push_back(
|
||||
{{neighbour, "localhost:" + std::to_string(neighbour_port), std::string{name}},
|
||||
area(neighbour == 1 ? 0 : 10 * m)});
|
||||
c.ghost_poll = std::chrono::milliseconds{20};
|
||||
auto made = server::RegionSessions::create(std::move(c));
|
||||
CHECK(made.has_value());
|
||||
const auto x0 = id == 1 ? 0 : 10 * m;
|
||||
CHECK((*made)->set_motion_area(area(x0), x0 + (5 * m), 5 * m));
|
||||
(*made)->set_default_interest({(x0 / m) + 5, 5, 0, 7});
|
||||
return std::move(*made);
|
||||
};
|
||||
// Region 2 listens on a port found by binding a throwaway region first.
|
||||
std::uint16_t port2 = 0;
|
||||
{
|
||||
auto probe = make(2, db2, key2, *key1, 1, 1, 0);
|
||||
port2 = probe->port();
|
||||
}
|
||||
auto r1 = make(1, db1, key1, *key2, 2, port2, 0);
|
||||
auto r2 = make(2, db2, key2, *key1, 1, r1->port(), port2);
|
||||
std::uint64_t tick = 100;
|
||||
const auto grants = [&](const AccountId& who, std::uint64_t first) {
|
||||
std::vector<WireGrant> out;
|
||||
for (std::uint64_t i = 0; i < 4; ++i) {
|
||||
GrantClaims c;
|
||||
c.grant_id = 5000 + first + i;
|
||||
c.account = who;
|
||||
c.serial = first + i;
|
||||
c.world = world_id;
|
||||
c.region = (i % 2) + 1; // Interleaved: region 1, 2, 1, 2.
|
||||
c.issued_at = start;
|
||||
c.expires_at = start + 120;
|
||||
out.push_back(*issuer.sign(c));
|
||||
}
|
||||
return out;
|
||||
};
|
||||
const auto material = [&](std::vector<WireGrant> g) {
|
||||
return client::ConnectMaterial{
|
||||
{"localhost", r1->port()}, std::string{name}, f.ca_pem, f.ca.string(), std::move(g)};
|
||||
};
|
||||
const auto pump = [&](const std::vector<Client*>& clients, const std::function<bool()>& done) {
|
||||
const auto end = Clock::now() + std::chrono::seconds{20};
|
||||
for (int i = 1; Clock::now() < end; ++i) {
|
||||
if (i % 5 == 0)
|
||||
++tick;
|
||||
for (auto* r : {r1.get(), r2.get()}) {
|
||||
r->poll({true, 3, tick}, start + 1, Clock::now());
|
||||
r->replicate(tick, [](const SessionInterest&) {
|
||||
ReplicationSource s;
|
||||
s.identity = world_id;
|
||||
return s;
|
||||
});
|
||||
static_cast<void>(r->take_events());
|
||||
}
|
||||
for (auto* c : clients)
|
||||
c->host.step(Clock::now(), c->intention, c->ui);
|
||||
if (done())
|
||||
return true;
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds{2});
|
||||
}
|
||||
return done();
|
||||
};
|
||||
const auto dana = account(31);
|
||||
Client a;
|
||||
CHECK(a.host.connect(RemoteSession::open(material(grants(dana, 10)))));
|
||||
auto& s = *a.host.session();
|
||||
CHECK(pump({&a}, [&] { return s.status().phase == "connected" && s.status().marker; }));
|
||||
CHECK(s.status().region == 1 && s.status().marker_x_mm == 5000);
|
||||
// Walking east: the crossing is followed into region 2 with the ticket, no grant used.
|
||||
a.intention.move_x = 1000;
|
||||
const auto left = s.status().grants_left;
|
||||
CHECK(pump({&a}, [&] {
|
||||
const auto st = s.status();
|
||||
return st.region == 2 && st.phase == "connected" && st.handoffs == 1 && st.marker;
|
||||
}));
|
||||
CHECK(s.status().grants_left == left && a.phase() == LaunchPhase::connected &&
|
||||
world.probes.at(dana).owner == 2 && s.status().marker_x_mm >= 10'000);
|
||||
a.intention.move_x = 0;
|
||||
// A second client with a newer bundle logs in at region 1 and is redirected to region 2,
|
||||
// where it takes over (the first is superseded).
|
||||
Client b;
|
||||
CHECK(b.host.connect(RemoteSession::open(material(grants(dana, 20)))));
|
||||
auto& t = *b.host.session();
|
||||
CHECK(
|
||||
pump({&a, &b}, [&] { return t.status().region == 2 && t.status().phase == "connected"; }));
|
||||
CHECK(a.phase() == LaunchPhase::failed && world.probes.at(dana).owner == 2);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main() try {
|
||||
@@ -337,6 +464,7 @@ int main() try {
|
||||
remote_markers(r);
|
||||
refusals(r);
|
||||
}
|
||||
crossing_regions(files);
|
||||
std::filesystem::remove_all(files.dir);
|
||||
std::puts("client remote session tests passed");
|
||||
return 0;
|
||||
|
||||
+119
@@ -0,0 +1,119 @@
|
||||
#pragma once
|
||||
// M10.8c test fixture (ADR-0096): a fake world database with the same probe transfer state
|
||||
// machine as schema v12 (prepared -> committed or aborted; stage and commit happen together
|
||||
// at the ticket login), serving one region's ProbeLedger, HandoffLedger and ControlLedger.
|
||||
#include "evo/network/handoff_ticket.hpp"
|
||||
#include "evo/network/session_control.hpp"
|
||||
#include "evo/server/probe_ledger.hpp"
|
||||
#include <chrono>
|
||||
#include <cstdint>
|
||||
#include <expected>
|
||||
#include <map>
|
||||
#include <optional>
|
||||
#include <vector>
|
||||
|
||||
namespace evo::test {
|
||||
using network::AccountId;
|
||||
using network::ControlLease;
|
||||
using network::ControlLedger;
|
||||
using network::ControlLedgerError;
|
||||
using network::HandoffAdmission;
|
||||
using network::HandoffLedger;
|
||||
using network::HandoffLedgerError;
|
||||
using network::TicketClaims;
|
||||
using network::TransferId;
|
||||
struct WorldDb {
|
||||
struct Probe {
|
||||
std::uint64_t owner{}, generation{};
|
||||
std::int64_t x{}, y{};
|
||||
std::optional<TransferId> transfer;
|
||||
};
|
||||
enum class State : std::uint8_t { prepared, committed, aborted };
|
||||
struct Transfer {
|
||||
AccountId account;
|
||||
std::uint64_t source{}, destination{}, generation{};
|
||||
std::int64_t x{}, y{};
|
||||
State state{};
|
||||
};
|
||||
std::map<AccountId, Probe> probes;
|
||||
std::map<TransferId, Transfer> transfers;
|
||||
};
|
||||
struct RegionDb final : server::ProbeLedger, HandoffLedger, ControlLedger {
|
||||
RegionDb(WorldDb& w, std::uint64_t r) : world{&w}, region{r} {}
|
||||
std::expected<server::ProbeHome, server::ProbeLedgerError>
|
||||
open(const AccountId& account, std::int64_t x, std::int64_t y, std::int64_t) override {
|
||||
auto [it, created] =
|
||||
world->probes.try_emplace(account, WorldDb::Probe{region, 1, x, y, std::nullopt});
|
||||
const auto& p = it->second;
|
||||
return server::ProbeHome{p.owner, p.generation, p.x, p.y, p.transfer.has_value()};
|
||||
}
|
||||
void save(const AccountId& account, std::uint64_t generation, std::int64_t x, std::int64_t y,
|
||||
std::int64_t) override {
|
||||
auto& p = world->probes.at(account);
|
||||
if (p.owner == region && p.generation == generation && !p.transfer) {
|
||||
p.x = x;
|
||||
p.y = y;
|
||||
++saves;
|
||||
}
|
||||
}
|
||||
std::expected<void, server::ProbeLedgerError>
|
||||
prepare(const AccountId& account, std::uint64_t generation, const TransferId& transfer,
|
||||
std::uint64_t destination, std::int64_t x, std::int64_t y, std::int64_t) override {
|
||||
auto& p = world->probes.at(account);
|
||||
if (p.owner != region || p.generation != generation || p.transfer)
|
||||
return std::unexpected(server::ProbeLedgerError::unavailable);
|
||||
p.transfer = transfer;
|
||||
p.x = x;
|
||||
p.y = y;
|
||||
world->transfers[transfer] = {
|
||||
account, region, destination, generation, x, y, WorldDb::State::prepared};
|
||||
return {};
|
||||
}
|
||||
std::expected<bool, server::ProbeLedgerError> abort(const TransferId& transfer) override {
|
||||
auto& t = world->transfers.at(transfer);
|
||||
if (t.state == WorldDb::State::prepared) {
|
||||
t.state = WorldDb::State::aborted;
|
||||
world->probes.at(t.account).transfer.reset();
|
||||
}
|
||||
return t.state == WorldDb::State::aborted;
|
||||
}
|
||||
std::expected<std::vector<server::IncomingProbe>, server::ProbeLedgerError>
|
||||
incoming() override {
|
||||
std::vector<server::IncomingProbe> out;
|
||||
for (const auto& [id, t] : world->transfers)
|
||||
if (t.destination == region && t.state == WorldDb::State::prepared)
|
||||
out.push_back({id, t.x, t.y});
|
||||
return out;
|
||||
}
|
||||
std::expected<HandoffAdmission, HandoffLedgerError> admit(const TicketClaims& ticket,
|
||||
std::uint64_t) override {
|
||||
const auto found = world->transfers.find(ticket.transfer);
|
||||
if (found == world->transfers.end() || found->second.destination != region ||
|
||||
found->second.account != ticket.account ||
|
||||
found->second.state == WorldDb::State::aborted)
|
||||
return std::unexpected(HandoffLedgerError::refused);
|
||||
auto& t = found->second;
|
||||
auto& p = world->probes.at(t.account);
|
||||
if (t.state == WorldDb::State::prepared) { // Stage and commit: the switch.
|
||||
t.state = WorldDb::State::committed;
|
||||
p = {region, t.generation + 1, t.x, t.y, std::nullopt};
|
||||
}
|
||||
return HandoffAdmission{ControlLease{++control, {}, std::chrono::milliseconds{20000}},
|
||||
p.generation, p.x, p.y};
|
||||
}
|
||||
std::expected<ControlLease, ControlLedgerError> claim(const AccountId&, std::uint64_t,
|
||||
std::uint64_t) override {
|
||||
return ControlLease{++control, {}, std::chrono::milliseconds{20000}};
|
||||
}
|
||||
std::expected<std::chrono::milliseconds, ControlLedgerError> renew(const AccountId&,
|
||||
std::uint64_t) override {
|
||||
return std::chrono::milliseconds{20000};
|
||||
}
|
||||
void release(const AccountId&, std::uint64_t) override {
|
||||
++releases;
|
||||
}
|
||||
WorldDb* world;
|
||||
std::uint64_t region;
|
||||
std::uint64_t control{}, saves{}, releases{};
|
||||
};
|
||||
} // namespace evo::test
|
||||
+5
-96
@@ -8,6 +8,7 @@
|
||||
#include "evo/network/session_grant.hpp"
|
||||
#include "evo/server/probe_ledger.hpp"
|
||||
#include "evo/server/region_sessions.hpp"
|
||||
#include "fixtures/fake_handoff_world.hpp"
|
||||
#include <algorithm>
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
@@ -628,102 +629,10 @@ void ticket_login(const Files& f) {
|
||||
CHECK(a->state() == RegionSessionState::established && handoff.admitted.size() == 1);
|
||||
}
|
||||
|
||||
// M10.8c (ADR-0096): two regions with adjacent areas in one process, over a fake world
|
||||
// database with the same transfer state machine as schema v12.
|
||||
struct WorldDb {
|
||||
struct Probe {
|
||||
std::uint64_t owner{}, generation{};
|
||||
std::int64_t x{}, y{};
|
||||
std::optional<TransferId> transfer;
|
||||
};
|
||||
enum class State : std::uint8_t { prepared, committed, aborted };
|
||||
struct Transfer {
|
||||
AccountId account;
|
||||
std::uint64_t source{}, destination{}, generation{};
|
||||
std::int64_t x{}, y{};
|
||||
State state{};
|
||||
};
|
||||
std::map<AccountId, Probe> probes;
|
||||
std::map<TransferId, Transfer> transfers;
|
||||
};
|
||||
struct RegionDb final : server::ProbeLedger, HandoffLedger, ControlLedger {
|
||||
RegionDb(WorldDb& w, std::uint64_t r) : world{&w}, region{r} {}
|
||||
std::expected<server::ProbeHome, server::ProbeLedgerError>
|
||||
open(const AccountId& account, std::int64_t x, std::int64_t y, std::int64_t) override {
|
||||
auto [it, created] =
|
||||
world->probes.try_emplace(account, WorldDb::Probe{region, 1, x, y, std::nullopt});
|
||||
const auto& p = it->second;
|
||||
return server::ProbeHome{p.owner, p.generation, p.x, p.y, p.transfer.has_value()};
|
||||
}
|
||||
void save(const AccountId& account, std::uint64_t generation, std::int64_t x, std::int64_t y,
|
||||
std::int64_t) override {
|
||||
auto& p = world->probes.at(account);
|
||||
if (p.owner == region && p.generation == generation && !p.transfer) {
|
||||
p.x = x;
|
||||
p.y = y;
|
||||
++saves;
|
||||
}
|
||||
}
|
||||
std::expected<void, server::ProbeLedgerError>
|
||||
prepare(const AccountId& account, std::uint64_t generation, const TransferId& transfer,
|
||||
std::uint64_t destination, std::int64_t x, std::int64_t y, std::int64_t) override {
|
||||
auto& p = world->probes.at(account);
|
||||
if (p.owner != region || p.generation != generation || p.transfer)
|
||||
return std::unexpected(server::ProbeLedgerError::unavailable);
|
||||
p.transfer = transfer;
|
||||
p.x = x;
|
||||
p.y = y;
|
||||
world->transfers[transfer] = {
|
||||
account, region, destination, generation, x, y, WorldDb::State::prepared};
|
||||
return {};
|
||||
}
|
||||
std::expected<bool, server::ProbeLedgerError> abort(const TransferId& transfer) override {
|
||||
auto& t = world->transfers.at(transfer);
|
||||
if (t.state == WorldDb::State::prepared) {
|
||||
t.state = WorldDb::State::aborted;
|
||||
world->probes.at(t.account).transfer.reset();
|
||||
}
|
||||
return t.state == WorldDb::State::aborted;
|
||||
}
|
||||
std::expected<std::vector<server::IncomingProbe>, server::ProbeLedgerError>
|
||||
incoming() override {
|
||||
std::vector<server::IncomingProbe> out;
|
||||
for (const auto& [id, t] : world->transfers)
|
||||
if (t.destination == region && t.state == WorldDb::State::prepared)
|
||||
out.push_back({id, t.x, t.y});
|
||||
return out;
|
||||
}
|
||||
std::expected<HandoffAdmission, HandoffLedgerError> admit(const TicketClaims& ticket,
|
||||
std::uint64_t) override {
|
||||
const auto found = world->transfers.find(ticket.transfer);
|
||||
if (found == world->transfers.end() || found->second.destination != region ||
|
||||
found->second.account != ticket.account ||
|
||||
found->second.state == WorldDb::State::aborted)
|
||||
return std::unexpected(HandoffLedgerError::refused);
|
||||
auto& t = found->second;
|
||||
auto& p = world->probes.at(t.account);
|
||||
if (t.state == WorldDb::State::prepared) { // Stage and commit: the switch.
|
||||
t.state = WorldDb::State::committed;
|
||||
p = {region, t.generation + 1, t.x, t.y, std::nullopt};
|
||||
}
|
||||
return HandoffAdmission{ControlLease{++control, {}, std::chrono::milliseconds{20000}},
|
||||
p.generation, p.x, p.y};
|
||||
}
|
||||
std::expected<ControlLease, ControlLedgerError> claim(const AccountId&, std::uint64_t,
|
||||
std::uint64_t) override {
|
||||
return ControlLease{++control, {}, std::chrono::milliseconds{20000}};
|
||||
}
|
||||
std::expected<std::chrono::milliseconds, ControlLedgerError> renew(const AccountId&,
|
||||
std::uint64_t) override {
|
||||
return std::chrono::milliseconds{20000};
|
||||
}
|
||||
void release(const AccountId&, std::uint64_t) override {
|
||||
++releases;
|
||||
}
|
||||
WorldDb* world;
|
||||
std::uint64_t region;
|
||||
std::uint64_t control{}, saves{}, releases{};
|
||||
};
|
||||
// M10.8c (ADR-0096): two regions with adjacent areas in one process, over the fake world
|
||||
// database of tests/fixtures/fake_handoff_world.hpp.
|
||||
using evo::test::RegionDb;
|
||||
using evo::test::WorldDb;
|
||||
constexpr std::int64_t m_um = 1'000'000; // One metre (one cell) in micrometres.
|
||||
// Region `id` owns x in [x0, x0 + 10 m), y in [0, 10 m) of slice 0.
|
||||
network::motion::Area area_of(std::int64_t x0) {
|
||||
|
||||
Reference in New Issue
Block a user