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

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:
dingo
2026-10-06 21:56:42 -04:00
co-authored by Claude Opus 5.5
parent a7a3d12283
commit dabeee8e8b
14 changed files with 635 additions and 129 deletions
+1
View File
@@ -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));
+131 -15
View File
@@ -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_;
+113 -2
View File
@@ -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_{};
+9 -1
View File
@@ -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;
}
+34 -10
View File
@@ -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")