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")
|
||||
|
||||
Reference in New Issue
Block a user