feat(admin): read-only admin portal and API (ADR-0182 step 1, schema 61)
evo-admin-api serves the portal at srs.aeternalisgames.com and read-only JSON for world 100 behind Keycloak (realm role aevolution-admin, audience aevolution-admin, client aevolution-admin-portal): accounts with session, status, lives, deaths, resets and mutation choices; one account's lives; the world's regions; and a live 2D region view of cells, wildlife, pools and bubbles. The portal is plain HTML/CSS/JS with PKCE sign-in, a strict CSP and no third-party code. - Schema 61: three bounded SECURITY DEFINER read functions, fenced in the privilege audit; no table or existing function changes. - Cellular regions answer GET /admin/view on the ops port (NetworkPolicy: Prometheus and the admin portal only); CellularLives::extent_of reads the existing phenotype budget. No simulation, checkpoint or wire change. - TokenVerifier takes an optional realm role and returns the email; the ops server's response bound is configurable (16 KiB default unchanged). - DEV component admin-portal-dev (Deployment, Service, NetworkPolicies); the Ingress and the aevolution-admin-pg Secret are created out of band. - CI scripts pinned to schema 60 now expect 61. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
+14
-2
@@ -103,7 +103,7 @@ add_library(evo_lifecycle STATIC src/server/lifecycle/primitive_lives.cpp
|
||||
src/server/lifecycle/cellular_schedule.cpp src/server/lifecycle/cellular_population_batch.cpp
|
||||
src/server/lifecycle/cellular_environment.cpp src/server/lifecycle/cellular_environment_batch.cpp
|
||||
src/server/lifecycle/cellular_light.cpp src/server/lifecycle/cellular_liquid.cpp
|
||||
src/server/lifecycle/cellular_revamp.cpp)
|
||||
src/server/lifecycle/cellular_revamp.cpp src/server/lifecycle/cellular_admin_view.cpp)
|
||||
add_library(evo::lifecycle ALIAS evo_lifecycle)
|
||||
target_link_libraries(evo_lifecycle PUBLIC evo::biology evo::world)
|
||||
evo_owned_target(evo_lifecycle)
|
||||
@@ -311,6 +311,13 @@ if(EVO_BUILD_POSTGRES)
|
||||
add_executable(evo-grant-broker apps/evo-grant-broker/main.cpp)
|
||||
target_link_libraries(evo-grant-broker PRIVATE evo_grant_broker)
|
||||
evo_owned_target(evo-grant-broker)
|
||||
# ADR-0182 read-only admin API and portal host (schema v61).
|
||||
add_library(evo_admin_api STATIC src/server/admin/admin_api.cpp)
|
||||
target_link_libraries(evo_admin_api PUBLIC evo_grant_broker)
|
||||
evo_owned_target(evo_admin_api)
|
||||
add_executable(evo-admin-api apps/evo-admin-api/main.cpp)
|
||||
target_link_libraries(evo-admin-api PRIVATE evo_admin_api)
|
||||
evo_owned_target(evo-admin-api)
|
||||
endif()
|
||||
# M7.9 clone and history audit tool (ADR-0067).
|
||||
add_executable(evo-world-clone apps/evo-world-clone/main.cpp)
|
||||
@@ -337,7 +344,7 @@ if(EVO_BUILD_POSTGRES)
|
||||
target_sources(evo-postgres-tests PRIVATE tests/region_session_tests.cpp
|
||||
tests/grant_broker_tests.cpp)
|
||||
target_link_libraries(evo-postgres-tests PRIVATE evo_network_session evo_control_ledger_postgres
|
||||
evo_grant_broker OpenSSL::Crypto)
|
||||
evo_grant_broker evo_admin_api OpenSSL::Crypto)
|
||||
target_compile_definitions(evo-postgres-tests PRIVATE EVO_POSTGRES_SESSIONS=1)
|
||||
endif()
|
||||
if(EVO_BUILD_QUIC)
|
||||
@@ -787,6 +794,11 @@ if(BUILD_TESTING)
|
||||
evo_owned_target(evo-cellular-revamp-owner-tests)
|
||||
add_test(NAME cellular-revamp-owner-contracts COMMAND evo-cellular-revamp-owner-tests)
|
||||
set_tests_properties(cellular-revamp-owner-contracts PROPERTIES TIMEOUT 300)
|
||||
add_executable(evo-cellular-admin-view-tests tests/cellular_admin_view_tests.cpp)
|
||||
target_include_directories(evo-cellular-admin-view-tests PRIVATE tests)
|
||||
target_link_libraries(evo-cellular-admin-view-tests PRIVATE evo::lifecycle)
|
||||
evo_owned_target(evo-cellular-admin-view-tests)
|
||||
add_test(NAME cellular-admin-view-contracts COMMAND evo-cellular-admin-view-tests)
|
||||
add_executable(evo-photosynthesis-tests tests/photosynthesis_tests.cpp)
|
||||
target_link_libraries(evo-photosynthesis-tests PRIVATE evo::lifecycle)
|
||||
evo_owned_target(evo-photosynthesis-tests)
|
||||
|
||||
@@ -0,0 +1,201 @@
|
||||
// ADR-0182 read-only admin API and portal host for one world (DEV).
|
||||
//
|
||||
// evo-admin-api --listen ADDRESS:PORT --world N --jwks JSON --oidc-issuer URL
|
||||
// --audience NAME --client NAME --role NAME --assets DIR
|
||||
// --pg-passfile F --pg-service F [--region REGION=HOST:PORT ...]
|
||||
//
|
||||
// --assets holds the portal's index.html, app.js and style.css. Each --region names a
|
||||
// region's operations address, whose /admin/view the portal may show. No token is printed.
|
||||
#include "evo/persistence/postgres.hpp"
|
||||
#include "evo/server/admin/admin_api.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <charconv>
|
||||
#include <chrono>
|
||||
#include <csignal>
|
||||
#include <cstdio>
|
||||
#include <fstream>
|
||||
#include <iterator>
|
||||
#include <map>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
using namespace evo;
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
volatile std::sig_atomic_t stop_requested = 0;
|
||||
void on_stop(int) {
|
||||
stop_requested = 1;
|
||||
}
|
||||
|
||||
struct Options {
|
||||
std::string listen, jwks, oidc_issuer, audience, client, role, assets;
|
||||
std::uint64_t world{};
|
||||
std::map<std::uint64_t, std::string> regions; // Region to its operations address.
|
||||
persistence::PgOptions pg;
|
||||
};
|
||||
|
||||
std::optional<std::uint64_t> number(std::string_view text) {
|
||||
std::uint64_t value{};
|
||||
const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), value);
|
||||
if (error != std::errc{} || end != text.data() + text.size())
|
||||
return std::nullopt;
|
||||
return value;
|
||||
}
|
||||
|
||||
std::optional<Options> parse(int argc, char** argv) {
|
||||
Options o;
|
||||
std::string pg_service, pg_passfile;
|
||||
for (int i = 1; i + 1 < argc; i += 2) {
|
||||
const std::string_view flag = argv[i];
|
||||
const std::string_view value = argv[i + 1];
|
||||
const auto n = number(value);
|
||||
if (flag == "--listen")
|
||||
o.listen = value;
|
||||
else if (flag == "--world" && n && *n > 0)
|
||||
o.world = *n;
|
||||
else if (flag == "--jwks")
|
||||
o.jwks = value;
|
||||
else if (flag == "--oidc-issuer")
|
||||
o.oidc_issuer = value;
|
||||
else if (flag == "--audience")
|
||||
o.audience = value;
|
||||
else if (flag == "--client")
|
||||
o.client = value;
|
||||
else if (flag == "--role")
|
||||
o.role = value;
|
||||
else if (flag == "--assets")
|
||||
o.assets = value;
|
||||
else if (flag == "--pg-service")
|
||||
pg_service = value;
|
||||
else if (flag == "--pg-passfile")
|
||||
pg_passfile = value;
|
||||
else if (flag == "--region") {
|
||||
const auto equals = value.find('=');
|
||||
const auto region =
|
||||
equals == std::string_view::npos ? std::nullopt : number(value.substr(0, equals));
|
||||
const auto address =
|
||||
equals == std::string_view::npos ? std::string_view{} : value.substr(equals + 1);
|
||||
if (!region || *region == 0 || address.empty() || address.size() > 128 ||
|
||||
!o.regions.emplace(*region, std::string(address)).second)
|
||||
return std::nullopt;
|
||||
} else
|
||||
return std::nullopt;
|
||||
}
|
||||
// Names are embedded in the portal's JSON settings: printable ASCII without quotes.
|
||||
const auto plain = [](std::string_view text) {
|
||||
return !text.empty() && text.size() <= 256 && std::ranges::all_of(text, [](char ch) {
|
||||
return ch > ' ' && ch <= '~' && ch != '"' && ch != '\\';
|
||||
});
|
||||
};
|
||||
if (argc % 2 != 1 || o.listen.empty() || o.world == 0 || o.jwks.empty() ||
|
||||
!plain(o.oidc_issuer) || !o.oidc_issuer.starts_with("https://") || !plain(o.audience) ||
|
||||
!plain(o.client) || !plain(o.role) || o.assets.empty() || pg_service.empty() ||
|
||||
pg_passfile.empty())
|
||||
return std::nullopt;
|
||||
auto service = persistence::read_pg_service(pg_service, "evolution");
|
||||
if (!service)
|
||||
return std::nullopt;
|
||||
o.pg = *service;
|
||||
o.pg.password_file = pg_passfile;
|
||||
return o;
|
||||
}
|
||||
|
||||
std::optional<std::string> read_file(const std::string& path) {
|
||||
std::ifstream file{path, std::ios::binary};
|
||||
if (!file)
|
||||
return std::nullopt;
|
||||
std::string body{std::istreambuf_iterator<char>{file}, std::istreambuf_iterator<char>{}};
|
||||
if (body.empty() || body.size() > (std::size_t{1} << 20U))
|
||||
return std::nullopt;
|
||||
return body;
|
||||
}
|
||||
|
||||
std::uint64_t wall_seconds() {
|
||||
return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
|
||||
std::chrono::system_clock::now().time_since_epoch())
|
||||
.count());
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
const auto options = parse(argc, argv);
|
||||
if (!options) {
|
||||
std::fputs("usage: evo-admin-api (see apps/evo-admin-api/main.cpp)\n", stderr);
|
||||
return 2;
|
||||
}
|
||||
std::signal(SIGTERM, on_stop);
|
||||
std::signal(SIGINT, on_stop);
|
||||
std::signal(SIGPIPE, SIG_IGN);
|
||||
|
||||
auto verifier = server::broker::TokenVerifier::from_jwks(
|
||||
options->jwks,
|
||||
{options->oidc_issuer, options->audience, options->client, 30, options->role});
|
||||
if (!verifier) {
|
||||
std::puts("error jwks");
|
||||
return 2;
|
||||
}
|
||||
std::vector<server::admin::AdminAsset> assets;
|
||||
for (const auto& [name, type] : {std::pair{"index.html", "text/html; charset=utf-8"},
|
||||
std::pair{"app.js", "text/javascript; charset=utf-8"},
|
||||
std::pair{"style.css", "text/css; charset=utf-8"}}) {
|
||||
auto body = read_file(options->assets + "/" + name);
|
||||
if (!body) {
|
||||
std::printf("error assets %s\n", name);
|
||||
return 2;
|
||||
}
|
||||
assets.push_back({std::string("/") + name, type, std::move(*body)});
|
||||
}
|
||||
// The realm's origin: sign-in redirects there and the portal exchanges tokens with it.
|
||||
const auto origin_end = options->oidc_issuer.find('/', std::string_view{"https://"}.size());
|
||||
const auto origin = options->oidc_issuer.substr(0, origin_end);
|
||||
server::admin::AdminConfig config;
|
||||
config.world = options->world;
|
||||
for (const auto& [region, address] : options->regions)
|
||||
config.view_regions.push_back(region);
|
||||
config.portal_config_json = "{\"issuer\":\"" + options->oidc_issuer + "\",\"client_id\":\"" +
|
||||
options->client + "\",\"world\":" + std::to_string(options->world) +
|
||||
"}\n";
|
||||
config.content_security_policy =
|
||||
"default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' data:; "
|
||||
"connect-src 'self' " +
|
||||
origin + "; form-action 'self' " + origin + "; frame-ancestors 'none'; base-uri 'none'";
|
||||
|
||||
auto listening = server::OpsServer::listen(options->listen,
|
||||
server::OpsServer::max_configurable_response_bytes);
|
||||
if (!listening) {
|
||||
std::puts("error listen");
|
||||
return 2;
|
||||
}
|
||||
const auto pg = options->pg;
|
||||
const auto regions = options->regions;
|
||||
server::admin::AdminApi api{std::move(config), std::move(*verifier),
|
||||
[pg]() -> std::unique_ptr<persistence::Postgres> {
|
||||
auto db = persistence::Postgres::connect(pg, 3s);
|
||||
return db ? std::move(*db) : nullptr;
|
||||
},
|
||||
[regions](std::uint64_t region) -> std::optional<std::string> {
|
||||
const auto found = regions.find(region);
|
||||
if (found == regions.end())
|
||||
return std::nullopt;
|
||||
return server::admin::http_get(
|
||||
found->second, "/admin/view", 1500ms,
|
||||
server::OpsServer::max_configurable_response_bytes);
|
||||
},
|
||||
std::move(assets)};
|
||||
std::printf("admin api listening %u world %llu\n", static_cast<unsigned>((*listening)->port()),
|
||||
static_cast<unsigned long long>(options->world));
|
||||
std::fflush(stdout);
|
||||
while (stop_requested == 0) {
|
||||
(*listening)->serve_api([&](const server::ApiRequest& request) {
|
||||
return api.handle(request, wall_seconds(), std::chrono::steady_clock::now());
|
||||
});
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
std::puts("admin api stopped");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,558 @@
|
||||
// ADR-0182 read-only admin portal. Keycloak sign-in (authorization code with PKCE), then the
|
||||
// admin API on this origin. Tokens stay in this tab: the access token in memory, the refresh
|
||||
// and ID tokens in sessionStorage so a reload keeps the session. No third-party code.
|
||||
|
||||
const store = {
|
||||
get: (k) => { try { return sessionStorage.getItem(k); } catch { return null; } },
|
||||
set: (k, v) => { try { sessionStorage.setItem(k, v); } catch { /* private mode */ } },
|
||||
drop: (...ks) => { try { ks.forEach((k) => sessionStorage.removeItem(k)); } catch { /* */ } },
|
||||
};
|
||||
|
||||
let config = null;
|
||||
let access = null; // { token, expires (ms) }
|
||||
let refreshing = null; // In-flight refresh promise.
|
||||
|
||||
// ---------- DOM helpers (textContent only: nothing from the API is parsed as HTML) ----------
|
||||
function h(tag, attrs = {}, ...children) {
|
||||
const el = document.createElement(tag);
|
||||
for (const [k, v] of Object.entries(attrs)) {
|
||||
if (v === null || v === undefined || v === false) continue;
|
||||
if (k === 'class') el.className = v;
|
||||
else if (k.startsWith('on')) el.addEventListener(k.slice(2), v);
|
||||
else if (v === true) el.setAttribute(k, '');
|
||||
else el.setAttribute(k, String(v));
|
||||
}
|
||||
for (const c of children.flat()) {
|
||||
if (c === null || c === undefined || c === false) continue;
|
||||
el.append(c instanceof Node ? c : document.createTextNode(String(c)));
|
||||
}
|
||||
return el;
|
||||
}
|
||||
const main = () => document.getElementById('main');
|
||||
function show(...nodes) { main().replaceChildren(...nodes); }
|
||||
|
||||
// ---------- Formatting ----------
|
||||
const fmtInt = (n) => (n === null || n === undefined ? '—' : Number(n).toLocaleString());
|
||||
function fmtUnit(value, units) {
|
||||
if (value === null || value === undefined) return '—';
|
||||
let v = Number(value), i = 0;
|
||||
while (Math.abs(v) >= 1000 && i < units.length - 1) { v /= 1000; i++; }
|
||||
return `${v >= 100 || i === 0 ? Math.round(v) : v.toFixed(v >= 10 ? 1 : 2)} ${units[i]}`;
|
||||
}
|
||||
const fmtEnergy = (pj) => fmtUnit(pj, ['pJ', 'nJ', 'µJ', 'mJ', 'J']);
|
||||
const fmtMass = (fg) => fmtUnit(fg, ['fg', 'pg', 'ng', 'µg', 'mg']);
|
||||
const fmtLength = (um) => fmtUnit(um, ['µm', 'mm', 'm']);
|
||||
function fmtTime(seconds) {
|
||||
if (!seconds) return '—';
|
||||
return new Date(seconds * 1000).toLocaleString();
|
||||
}
|
||||
function fmtAgo(seconds) {
|
||||
if (!seconds) return '—';
|
||||
const d = Math.round(Date.now() / 1000 - seconds);
|
||||
if (Math.abs(d) < 60) return d >= 0 ? `${d}s ago` : `in ${-d}s`;
|
||||
const m = Math.round(d / 60);
|
||||
if (Math.abs(m) < 60) return m >= 0 ? `${m}m ago` : `in ${-m}m`;
|
||||
const hr = Math.round(m / 60);
|
||||
if (Math.abs(hr) < 48) return hr >= 0 ? `${hr}h ago` : `in ${-hr}h`;
|
||||
return `${Math.round(hr / 24)}d ago`;
|
||||
}
|
||||
const short = (id) => (id ? `${id.slice(0, 8)}…` : '—');
|
||||
|
||||
// ---------- Sign-in ----------
|
||||
function b64url(bytes) {
|
||||
let s = '';
|
||||
bytes.forEach((b) => { s += String.fromCharCode(b); });
|
||||
return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
|
||||
}
|
||||
function randomText(n) {
|
||||
const a = new Uint8Array(n);
|
||||
crypto.getRandomValues(a);
|
||||
return b64url(a);
|
||||
}
|
||||
const endpoint = (name) => `${config.issuer}/protocol/openid-connect/${name}`;
|
||||
const redirectUri = () => `${location.origin}/`;
|
||||
|
||||
async function signIn() {
|
||||
const verifier = randomText(48);
|
||||
const state = randomText(16);
|
||||
const challenge = b64url(new Uint8Array(
|
||||
await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier))));
|
||||
store.set('pkce_verifier', verifier);
|
||||
store.set('pkce_state', state);
|
||||
store.set('return_to', location.hash || '#/accounts');
|
||||
const url = new URL(endpoint('auth'));
|
||||
url.search = new URLSearchParams({
|
||||
client_id: config.client_id, redirect_uri: redirectUri(), response_type: 'code',
|
||||
response_mode: 'query', scope: 'openid email', state, code_challenge: challenge,
|
||||
code_challenge_method: 'S256',
|
||||
});
|
||||
location.assign(url);
|
||||
}
|
||||
|
||||
async function tokenRequest(body) {
|
||||
const res = await fetch(endpoint('token'), {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
|
||||
body: new URLSearchParams({ client_id: config.client_id, ...body }),
|
||||
});
|
||||
if (!res.ok) throw new Error(`token endpoint ${res.status}`);
|
||||
const t = await res.json();
|
||||
access = { token: t.access_token, expires: Date.now() + (t.expires_in || 60) * 1000 };
|
||||
if (t.refresh_token) store.set('refresh_token', t.refresh_token);
|
||||
if (t.id_token) store.set('id_token', t.id_token);
|
||||
return access.token;
|
||||
}
|
||||
|
||||
async function finishSignIn() {
|
||||
const params = new URLSearchParams(location.search);
|
||||
const code = params.get('code');
|
||||
if (!code && !params.get('error')) return false;
|
||||
const expected = store.get('pkce_state');
|
||||
const verifier = store.get('pkce_verifier');
|
||||
const returnTo = store.get('return_to') || '#/accounts';
|
||||
store.drop('pkce_state', 'pkce_verifier', 'return_to');
|
||||
history.replaceState(null, '', `/${returnTo}`);
|
||||
if (params.get('error') || !expected || params.get('state') !== expected || !verifier) {
|
||||
throw new Error(`sign-in was not completed (${params.get('error') || 'state mismatch'})`);
|
||||
}
|
||||
await tokenRequest({ grant_type: 'authorization_code', code, redirect_uri: redirectUri(),
|
||||
code_verifier: verifier });
|
||||
return true;
|
||||
}
|
||||
|
||||
async function token() {
|
||||
if (access && access.expires - Date.now() > 30000) return access.token;
|
||||
const refresh = store.get('refresh_token');
|
||||
if (!refresh) return null;
|
||||
refreshing = refreshing || tokenRequest({ grant_type: 'refresh_token', refresh_token: refresh })
|
||||
.catch(() => { store.drop('refresh_token'); access = null; return null; })
|
||||
.finally(() => { refreshing = null; });
|
||||
return refreshing;
|
||||
}
|
||||
|
||||
function signOut() {
|
||||
const idToken = store.get('id_token');
|
||||
store.drop('refresh_token', 'id_token');
|
||||
access = null;
|
||||
const url = new URL(endpoint('logout'));
|
||||
url.search = new URLSearchParams({
|
||||
client_id: config.client_id, post_logout_redirect_uri: redirectUri(),
|
||||
...(idToken ? { id_token_hint: idToken } : {}),
|
||||
});
|
||||
location.assign(url);
|
||||
}
|
||||
|
||||
class ApiError extends Error {
|
||||
constructor(status, code) { super(code || `HTTP ${status}`); this.status = status; this.code = code; }
|
||||
}
|
||||
async function api(path, retry = true) {
|
||||
const t = await token();
|
||||
if (!t) throw new ApiError(401, 'signed_out');
|
||||
const res = await fetch(path, { headers: { Authorization: `Bearer ${t}` }, cache: 'no-store' });
|
||||
if (res.status === 401 && retry) { access = null; return api(path, false); }
|
||||
if (!res.ok) {
|
||||
let code = null;
|
||||
try { code = (await res.json()).error; } catch { /* plain text */ }
|
||||
throw new ApiError(res.status, code);
|
||||
}
|
||||
return res.json();
|
||||
}
|
||||
|
||||
// ---------- Sortable tables ----------
|
||||
function table(columns, rows, { onRow, sortKey, sortUp = false } = {}) {
|
||||
let key = sortKey, up = sortUp;
|
||||
const wrap = h('div', { class: 'table-wrap' });
|
||||
const draw = () => {
|
||||
const col = columns.find((c) => c.key === key);
|
||||
const sorted = col ? [...rows].sort((a, b) => {
|
||||
const va = col.sort ? col.sort(a) : a[col.key];
|
||||
const vb = col.sort ? col.sort(b) : b[col.key];
|
||||
const r = va === vb ? 0 : va === null || va === undefined ? 1 : vb === null || vb === undefined ? -1 : va < vb ? -1 : 1;
|
||||
return up ? r : -r;
|
||||
}) : rows;
|
||||
const head = h('tr', {}, columns.map((c) => h('th', {
|
||||
class: [c.num ? 'num' : '', c.key === key ? `sorted${up ? ' up' : ''}` : ''].join(' ').trim() || null,
|
||||
onclick: () => { if (key === c.key) up = !up; else { key = c.key; up = !c.num; } draw(); },
|
||||
}, c.label)));
|
||||
const body = sorted.map((r) => h('tr', { class: onRow ? 'clickable' : null, onclick: onRow ? () => onRow(r) : null },
|
||||
columns.map((c) => h('td', { class: c.num ? 'num' : null }, c.render ? c.render(r) : (r[c.key] ?? '—')))));
|
||||
wrap.replaceChildren(h('table', {}, h('thead', {}, head), h('tbody', {}, body.length ? body
|
||||
: h('tr', {}, h('td', { colspan: columns.length, class: 'muted' }, 'Nothing to show.')))));
|
||||
};
|
||||
draw();
|
||||
return wrap;
|
||||
}
|
||||
|
||||
function statusBadge(a) {
|
||||
return h('span', { class: `badge ${a.status === 'alive' ? 'alive' : a.status === 'dead' ? 'dead' : ''}` },
|
||||
a.status === 'no_life' ? 'no life' : a.status);
|
||||
}
|
||||
function sessionBadge(a) {
|
||||
return a.logged_in ? h('span', { class: 'badge online' }, `online · region ${a.control_region}`)
|
||||
: h('span', { class: 'muted' }, 'offline');
|
||||
}
|
||||
|
||||
// ---------- Pages ----------
|
||||
let stopPage = () => {};
|
||||
|
||||
async function accountsPage() {
|
||||
const data = await api('/api/accounts');
|
||||
const search = h('input', { type: 'search', placeholder: 'Filter by account, subject or status' });
|
||||
const holder = h('div');
|
||||
const columns = [
|
||||
{ key: 'account', label: 'Account', render: (a) => h('span', { class: 'mono', title: a.account }, short(a.account)) },
|
||||
{ key: 'subject', label: 'Keycloak subject', render: (a) => h('span', { class: 'mono muted', title: a.subject || '' }, a.subject ? short(a.subject) : '—') },
|
||||
{ key: 'status', label: 'Status', render: statusBadge },
|
||||
{ key: 'logged_in', label: 'Session', render: sessionBadge, sort: (a) => (a.logged_in ? 1 : 0) },
|
||||
{ key: 'active_region', label: 'Region', render: (a) => a.active_region ?? '—', sort: (a) => Number(a.active_region ?? -1) },
|
||||
{ key: 'lives', label: 'Lives', num: true },
|
||||
{ key: 'deaths', label: 'Deaths', num: true },
|
||||
{ key: 'resets', label: 'Resets', num: true },
|
||||
{ key: 'mutation_choices', label: 'Mutation choices', num: true },
|
||||
{ key: 'created_at', label: 'Created', render: (a) => (a.created_at ? fmtAgo(a.created_at) : '—'), sort: (a) => a.created_at ?? 0 },
|
||||
];
|
||||
const draw = () => {
|
||||
const q = search.value.trim().toLowerCase();
|
||||
const rows = data.accounts.filter((a) => !q || [a.account, a.subject, a.status].some((v) => (v || '').toLowerCase().includes(q)));
|
||||
holder.replaceChildren(table(columns, rows, { sortKey: 'created_at', onRow: (a) => { location.hash = `#/accounts/${a.account}`; } }));
|
||||
};
|
||||
search.addEventListener('input', draw);
|
||||
const n = data.accounts.length;
|
||||
const online = data.accounts.filter((a) => a.logged_in).length;
|
||||
const alive = data.accounts.filter((a) => a.status === 'alive').length;
|
||||
show(
|
||||
h('div', { class: 'head' }, h('div', {}, h('h1', {}, 'Accounts'), h('span', { class: 'muted' }, `World ${data.world}`)),
|
||||
h('div', { class: 'tools' }, search, h('button', { onclick: () => route() }, 'Refresh'))),
|
||||
h('div', { class: 'stats' },
|
||||
stat('Accounts', fmtInt(n)), stat('Online', fmtInt(online)), stat('Alive', fmtInt(alive)),
|
||||
stat('Deaths', fmtInt(data.accounts.reduce((s, a) => s + (a.deaths || 0), 0)))),
|
||||
holder);
|
||||
draw();
|
||||
}
|
||||
|
||||
function stat(label, value, sub) {
|
||||
return h('div', { class: 'stat' }, h('div', { class: 'label' }, label),
|
||||
h('div', { class: 'value' }, value, sub ? h('small', {}, ` ${sub}`) : null));
|
||||
}
|
||||
|
||||
// persistence::LifeRefusal.
|
||||
const rejections = ['accepted', 'refused: not enough funding', 'refused: no placement', 'cancelled', 'refused: already alive'];
|
||||
|
||||
async function accountPage(id) {
|
||||
const data = await api(`/api/accounts/${id}`);
|
||||
const a = data.account;
|
||||
const facts = h('dl', { class: 'facts' },
|
||||
h('dt', {}, 'Account'), h('dd', { class: 'mono' }, a.account),
|
||||
h('dt', {}, 'Keycloak subject'), h('dd', { class: 'mono' }, a.subject || '—'),
|
||||
h('dt', {}, 'Issuer'), h('dd', { class: 'mono' }, a.issuer || '—'),
|
||||
h('dt', {}, 'Status'), h('dd', {}, statusBadge(a)),
|
||||
h('dt', {}, 'Session'), h('dd', {}, sessionBadge(a),
|
||||
a.control_expires ? h('span', { class: 'muted' }, ` control ${a.logged_in ? 'until' : 'ended'} ${fmtTime(a.control_expires)}`) : null),
|
||||
h('dt', {}, 'Active life'), h('dd', { class: 'mono' }, a.active_life ?? '—',
|
||||
a.active_region ? h('span', {}, ' ', h('a', { href: `#/regions/${a.active_region}?account=${a.account}` }, `show in region ${a.active_region}`)) : null),
|
||||
h('dt', {}, 'Created'), h('dd', {}, fmtTime(a.created_at)));
|
||||
const lives = table([
|
||||
{ key: 'request', label: 'Request', sort: (l) => Number(l.request) },
|
||||
{ key: 'identity', label: 'Life', render: (l) => h('span', { class: 'mono' }, l.identity) },
|
||||
{ key: 'region', label: 'Region' },
|
||||
{ key: 'rejection', label: 'Outcome', render: (l) => (l.rejection ? h('span', { class: 'badge warn' }, rejections[l.rejection] || `refused ${l.rejection}`)
|
||||
: l.born === null ? h('span', { class: 'muted' }, 'reserved') : l.ended_tick ? h('span', { class: 'badge dead' }, 'died') : h('span', { class: 'badge alive' }, 'alive')) },
|
||||
{ key: 'born', label: 'Born (tick)', num: true, sort: (l) => Number(l.born ?? -1) },
|
||||
{ key: 'ended_tick', label: 'Ended (tick)', num: true, sort: (l) => Number(l.ended_tick ?? -1) },
|
||||
{ key: 'ended_at', label: 'Ended', render: (l) => fmtTime(l.ended_at), sort: (l) => l.ended_at ?? 0 },
|
||||
], data.lives, { sortKey: 'request' });
|
||||
show(
|
||||
h('div', { class: 'head' }, h('div', {}, h('a', { href: '#/accounts' }, '← Accounts'), h('h1', {}, `Account ${short(a.account)}`))),
|
||||
h('div', { class: 'stats' },
|
||||
stat('Lives', fmtInt(a.lives)), stat('Deaths', fmtInt(a.deaths)), stat('Resets', fmtInt(a.resets)),
|
||||
stat('Mutation choices', fmtInt(a.mutation_choices))),
|
||||
h('div', { class: 'card' }, facts),
|
||||
h('h2', {}, 'Lives'), lives,
|
||||
h('p', { class: 'muted' }, 'Time played, bans, current mutations and living offspring arrive with the next admin phase (ADR-0182).'));
|
||||
}
|
||||
|
||||
async function regionsPage() {
|
||||
const data = await api('/api/regions');
|
||||
show(
|
||||
h('div', { class: 'head' }, h('div', {}, h('h1', {}, 'Regions'), h('span', { class: 'muted' }, `World ${data.world}`)),
|
||||
h('div', { class: 'tools' }, h('button', { onclick: () => route() }, 'Refresh'))),
|
||||
table([
|
||||
{ key: 'region', label: 'Region', sort: (r) => Number(r.region) },
|
||||
{ key: 'frame', label: 'Frame' },
|
||||
{ key: 'lease_held', label: 'Lease', render: (r) => (r.lease_held ? h('span', { class: 'badge alive' }, `held · epoch ${r.lease_epoch}`) : h('span', { class: 'muted' }, 'free')) },
|
||||
{ key: 'lease_expires', label: 'Lease expires', render: (r) => fmtAgo(r.lease_expires) },
|
||||
{ key: 'tick', label: 'Head tick', num: true, render: (r) => fmtInt(r.tick), sort: (r) => Number(r.tick ?? -1) },
|
||||
{ key: 'sequence', label: 'Commits', num: true, render: (r) => fmtInt(r.sequence), sort: (r) => Number(r.sequence ?? -1) },
|
||||
{ key: 'committed_at', label: 'Last commit', render: (r) => fmtAgo(r.committed_at), sort: (r) => r.committed_at ?? 0 },
|
||||
{ key: 'build', label: 'Build', render: (r) => h('span', { class: 'mono', title: r.build || '' }, r.build ? r.build.slice(0, 12) : '—') },
|
||||
{ key: 'viewable', label: '', render: (r) => (r.viewable ? h('a', { href: `#/regions/${r.region}` }, 'Open view →') : h('span', { class: 'muted' }, 'no view')) },
|
||||
], data.regions, { sortKey: 'region' }));
|
||||
}
|
||||
|
||||
// ---------- Region view ----------
|
||||
const channelNames = ['energy', 'carbon', 'nitrogen', 'phosphorus', 'other'];
|
||||
const css = (name) => getComputedStyle(document.documentElement).getPropertyValue(`--${name}`).trim();
|
||||
|
||||
async function regionPage(region, params) {
|
||||
const highlight = params.get('account') || '';
|
||||
const canvas = h('canvas');
|
||||
const tip = h('div', { class: 'tooltip', hidden: true });
|
||||
const note = h('div', { class: 'overlay-note' }, 'Scroll to zoom, drag to pan, double-click to reset.');
|
||||
const statsBox = h('div', { class: 'stats' });
|
||||
const detail = h('div', { class: 'card' }, h('span', { class: 'muted' }, 'Select a cell to see it here.'));
|
||||
const status = h('span', { class: 'muted' });
|
||||
const show_ = { players: true, wildlife: true, pools: true, bubbles: true };
|
||||
const toggle = (k, label) => h('label', {}, h('input', { type: 'checkbox', checked: true, onchange: (e) => { show_[k] = e.target.checked; paint(); } }), label);
|
||||
const live = h('input', { type: 'checkbox', checked: true });
|
||||
let view = null, selected = null, timer = null;
|
||||
let zoom = 1, panX = 0, panY = 0, drag = null;
|
||||
|
||||
show(
|
||||
h('div', { class: 'head' }, h('div', {}, h('a', { href: '#/regions' }, '← Regions'), h('h1', {}, `Region ${region}`), status),
|
||||
h('div', { class: 'tools' }, h('label', {}, live, ' Live (1 s)'), h('button', { onclick: () => load() }, 'Refresh'))),
|
||||
statsBox,
|
||||
h('div', { class: 'region-layout' },
|
||||
h('div', { class: 'canvas-wrap' }, canvas, tip, note),
|
||||
h('div', { class: 'side' },
|
||||
detail,
|
||||
h('div', { class: 'card' }, h('h2', {}, 'Show'), h('div', { class: 'toggles' },
|
||||
toggle('players', 'Player cells'), toggle('wildlife', 'Wildlife'), toggle('pools', 'Pools'), toggle('bubbles', 'Bubbles'))),
|
||||
h('div', { class: 'card' }, h('h2', {}, 'Legend'), h('div', { class: 'legend' },
|
||||
h('span', { class: 'swatch player' }), 'Player cell',
|
||||
h('span', { class: 'swatch online' }), 'Player cell, connected',
|
||||
h('span', { class: 'swatch wildlife' }), 'Wildlife',
|
||||
h('span', { class: 'swatch pool' }), 'Pool',
|
||||
...channelNames.flatMap((c) => [h('span', { class: `swatch ${c}` }), `Bubble, mostly ${c}`]))))));
|
||||
|
||||
const cellObj = (c) => ({
|
||||
life: c[0], organism: c[1], account: c[2], x: c[3], y: c[4], extent: c[5], flags: c[6], members: c[7],
|
||||
reserve: c.slice(8, 13), bodyMass: c[13],
|
||||
});
|
||||
const depObj = (d) => ({ id: d[0], kind: d[1], x: d[2], y: d[3], r: d[4], stock: d.slice(5, 10) });
|
||||
|
||||
function geometry() {
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
const dpr = window.devicePixelRatio || 1;
|
||||
const w = Math.max(1, Math.round(rect.width * dpr)), hgt = Math.max(1, Math.round(rect.height * dpr));
|
||||
if (canvas.width !== w || canvas.height !== hgt) { canvas.width = w; canvas.height = hgt; }
|
||||
const [aw, ah] = view ? view.area : [1, 1];
|
||||
const base = Math.min(w / aw, hgt / ah);
|
||||
const s = base * zoom;
|
||||
const ox = (w - aw * s) / 2 + panX * dpr, oy = (hgt - ah * s) / 2 + panY * dpr;
|
||||
// World y grows upward; the canvas grows downward.
|
||||
return { dpr, s, toX: (x) => ox + x * s, toY: (y) => oy + (ah - y) * s, fromX: (px) => (px - ox) / s, fromY: (py) => ah - (py - oy) / s };
|
||||
}
|
||||
|
||||
function paint() {
|
||||
const ctx = canvas.getContext('2d');
|
||||
const g = geometry();
|
||||
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
||||
if (!view) return;
|
||||
const [aw, ah] = view.area;
|
||||
ctx.strokeStyle = css('line');
|
||||
ctx.lineWidth = g.dpr;
|
||||
ctx.strokeRect(g.toX(0), g.toY(ah), aw * g.s, ah * g.s);
|
||||
if (show_.pools) {
|
||||
ctx.fillStyle = css('pool');
|
||||
ctx.strokeStyle = css('accent');
|
||||
for (const d of view.deps) if (d.kind !== 2) {
|
||||
ctx.beginPath(); ctx.arc(g.toX(d.x), g.toY(d.y), Math.max(d.r * g.s, 2 * g.dpr), 0, Math.PI * 2); ctx.fill();
|
||||
}
|
||||
}
|
||||
if (show_.bubbles) {
|
||||
const colors = channelNames.map(css);
|
||||
for (const d of view.deps) if (d.kind === 2) {
|
||||
// Energy counts in pJ, matter in fg; ~17 pJ per fg of food, so compare on that scale.
|
||||
const weights = [d.stock[0] / 17, d.stock[1], d.stock[2], d.stock[3], d.stock[4]];
|
||||
const top = weights.indexOf(Math.max(...weights));
|
||||
ctx.fillStyle = colors[top];
|
||||
ctx.beginPath(); ctx.arc(g.toX(d.x), g.toY(d.y), Math.max(d.r * g.s, 1.5 * g.dpr), 0, Math.PI * 2); ctx.fill();
|
||||
}
|
||||
}
|
||||
for (const c of view.cells) {
|
||||
const wild = (c.flags & 1) !== 0;
|
||||
if ((wild && !show_.wildlife) || (!wild && !show_.players)) continue;
|
||||
const online = (c.flags & 2) !== 0, faded = (c.flags & 12) !== 0;
|
||||
const size = Math.max(c.extent * g.s, 3 * g.dpr);
|
||||
const x = g.toX(c.x + c.extent / 2), y = g.toY(c.y + c.extent / 2);
|
||||
ctx.globalAlpha = faded ? 0.4 : 0.9;
|
||||
ctx.fillStyle = wild ? css('wildlife') : online ? css('online') : css('player');
|
||||
ctx.beginPath(); ctx.arc(x, y, size / 2, 0, Math.PI * 2); ctx.fill();
|
||||
ctx.globalAlpha = 1;
|
||||
const marked = (highlight && c.account === highlight) || (selected && selected.life === c.life);
|
||||
if (marked) {
|
||||
ctx.strokeStyle = css('warn'); ctx.lineWidth = 2 * g.dpr;
|
||||
ctx.beginPath(); ctx.arc(x, y, size / 2 + 4 * g.dpr, 0, Math.PI * 2); ctx.stroke();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function hit(px, py) {
|
||||
const g = geometry();
|
||||
const wx = g.fromX(px * g.dpr), wy = g.fromY(py * g.dpr);
|
||||
const slack = 4 / g.s * g.dpr;
|
||||
for (const c of view ? view.cells : []) {
|
||||
const wild = (c.flags & 1) !== 0;
|
||||
if ((wild && !show_.wildlife) || (!wild && !show_.players)) continue;
|
||||
if (wx >= c.x - slack && wx <= c.x + c.extent + slack && wy >= c.y - slack && wy <= c.y + c.extent + slack) return { cell: c };
|
||||
}
|
||||
if (show_.bubbles || show_.pools) {
|
||||
for (const d of view ? view.deps : []) {
|
||||
if ((d.kind === 2 && !show_.bubbles) || (d.kind !== 2 && !show_.pools)) continue;
|
||||
const r = Math.max(d.r, slack);
|
||||
if ((wx - d.x) ** 2 + (wy - d.y) ** 2 <= r * r) return { dep: d };
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function cellLines(c) {
|
||||
const kind = c.flags & 1 ? 'Wildlife' : c.flags & 2 ? 'Player (connected)' : 'Player';
|
||||
return [
|
||||
['Kind', kind], ['Life', c.life], ['Organism', c.organism], ['Account', c.account || '—'],
|
||||
['Members', c.members], ['Size', fmtLength(c.extent)], ['Body mass', fmtMass(c.bodyMass)],
|
||||
['Reserve energy', fmtEnergy(c.reserve[0])],
|
||||
['Reserve C / N / P / other', c.reserve.slice(1).map(fmtMass).join(' / ')],
|
||||
['Position', `${fmtLength(c.x)}, ${fmtLength(c.y)}`],
|
||||
];
|
||||
}
|
||||
function showDetail(c) {
|
||||
selected = c;
|
||||
detail.replaceChildren(h('h2', {}, c.flags & 1 ? 'Wildlife cell' : 'Player cell'),
|
||||
h('dl', { class: 'facts' }, cellLines(c).flatMap(([k, v]) => [h('dt', {}, k), h('dd', { class: k === 'Life' || k === 'Account' ? 'mono' : null }, v)])),
|
||||
c.account ? h('p', {}, h('a', { href: `#/accounts/${c.account}` }, 'Open account →')) : null);
|
||||
paint();
|
||||
}
|
||||
|
||||
canvas.addEventListener('mousemove', (e) => {
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
if (drag) {
|
||||
panX = drag.panX + (e.clientX - drag.x); panY = drag.panY + (e.clientY - drag.y);
|
||||
paint(); return;
|
||||
}
|
||||
const found = hit(e.clientX - rect.left, e.clientY - rect.top);
|
||||
if (!found) { tip.hidden = true; return; }
|
||||
const lines = found.cell
|
||||
? cellLines(found.cell).slice(0, 7)
|
||||
: [['Kind', found.dep.kind === 2 ? 'Bubble' : 'Pool'], ['Energy', fmtEnergy(found.dep.stock[0])],
|
||||
['C / N / P / other', found.dep.stock.slice(1).map(fmtMass).join(' / ')], ['Radius', fmtLength(found.dep.r)]];
|
||||
tip.replaceChildren(...lines.map(([k, v]) => h('div', {}, h('span', { class: 'muted' }, `${k}: `), String(v))));
|
||||
tip.hidden = false;
|
||||
tip.style.left = `${Math.min(e.clientX - rect.left + 14, rect.width - 290)}px`;
|
||||
tip.style.top = `${e.clientY - rect.top + 14}px`;
|
||||
});
|
||||
canvas.addEventListener('mouseleave', () => { tip.hidden = true; drag = null; });
|
||||
canvas.addEventListener('mousedown', (e) => { drag = { x: e.clientX, y: e.clientY, panX, panY, moved: false }; });
|
||||
canvas.addEventListener('mouseup', (e) => {
|
||||
const wasDrag = drag && (Math.abs(e.clientX - drag.x) > 3 || Math.abs(e.clientY - drag.y) > 3);
|
||||
drag = null;
|
||||
if (wasDrag) return;
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
const found = hit(e.clientX - rect.left, e.clientY - rect.top);
|
||||
if (found && found.cell) showDetail(found.cell);
|
||||
});
|
||||
canvas.addEventListener('wheel', (e) => {
|
||||
e.preventDefault();
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
const mx = e.clientX - rect.left - rect.width / 2, my = e.clientY - rect.top - rect.height / 2;
|
||||
const factor = Math.exp(-e.deltaY * 0.0015);
|
||||
const next = Math.min(64, Math.max(1, zoom * factor));
|
||||
const k = next / zoom;
|
||||
panX = mx - (mx - panX) * k; panY = my - (my - panY) * k;
|
||||
zoom = next;
|
||||
if (zoom === 1) { panX = 0; panY = 0; }
|
||||
paint();
|
||||
}, { passive: false });
|
||||
canvas.addEventListener('dblclick', () => { zoom = 1; panX = 0; panY = 0; paint(); });
|
||||
const onResize = () => paint();
|
||||
window.addEventListener('resize', onResize);
|
||||
|
||||
async function load() {
|
||||
try {
|
||||
const raw = await api(`/api/regions/${region}/view`);
|
||||
view = { ...raw, cells: raw.cells.map(cellObj), deps: raw.deposits.map(depObj) };
|
||||
const players = view.cells.filter((c) => !(c.flags & 1));
|
||||
const online = players.filter((c) => c.flags & 2).length;
|
||||
const wild = view.cells.length - players.length;
|
||||
const bubbles = view.deps.filter((d) => d.kind === 2).length;
|
||||
const spentMatter = raw.spent.slice(1).reduce((s, v) => s + v, 0);
|
||||
statsBox.replaceChildren(
|
||||
stat('Tick', fmtInt(raw.tick)), stat('Cells', fmtInt(raw.cells_total)),
|
||||
stat('Players', fmtInt(players.length), `${online} connected`), stat('Wildlife', fmtInt(wild)),
|
||||
stat('Bubbles', fmtInt(bubbles), `${fmtInt(raw.deposits_total - bubbles)} pools`),
|
||||
stat('Spent pool', fmtEnergy(raw.spent[0]), fmtMass(spentMatter)),
|
||||
stat('Area', `${fmtLength(raw.area[0])} × ${fmtLength(raw.area[1])}`));
|
||||
const truncated = raw.cells_total > raw.cells.length || raw.deposits_total > raw.deposits.length;
|
||||
status.textContent = ` rules ${raw.rules}${truncated ? ' · view truncated' : ''} · updated ${new Date().toLocaleTimeString()}`;
|
||||
status.className = truncated ? 'error' : 'muted';
|
||||
if (selected) {
|
||||
const again = view.cells.find((c) => c.life === selected.life);
|
||||
if (again) showDetail(again); else { selected = null; detail.replaceChildren(h('span', { class: 'muted' }, 'The selected cell is gone (died or left).')); }
|
||||
}
|
||||
paint();
|
||||
} catch (e) {
|
||||
status.textContent = ` ${e.status === 503 ? 'region not ready or unreachable' : e.message}`;
|
||||
status.className = 'error';
|
||||
}
|
||||
}
|
||||
const tick = () => { timer = setTimeout(async () => { if (live.checked && !document.hidden) await load(); tick(); }, 1000); };
|
||||
await load();
|
||||
tick();
|
||||
stopPage = () => { clearTimeout(timer); window.removeEventListener('resize', onResize); };
|
||||
}
|
||||
|
||||
// ---------- Routing ----------
|
||||
async function route() {
|
||||
stopPage();
|
||||
stopPage = () => {};
|
||||
const [path, query] = (location.hash.slice(1) || '/accounts').split('?');
|
||||
const parts = path.split('/').filter(Boolean);
|
||||
const params = new URLSearchParams(query || '');
|
||||
for (const a of document.querySelectorAll('[data-route]')) a.classList.toggle('active', a.dataset.route === parts[0]);
|
||||
try {
|
||||
if (parts[0] === 'accounts' && parts[1]) await accountPage(parts[1]);
|
||||
else if (parts[0] === 'regions' && parts[1]) await regionPage(parts[1], params);
|
||||
else if (parts[0] === 'regions') await regionsPage();
|
||||
else await accountsPage();
|
||||
main().focus({ preventScroll: true });
|
||||
} catch (e) {
|
||||
if (e instanceof ApiError && e.status === 401) return signedOut();
|
||||
if (e instanceof ApiError && e.status === 403) {
|
||||
return show(h('div', { class: 'center' }, h('div', {}, h('h1', {}, 'Not an administrator'),
|
||||
h('p', { class: 'muted' }, 'Your account does not have the aevolution-admin role.'),
|
||||
h('button', { onclick: signOut }, 'Sign out'))));
|
||||
}
|
||||
show(h('p', { class: 'error' }, `Could not load this page: ${e.message}`), h('button', { onclick: () => route() }, 'Try again'));
|
||||
}
|
||||
}
|
||||
|
||||
function signedOut() {
|
||||
document.getElementById('who').textContent = '';
|
||||
document.getElementById('sign-out').hidden = true;
|
||||
show(h('div', { class: 'center' }, h('div', {}, h('h1', {}, 'AEvolution admin'),
|
||||
h('p', { class: 'muted' }, 'Sign in with an account that has the aevolution-admin role.'),
|
||||
h('button', { class: 'primary', onclick: signIn }, 'Sign in'))));
|
||||
}
|
||||
|
||||
async function start() {
|
||||
config = await (await fetch('/config.json', { cache: 'no-store' })).json();
|
||||
document.getElementById('sign-out').addEventListener('click', signOut);
|
||||
try {
|
||||
await finishSignIn();
|
||||
} catch (e) {
|
||||
show(h('p', { class: 'error' }, e.message), h('button', { class: 'primary', onclick: signIn }, 'Sign in again'));
|
||||
return;
|
||||
}
|
||||
if (!(await token())) return signedOut();
|
||||
try {
|
||||
const me = await api('/api/me');
|
||||
document.getElementById('who').textContent = me.email || me.subject;
|
||||
document.getElementById('sign-out').hidden = false;
|
||||
} catch (e) {
|
||||
if (e instanceof ApiError && e.status === 401) return signedOut();
|
||||
}
|
||||
window.addEventListener('hashchange', route);
|
||||
await route();
|
||||
}
|
||||
|
||||
start();
|
||||
@@ -0,0 +1,30 @@
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<meta name="robots" content="noindex">
|
||||
<title>AEvolution Admin</title>
|
||||
<link rel="stylesheet" href="/style.css">
|
||||
<script type="module" src="/app.js"></script>
|
||||
</head>
|
||||
<body>
|
||||
<header class="bar">
|
||||
<a class="brand" href="#/accounts">AEvolution <span>admin</span></a>
|
||||
<nav class="sections" aria-label="Sections">
|
||||
<div class="section">
|
||||
<span class="section-name">Cellular</span>
|
||||
<a href="#/accounts" data-route="accounts">Accounts</a>
|
||||
<a href="#/regions" data-route="regions">Regions</a>
|
||||
</div>
|
||||
</nav>
|
||||
<div class="who">
|
||||
<span id="who" class="muted"></span>
|
||||
<button id="sign-out" class="ghost" hidden>Sign out</button>
|
||||
</div>
|
||||
</header>
|
||||
<main id="main" tabindex="-1">
|
||||
<p class="muted">Loading…</p>
|
||||
</main>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,184 @@
|
||||
/* ADR-0182 admin portal. Tokens first; dark is the default, light follows the system. */
|
||||
:root {
|
||||
--bg: #0f1419;
|
||||
--panel: #161d24;
|
||||
--panel-2: #1c252e;
|
||||
--line: #2a3640;
|
||||
--text: #dbe3ea;
|
||||
--muted: #8a99a6;
|
||||
--accent: #4fb3ff;
|
||||
--good: #3ecf8e;
|
||||
--warn: #f2b84b;
|
||||
--bad: #ff6b6b;
|
||||
--player: #4f8dff;
|
||||
--online: #5ff2ff;
|
||||
--wildlife: #3ecf8e;
|
||||
--pool: rgba(120, 170, 255, 0.16);
|
||||
--energy: #ffd84d;
|
||||
--carbon: #b0b7bf;
|
||||
--nitrogen: #9b7bff;
|
||||
--phosphorus: #ff9a3c;
|
||||
--other: #ff6fb5;
|
||||
--radius: 8px;
|
||||
--mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
|
||||
color-scheme: dark;
|
||||
}
|
||||
@media (prefers-color-scheme: light) {
|
||||
:root {
|
||||
--bg: #f5f7f9;
|
||||
--panel: #ffffff;
|
||||
--panel-2: #eef2f5;
|
||||
--line: #d6dde3;
|
||||
--text: #18212a;
|
||||
--muted: #5d6b77;
|
||||
--accent: #0b6bcb;
|
||||
--pool: rgba(30, 90, 200, 0.12);
|
||||
--carbon: #59626b;
|
||||
color-scheme: light;
|
||||
}
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
html, body { margin: 0; }
|
||||
body {
|
||||
background: var(--bg);
|
||||
color: var(--text);
|
||||
font: 14px/1.45 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
|
||||
}
|
||||
a { color: var(--accent); text-decoration: none; }
|
||||
a:hover { text-decoration: underline; }
|
||||
button {
|
||||
font: inherit;
|
||||
color: var(--text);
|
||||
background: var(--panel-2);
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 6px;
|
||||
padding: 5px 12px;
|
||||
cursor: pointer;
|
||||
}
|
||||
button:hover { border-color: var(--accent); }
|
||||
button.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
|
||||
button.ghost { background: transparent; }
|
||||
input[type="search"] {
|
||||
font: inherit;
|
||||
color: var(--text);
|
||||
background: var(--panel);
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 6px;
|
||||
padding: 5px 10px;
|
||||
min-width: 240px;
|
||||
}
|
||||
.muted { color: var(--muted); }
|
||||
.mono { font-family: var(--mono); font-size: 12.5px; }
|
||||
|
||||
.bar {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 24px;
|
||||
padding: 10px 20px;
|
||||
background: var(--panel);
|
||||
border-bottom: 1px solid var(--line);
|
||||
position: sticky;
|
||||
top: 0;
|
||||
z-index: 2;
|
||||
}
|
||||
.brand { font-weight: 700; color: var(--text); letter-spacing: 0.02em; }
|
||||
.brand span { color: var(--accent); font-weight: 500; }
|
||||
.sections { display: flex; gap: 20px; flex: 1; }
|
||||
.section { display: flex; align-items: center; gap: 4px; }
|
||||
.section-name {
|
||||
text-transform: uppercase;
|
||||
font-size: 11px;
|
||||
letter-spacing: 0.08em;
|
||||
color: var(--muted);
|
||||
margin-right: 6px;
|
||||
}
|
||||
.section a { padding: 5px 10px; border-radius: 6px; color: var(--text); }
|
||||
.section a.active { background: var(--panel-2); color: var(--accent); }
|
||||
.who { display: flex; align-items: center; gap: 10px; }
|
||||
|
||||
main { padding: 20px; max-width: 1600px; margin: 0 auto; }
|
||||
h1 { font-size: 20px; margin: 0 0 4px; }
|
||||
h2 { font-size: 15px; margin: 20px 0 8px; }
|
||||
.head { display: flex; align-items: baseline; justify-content: space-between; gap: 12px; flex-wrap: wrap; margin-bottom: 14px; }
|
||||
.tools { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
|
||||
|
||||
.card {
|
||||
background: var(--panel);
|
||||
border: 1px solid var(--line);
|
||||
border-radius: var(--radius);
|
||||
padding: 14px 16px;
|
||||
}
|
||||
.stats { display: grid; grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 10px; margin-bottom: 14px; }
|
||||
.stat { background: var(--panel); border: 1px solid var(--line); border-radius: var(--radius); padding: 10px 12px; }
|
||||
.stat .label { font-size: 11px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--muted); }
|
||||
.stat .value { font-size: 18px; font-weight: 600; margin-top: 2px; }
|
||||
.stat .value small { font-size: 12px; font-weight: 400; color: var(--muted); }
|
||||
|
||||
.table-wrap { overflow-x: auto; border: 1px solid var(--line); border-radius: var(--radius); }
|
||||
table { border-collapse: collapse; width: 100%; background: var(--panel); }
|
||||
th, td { text-align: left; padding: 7px 10px; border-bottom: 1px solid var(--line); white-space: nowrap; }
|
||||
th { font-size: 11px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--muted); background: var(--panel-2); cursor: pointer; user-select: none; }
|
||||
th.sorted::after { content: " ▾"; }
|
||||
th.sorted.up::after { content: " ▴"; }
|
||||
td.num, th.num { text-align: right; font-variant-numeric: tabular-nums; }
|
||||
tbody tr:hover { background: var(--panel-2); }
|
||||
tbody tr.clickable { cursor: pointer; }
|
||||
|
||||
.badge {
|
||||
display: inline-block;
|
||||
font-size: 11.5px;
|
||||
padding: 1px 8px;
|
||||
border-radius: 999px;
|
||||
border: 1px solid var(--line);
|
||||
color: var(--muted);
|
||||
}
|
||||
.badge.alive { color: var(--good); border-color: var(--good); }
|
||||
.badge.dead { color: var(--bad); border-color: var(--bad); }
|
||||
.badge.online { color: var(--online); border-color: var(--online); }
|
||||
.badge.warn { color: var(--warn); border-color: var(--warn); }
|
||||
|
||||
dl.facts { display: grid; grid-template-columns: max-content 1fr; gap: 6px 18px; margin: 0; }
|
||||
dl.facts dt { color: var(--muted); }
|
||||
dl.facts dd { margin: 0; }
|
||||
|
||||
.region-layout { display: grid; grid-template-columns: minmax(0, 1fr) 320px; gap: 14px; }
|
||||
@media (max-width: 1000px) { .region-layout { grid-template-columns: 1fr; } }
|
||||
.canvas-wrap {
|
||||
position: relative;
|
||||
background: var(--panel);
|
||||
border: 1px solid var(--line);
|
||||
border-radius: var(--radius);
|
||||
overflow: hidden;
|
||||
aspect-ratio: 1 / 1;
|
||||
max-height: calc(100vh - 230px);
|
||||
width: 100%;
|
||||
}
|
||||
.canvas-wrap canvas { display: block; width: 100%; height: 100%; cursor: crosshair; }
|
||||
.overlay-note { position: absolute; left: 10px; bottom: 8px; font-size: 12px; color: var(--muted); pointer-events: none; }
|
||||
.tooltip {
|
||||
position: absolute;
|
||||
pointer-events: none;
|
||||
background: var(--panel-2);
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 6px;
|
||||
padding: 6px 8px;
|
||||
font-size: 12px;
|
||||
max-width: 280px;
|
||||
z-index: 1;
|
||||
}
|
||||
.side { display: flex; flex-direction: column; gap: 12px; }
|
||||
.legend { display: grid; grid-template-columns: 14px 1fr; gap: 6px 8px; align-items: center; font-size: 13px; }
|
||||
.swatch { width: 12px; height: 12px; border-radius: 50%; }
|
||||
.swatch.player { background: var(--player); }
|
||||
.swatch.online { background: var(--online); }
|
||||
.swatch.wildlife { background: var(--wildlife); }
|
||||
.swatch.pool { background: var(--pool); border: 1px solid var(--accent); }
|
||||
.swatch.energy { background: var(--energy); }
|
||||
.swatch.carbon { background: var(--carbon); }
|
||||
.swatch.nitrogen { background: var(--nitrogen); }
|
||||
.swatch.phosphorus { background: var(--phosphorus); }
|
||||
.swatch.other { background: var(--other); }
|
||||
.toggles { display: flex; flex-direction: column; gap: 6px; }
|
||||
.toggles label { display: flex; gap: 8px; align-items: center; cursor: pointer; }
|
||||
.error { color: var(--bad); }
|
||||
.center { display: grid; place-items: center; min-height: 50vh; text-align: center; }
|
||||
@@ -55,6 +55,7 @@
|
||||
#include "evo/biology/founder.hpp"
|
||||
#include "evo/processes/development_opening.hpp"
|
||||
#include "evo/server/cellular_session_batch.hpp"
|
||||
#include "evo/server/lifecycle/cellular_admin_view.hpp"
|
||||
#include "evo/server/lifecycle/cellular_schedule.hpp"
|
||||
#include "evo/server/lifecycle/primitive_lives.hpp"
|
||||
#include "evo/server/lifecycle/wildlife_controller.hpp"
|
||||
@@ -925,7 +926,9 @@ int serve_cellular(Options& o) {
|
||||
return 2;
|
||||
std::unique_ptr<server::OpsServer> ops;
|
||||
if (!o.ops_listen.empty()) {
|
||||
auto listening = server::OpsServer::listen(o.ops_listen);
|
||||
// Room for /admin/view (ADR-0182); probes and metrics stay small.
|
||||
auto listening = server::OpsServer::listen(
|
||||
o.ops_listen, server::OpsServer::max_configurable_response_bytes);
|
||||
if (!listening) {
|
||||
std::puts("error ops-listen");
|
||||
return 2;
|
||||
@@ -1092,6 +1095,20 @@ int serve_cellular(Options& o) {
|
||||
counters.checkpoint_age_ms = schedule.status().head_age_us / 1000;
|
||||
return {200, server::render_metrics(paced, counters)};
|
||||
}
|
||||
// ADR-0182: the admin portal's read-only region view. The port admits only
|
||||
// Prometheus and the admin API (NetworkPolicy).
|
||||
if (path == "/admin/view") {
|
||||
const auto* state = host.state();
|
||||
if (!current.ready || state == nullptr)
|
||||
return {503, "not ready\n"};
|
||||
const auto online = [&](const server::LifeAccount& account) {
|
||||
network::AccountId id;
|
||||
id.bytes = account;
|
||||
return bridge->sessions().holder(id).has_value();
|
||||
};
|
||||
return {200, server::render_cellular_admin_view(*state, online),
|
||||
"application/json"};
|
||||
}
|
||||
return {404, "not found\n"};
|
||||
};
|
||||
ops->serve(handler);
|
||||
|
||||
@@ -145,7 +145,8 @@ RUN cmake --preset release -B build/postgres -DCMAKE_CXX_COMPILER=g++-14 \
|
||||
-DCMAKE_C_COMPILER=gcc-14 -DEVO_BUILD_NETWORK=ON \
|
||||
-DEVO_BUILD_QUIC=ON -DEVO_BUILD_POSTGRES=ON \
|
||||
-DPostgreSQL_ROOT=/source/.cache/postgres/install \
|
||||
&& cmake --build build/postgres --target evo-server evo-session-probe evo-world-clone evo-grant-broker --parallel "${PG_BUILD_JOBS}"
|
||||
&& cmake --build build/postgres --target evo-server evo-session-probe evo-world-clone evo-grant-broker \
|
||||
evo-admin-api --parallel "${PG_BUILD_JOBS}"
|
||||
|
||||
FROM postgres-build AS postgres-test-build
|
||||
ARG PG_BUILD_JOBS=6
|
||||
@@ -202,6 +203,9 @@ COPY --from=postgres-build /source/build/postgres/evo-server /usr/local/bin/evo-
|
||||
COPY --from=postgres-build /source/build/postgres/evo-world-clone /usr/local/bin/evo-world-clone
|
||||
# ADR-0131 grant broker (Keycloak tokens to session grants); its own Deployment.
|
||||
COPY --from=postgres-build /source/build/postgres/evo-grant-broker /usr/local/bin/evo-grant-broker
|
||||
# ADR-0182 read-only admin API and the portal's static files; its own Deployment.
|
||||
COPY --from=postgres-build /source/build/postgres/evo-admin-api /usr/local/bin/evo-admin-api
|
||||
COPY apps/evo-admin-api/portal/ /usr/local/share/evo-admin-portal/
|
||||
COPY --from=postgres-build /source/.cache/postgres/install/lib/libpq.so* /opt/postgres/lib/
|
||||
COPY --from=postgres-build /source/build/postgres/msquic/bin/Release/libmsquic.so* /opt/msquic/lib/
|
||||
COPY --from=postgres-build /source/.cache/postgres/postgresql-18.6/COPYRIGHT /usr/share/doc/evo-postgres/COPYRIGHT
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
# ADR-0182 read-only admin API and portal. One replica; it holds no state but a short view
|
||||
# cache. The realm's public signing key is pinned below (ADMIN_JWKS, the same key as the grant
|
||||
# broker's); a Keycloak key rotation needs a Git update in both.
|
||||
apiVersion: apps/v1
|
||||
kind: Deployment
|
||||
metadata:
|
||||
name: evo-admin-portal
|
||||
annotations:
|
||||
argocd.argoproj.io/sync-wave: "2" # After migration (schema v61).
|
||||
labels:
|
||||
app.kubernetes.io/name: evo-admin-portal
|
||||
app.kubernetes.io/component: admin-portal
|
||||
spec:
|
||||
replicas: 1
|
||||
revisionHistoryLimit: 3
|
||||
progressDeadlineSeconds: 180
|
||||
selector:
|
||||
matchLabels:
|
||||
app.kubernetes.io/name: evo-admin-portal
|
||||
template:
|
||||
metadata:
|
||||
labels:
|
||||
app.kubernetes.io/name: evo-admin-portal
|
||||
app.kubernetes.io/component: admin-portal
|
||||
app.kubernetes.io/part-of: aevolution
|
||||
spec:
|
||||
serviceAccountName: aevolution-admin-portal
|
||||
automountServiceAccountToken: false
|
||||
terminationGracePeriodSeconds: 10
|
||||
securityContext:
|
||||
runAsNonRoot: true
|
||||
runAsUser: 10001
|
||||
runAsGroup: 10001
|
||||
fsGroup: 10001
|
||||
seccompProfile: {type: RuntimeDefault}
|
||||
containers:
|
||||
- name: evo-admin-api
|
||||
image: aevolution-server
|
||||
command: ["/bin/bash", "-c"]
|
||||
args:
|
||||
- |
|
||||
set -eu
|
||||
regions=()
|
||||
for region in $ADMIN_REGIONS; do regions+=(--region "$region"); done
|
||||
exec /usr/local/bin/evo-admin-api --listen 0.0.0.0:8080 --world "$ADMIN_WORLD" \
|
||||
--jwks "$ADMIN_JWKS" --oidc-issuer "$ADMIN_OIDC_ISSUER" \
|
||||
--audience aevolution-admin --client aevolution-admin-portal \
|
||||
--role aevolution-admin --assets /usr/local/share/evo-admin-portal \
|
||||
--pg-service /run/postgres/pg_service.conf --pg-passfile /run/postgres/pgpass \
|
||||
"${regions[@]}"
|
||||
env:
|
||||
- {name: ADMIN_WORLD, value: "100"}
|
||||
# Space-separated REGION=HOST:PORT: each region's operations address for /admin/view.
|
||||
- {name: ADMIN_REGIONS, value: "16=evo-region-ops:9100"}
|
||||
- {name: ADMIN_OIDC_ISSUER, value: "https://auth.aeternalisgames.com/realms/aeternalis"}
|
||||
# Public RS256 signing key(s) of realm aeternalis, from its JWKS endpoint.
|
||||
- name: ADMIN_JWKS
|
||||
value: '{"keys":[{"alg":"RS256","e":"AQAB","kid":"NGQG4QzQuBCIHVEomUPy-OoWOTVQIuyf3RXqeNbP8JI","kty":"RSA","n":"vvOpu1xxdyH_mB8LkJG6cwc6UVmmAj6mwQi1oEwrpJDLerBI2OZr2kpgMAUJ3-hMIkz5tRtSjHieMFteVrpDDQaCViIPCIvJTL3T7ujTGFNReSE6ho7h0DB_kybFeEWVpLqm6SSXWFYls5TKo6_t8Hw4G3njiRW9pX_NxyaBHqLkrCi63EyIGHOkdgUczg2d4pM4JTt-q25bcFSlYz8bhD3WEORQmbp-bU7aPPluCqCEAZRrbzf8Iy7svNemP5daDdlWQ3LaNy-ixC2HRjiPZdqK5BgAE800BigI-l1dkyJ4X172TLIPVPLW1WKlvdm3kHOpBXwACYiy8boSNDW7gQ","use":"sig"}]}'
|
||||
ports:
|
||||
- {name: http, containerPort: 8080, protocol: TCP}
|
||||
readinessProbe:
|
||||
httpGet: {path: /healthz, port: http}
|
||||
periodSeconds: 5
|
||||
timeoutSeconds: 1
|
||||
livenessProbe:
|
||||
httpGet: {path: /healthz, port: http}
|
||||
initialDelaySeconds: 5
|
||||
periodSeconds: 10
|
||||
timeoutSeconds: 2
|
||||
failureThreshold: 3
|
||||
resources:
|
||||
requests: {cpu: 10m, memory: 16Mi}
|
||||
limits: {memory: 128Mi}
|
||||
securityContext:
|
||||
allowPrivilegeEscalation: false
|
||||
readOnlyRootFilesystem: true
|
||||
capabilities: {drop: [ALL]}
|
||||
volumeMounts:
|
||||
- {name: connection, mountPath: /run/postgres, readOnly: true}
|
||||
volumes:
|
||||
- name: connection
|
||||
secret:
|
||||
secretName: aevolution-admin-pg
|
||||
defaultMode: 0440
|
||||
items:
|
||||
- {key: pg_service.conf, path: pg_service.conf}
|
||||
- {key: pgpass, path: pgpass}
|
||||
- {key: ca.crt, path: ca.crt}
|
||||
@@ -0,0 +1,15 @@
|
||||
# ADR-0182 read-only admin API and portal for evolution-dev ONLY: verifies Keycloak access
|
||||
# tokens (realm aeternalis, realm role aevolution-admin, audience aevolution-admin) and reads
|
||||
# world 100 through the schema v61 views and region 16's /admin/view.
|
||||
# Public route, 443 only: https://srs.aeternalisgames.com -> ingress-nginx (TLS; Ingress
|
||||
# created out of band, since the aevolution-dev Argo project admits none) -> ClusterIP
|
||||
# Service evo-admin-portal:8080, in-cluster only.
|
||||
# Out-of-band Secret in evolution-dev: aevolution-admin-pg (pg_service.conf, pgpass, ca.crt
|
||||
# for a login in the runtime group, as aevolution-grant-broker-pg).
|
||||
apiVersion: kustomize.config.k8s.io/v1alpha1
|
||||
kind: Component
|
||||
resources:
|
||||
- serviceaccount.yaml
|
||||
- deployment.yaml
|
||||
- service.yaml
|
||||
- networkpolicy.yaml
|
||||
@@ -0,0 +1,58 @@
|
||||
# Admin portal traffic on top of the namespace default-deny. Admins reach it only at
|
||||
# https://srs.aeternalisgames.com on 443, where ingress-nginx terminates TLS; port 8080 is
|
||||
# admitted from the ingress-nginx pods and nothing else. Egress: PostgreSQL on pg-forge-01
|
||||
# and the region's operations port (9100) for /admin/view.
|
||||
apiVersion: networking.k8s.io/v1
|
||||
kind: NetworkPolicy
|
||||
metadata:
|
||||
name: evo-admin-portal
|
||||
annotations:
|
||||
argocd.argoproj.io/sync-wave: "-1"
|
||||
spec:
|
||||
podSelector:
|
||||
matchLabels:
|
||||
app.kubernetes.io/name: evo-admin-portal
|
||||
policyTypes: [Ingress, Egress]
|
||||
ingress:
|
||||
- from:
|
||||
- namespaceSelector:
|
||||
matchLabels:
|
||||
kubernetes.io/metadata.name: kube-system
|
||||
podSelector:
|
||||
matchLabels:
|
||||
app.kubernetes.io/name: rke2-ingress-nginx
|
||||
ports:
|
||||
- {protocol: TCP, port: 8080}
|
||||
egress:
|
||||
- to:
|
||||
- ipBlock:
|
||||
cidr: 172.10.1.127/32
|
||||
ports:
|
||||
- {protocol: TCP, port: 5432}
|
||||
- to:
|
||||
- podSelector:
|
||||
matchLabels:
|
||||
app.kubernetes.io/name: evo-region
|
||||
ports:
|
||||
- {protocol: TCP, port: 9100}
|
||||
---
|
||||
# The region's operations port also admits the admin portal (alongside Prometheus,
|
||||
# evo-region-scrape). Only 9100: never the session port.
|
||||
apiVersion: networking.k8s.io/v1
|
||||
kind: NetworkPolicy
|
||||
metadata:
|
||||
name: evo-region-admin-view
|
||||
annotations:
|
||||
argocd.argoproj.io/sync-wave: "-1"
|
||||
spec:
|
||||
podSelector:
|
||||
matchLabels:
|
||||
app.kubernetes.io/name: evo-region
|
||||
policyTypes: [Ingress]
|
||||
ingress:
|
||||
- from:
|
||||
- podSelector:
|
||||
matchLabels:
|
||||
app.kubernetes.io/name: evo-admin-portal
|
||||
ports:
|
||||
- {protocol: TCP, port: 9100}
|
||||
@@ -0,0 +1,15 @@
|
||||
# Cluster-internal; the Ingress for srs.aeternalisgames.com terminates TLS and forwards here.
|
||||
apiVersion: v1
|
||||
kind: Service
|
||||
metadata:
|
||||
name: evo-admin-portal
|
||||
annotations:
|
||||
argocd.argoproj.io/sync-wave: "2"
|
||||
labels:
|
||||
app.kubernetes.io/name: evo-admin-portal
|
||||
spec:
|
||||
type: ClusterIP
|
||||
selector:
|
||||
app.kubernetes.io/name: evo-admin-portal
|
||||
ports:
|
||||
- {name: http, port: 8080, targetPort: http, protocol: TCP}
|
||||
@@ -0,0 +1,10 @@
|
||||
apiVersion: v1
|
||||
kind: ServiceAccount
|
||||
metadata:
|
||||
name: aevolution-admin-portal
|
||||
annotations:
|
||||
argocd.argoproj.io/sync-wave: "-1"
|
||||
automountServiceAccountToken: false
|
||||
# Create this pull-only Secret separately in evolution-dev; never commit credentials.
|
||||
imagePullSecrets:
|
||||
- name: harbor-pull
|
||||
@@ -9,6 +9,7 @@ resources:
|
||||
components:
|
||||
- ../dev-session-route
|
||||
- ../../grant-broker-dev
|
||||
- ../../admin-portal-dev
|
||||
- ../../worker-only-dev
|
||||
images:
|
||||
- name: aevolution-server
|
||||
|
||||
@@ -1,5 +1,17 @@
|
||||
# Project status and next steps
|
||||
|
||||
## Read-only admin portal - 2026-10-27
|
||||
|
||||
[ADR-0182](adr/0182-admin-portal-and-world-tuning.md) records the admin portal direction
|
||||
(world tuning in SQL adopted per tick, admin commands, data-defined mutations) and delivers
|
||||
its read-only first step: `evo-admin-api` and the portal at `https://srs.aeternalisgames.com`
|
||||
behind the Keycloak realm role `aevolution-admin`. It lists accounts (session, status,
|
||||
lives, deaths, resets, mutation choices), one account's lives, the world's regions, and a
|
||||
live 2D view of a region's cells, wildlife, pools and bubbles from the region's new
|
||||
`/admin/view` ops route. Schema 61 adds only read functions. Nothing in the simulation,
|
||||
wire protocol or checkpoints changed. Not yet deployed: it needs a new server image, the
|
||||
Keycloak client, an Ingress and a database Secret. See [validation](engineering/VALIDATION.md).
|
||||
|
||||
## Reproduction safety trial and resizable cards - 2026-10-27
|
||||
|
||||
[ADR-0181](adr/0181-cellular-reproduction-safety.md) declares opt-in safety
|
||||
|
||||
@@ -23,7 +23,7 @@ may change a running region except an event recorded at a tick.
|
||||
|
||||
### 1. World tuning lives in SQL
|
||||
|
||||
- Schema 61 adds append-only `world_tuning_revisions(world, revision, parent_revision,
|
||||
- Schema 62 adds append-only `world_tuning_revisions(world, revision, parent_revision,
|
||||
format, canonical_text, digest, author_subject, reason, created_at)`. A revision is the
|
||||
complete canonical tuning text (`encode_cellular_revamp_tuning`), never a diff, so the
|
||||
existing parser and validator are the only interpretation.
|
||||
@@ -51,7 +51,7 @@ may change a running region except an event recorded at a tick.
|
||||
|
||||
### 3. Admin commands
|
||||
|
||||
- Schema 61 adds `admin_commands(world, region, command_id, kind, payload, author_subject,
|
||||
- Schema 62 adds `admin_commands(world, region, command_id, kind, payload, author_subject,
|
||||
reason, created_at, applied_tick, outcome)`. The admin API inserts and the region host
|
||||
drains them at tick boundaries in id order, publishing each with that tick. This is the
|
||||
same pattern as the durable mutation queue (schema 59).
|
||||
@@ -121,24 +121,53 @@ pool holds. For the source, scale multiplies the import.
|
||||
### 7. Admin API and portal
|
||||
|
||||
- `evo-admin-api`: a C++ service built like the grant broker. It verifies Keycloak access
|
||||
tokens against the realm keys pinned in Git, requires audience `aevolution-admin` and
|
||||
realm role `aevolution-admin`, and has its own database login limited to the read views
|
||||
and the admin tables. Configured world allowlist; World0 is refused in code.
|
||||
tokens against the realm keys pinned in Git, requires audience `aevolution-admin`,
|
||||
authorized party `aevolution-admin-portal` and realm role `aevolution-admin`, and serves
|
||||
one configured world. Its component exists only in the evolution-dev overlay; World0 and
|
||||
stage have no admin portal (World0 has no fixed world id to refuse in code).
|
||||
- Every write records the token subject and a reason.
|
||||
- The region view: the region host's internal ops port gains a bounded snapshot route (cell
|
||||
id, position, radius, wildlife/player and account, bubbles), reachable only from the admin
|
||||
id, position, extent, wildlife/player and account, bubbles), reachable only from the admin
|
||||
API by NetworkPolicy. The admin API serves it to the portal at up to 1 Hz.
|
||||
- The portal is a static browser application at `https://srs.aeternalisgames.com`
|
||||
(section **Cellular** now, **3D** later) using authorization code with PKCE. Its toolchain is chosen in the implementation change
|
||||
with dependency evidence (DEPENDENCY_EVALUATION.md).
|
||||
(section **Cellular** now, **3D** later) using authorization code with PKCE. It is plain
|
||||
HTML, CSS and JavaScript with no third-party code, so no dependency evaluation is needed.
|
||||
- Keycloak (maintainer setup): realm role `aevolution-admin`; public client
|
||||
`aevolution-admin-portal` with PKCE S256; an audience mapper adding `aevolution-admin`;
|
||||
MFA required for the role.
|
||||
`aevolution-admin-portal` with standard flow and PKCE S256, redirect URI
|
||||
`https://srs.aeternalisgames.com/*`, web origin `https://srs.aeternalisgames.com` and
|
||||
post-logout redirect `https://srs.aeternalisgames.com/`; an audience mapper adding
|
||||
`aevolution-admin`; MFA required for the role.
|
||||
|
||||
### 8. Read-only portal (delivered first, schema 61)
|
||||
|
||||
- **Schema 61** adds three bounded, read-only SECURITY DEFINER functions, executable by the
|
||||
runtime group and listed in the privilege audit: `admin_accounts_v1(world)` (every account
|
||||
with its identity, session control, lives, deaths, active life and mutation-choice count),
|
||||
`admin_account_lives_v1(world, account)` (its life requests and endings) and
|
||||
`admin_regions_v1(world)` (leases and heads). No table or existing function changes. The
|
||||
runtime group still has no table privilege. DEV's admin API logs in with its own login in
|
||||
that group, as the grant broker does; a dedicated read role is a later least-privilege step.
|
||||
- **Derived values.** A life is a published, unrefused reservation; a death is an ended one;
|
||||
resets are lives after the first; logged in means the session control has not expired.
|
||||
- **Region view.** `GET /admin/view` on the cellular region's ops port renders the committed
|
||||
in-memory owner (`render_cellular_admin_view`): every cell (life and organism ids as
|
||||
strings, account, footprint, extent, wildlife/connected/lingering/suspended flags,
|
||||
members, reserve, body mass) and every pool and bubble, bounded to 4,096 cells and 16,384
|
||||
deposits with totals. It reads without changing anything; the ops server's response
|
||||
bound becomes configurable (4 MiB for this port), default 16 KiB elsewhere.
|
||||
- **Portal files and headers.** The image ships the portal under
|
||||
`/usr/local/share/evo-admin-portal`. Files go out with a strict Content-Security-Policy
|
||||
(`'self'` scripts and styles, connections only to this origin and the realm), `nosniff`,
|
||||
`no-referrer` and `DENY` framing; every answer is `no-store`. The access token stays in
|
||||
page memory and the rotating refresh token in the tab's sessionStorage.
|
||||
- **Not yet available** (they need the schema-62 records): time played, bans, current
|
||||
mutations and living offspring.
|
||||
|
||||
## Delivery order
|
||||
|
||||
1. Read-only portal: login, accounts (from existing data), regions, census, region view.
|
||||
2. Schema 61 and the new owner format: world revisions, adoption records, admin commands,
|
||||
1. Read-only portal: login, accounts (from existing data), regions, region view (schema 61,
|
||||
section 8).
|
||||
2. Schema 62 and the new owner format: world revisions, adoption records, admin commands,
|
||||
game source, drip settings, the score vector, session intervals and bans. One new
|
||||
opening on that format.
|
||||
3. Admin commands and account actions in the portal.
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
# Architecture decision records
|
||||
|
||||
- [ADR-0182: Admin portal, world tuning in SQL and per-tick amendments](0182-admin-portal-and-world-tuning.md) - accepted direction: world tuning revisions in SQL adopted per tick and recorded in region history, admin commands with a named game source, drip/source settings, data-defined mutations, bans and session intervals, and a Keycloak-gated admin API and portal; migration and new matter types deferred.
|
||||
- [ADR-0182: Admin portal, world tuning in SQL and per-tick amendments](0182-admin-portal-and-world-tuning.md) - accepted direction: world tuning revisions in SQL adopted per tick and recorded in region history, admin commands with a named game source, drip/source settings, data-defined mutations, bans and session intervals, and a Keycloak-gated admin API and portal; the read-only portal (schema 61 read views and the region view) comes first; migration and new matter types deferred.
|
||||
|
||||
- [ADR-0181: Reproduction safety revision 1](0181-cellular-reproduction-safety.md) - opt-in controlled-cell mutation share, retained budding provision, outward mutation launch and a protected growth fuel buffer; historical declarations unchanged.
|
||||
|
||||
|
||||
@@ -10414,3 +10414,60 @@ command, and another unique session activation expiring four hours ahead. No
|
||||
credential values, credential file, remote URL change or credential-store change
|
||||
are included in the repository; temporary helpers stay in ignored build output.
|
||||
No deployment or live-reachability claim follows from publication.
|
||||
|
||||
## 2026-10-27 - Read-only admin portal (ADR-0182 step 1, schema 61)
|
||||
|
||||
Scope: ADR-0182's read-only first step. `evo-admin-api` (Keycloak realm role
|
||||
`aevolution-admin`, audience `aevolution-admin`, client `aevolution-admin-portal`) serves
|
||||
the static portal and read-only JSON for world 100; schema 61 adds three bounded
|
||||
SECURITY DEFINER read functions; the cellular region's ops port gains `/admin/view`.
|
||||
The token verifier gains an optional realm-role rule and returns the email; the ops
|
||||
server's response bound becomes configurable (default unchanged). No simulation rule,
|
||||
checkpoint, manifest, wire protocol, genome or golden changed; `extent_of` reads the
|
||||
existing phenotype budget.
|
||||
|
||||
Also fixed a pre-existing PostgreSQL failure (`region store test line 826`, also seen in
|
||||
Gitea run 542): since 054e485 the DEV revamp tuning file seeds 100 wildlife, which
|
||||
`evo-world-clone provision` refuses without an audited `--playtest-wildlife-first-id`
|
||||
range. The cellular-v10 provisioning test now provisions the Git file's rules with its
|
||||
DEV opening fixture set to zero; seeded wildlife keeps its own suite. Earlier push builds
|
||||
skipped the PostgreSQL gate, and the 09:00 nightly (run 539) stopped at the format check,
|
||||
so the failure had not surfaced.
|
||||
|
||||
Executed (WSL Ubuntu, GCC 14.2 Release/NDEBUG, existing build/m97-postgres with network,
|
||||
QUIC and PostgreSQL):
|
||||
|
||||
- Built evo-server, evo-world-clone, evo-grant-broker, evo-admin-api, evo-postgres-tests
|
||||
and evo-cellular-admin-view-tests with -Werror (two missing-field-initializer errors
|
||||
from the new aggregate members were fixed with default initializers).
|
||||
- `cellular-admin-view-contracts` passed: header, totals, every cell row (id strings,
|
||||
account text, position, extent, connected flag, members), the cell and deposit limits
|
||||
keeping the lowest ids, empty lists, and an unchanged owner snapshot after rendering.
|
||||
- `tools/ci/postgres-check.sh --suite-only` passed after the fixes above: token role
|
||||
checks (required role present, absent, wrong shape; email), the admin API over world
|
||||
9831 (public files with CSP/nosniff headers, `/config.json`, 405 for POST, 401 without or
|
||||
with a foreign token, 403 without the role, no database contact before verification,
|
||||
accounts with session/status/lives/resets, one account, 404s, regions, the view cache,
|
||||
unviewable and unreachable regions, an offline database as 503, and the runtime role
|
||||
still refused direct table reads), the migration path to schema 61 with the privilege
|
||||
audit's new fenced functions, and the updated migration history expectation.
|
||||
- `tools/ci/postgres-check.sh --full` passed (634 s: suite, migration partitions, life
|
||||
reservations, backup, DR, upgrade, migration history, permission audit, checksum drift).
|
||||
Two CI scripts that pin the newest schema were updated: history-domain-check's schema-50
|
||||
rewind now drops the three schema-61 functions first, and the unknown-future-version
|
||||
probe moves from 61 to 62.
|
||||
- clang-tidy 19 with warnings as errors on every new or changed source passed after one
|
||||
unchecked-optional fix in the view test; clang-format 19.1.5 applied to changed C++.
|
||||
- Deploy suite (deploy-policy-check 80 objects / 150 rendered in 17 overlays, selftest,
|
||||
ops-lib-check) passed with the new admin-portal-dev component.
|
||||
- Local process smoke of the built evo-admin-api with the realm's pinned JWKS and a
|
||||
placeholder (unreachable) database: `/`, `/app.js`, `/style.css`, `/config.json`,
|
||||
`/healthz` answered 200 with the expected types and security headers, `/api/accounts`
|
||||
401 for a malformed token, `/missing` 404; no arguments exit 2 with usage.
|
||||
- `node --check` on the portal script.
|
||||
|
||||
Limits: no Keycloak sign-in, browser session or live region view was exercised (the
|
||||
Keycloak client, Ingress, Secret and a new server image are not in place yet); account
|
||||
lives and deaths were checked only on accounts without lives. The MSVC and sanitizer
|
||||
presets and the image build/smoke were not run locally. Nothing was deployed, pushed or
|
||||
synced; no World0, stage or live database operation occurred.
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
#pragma once
|
||||
|
||||
#include "evo/persistence/postgres.hpp"
|
||||
#include "evo/server/broker/access_token.hpp"
|
||||
#include "evo/server/ops_http.hpp"
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <vector>
|
||||
|
||||
// ADR-0182 read-only admin API and portal host. One world; every /api route needs a Keycloak
|
||||
// access token carrying the admin realm role. The portal's static files and its OIDC settings
|
||||
// are public; they carry no secret.
|
||||
//
|
||||
// GET /healthz ok
|
||||
// GET / and the portal's files the portal (index.html, app.js, style.css)
|
||||
// GET /config.json issuer, client id and world for the portal's sign-in
|
||||
// GET /api/me the signed-in admin's subject and email
|
||||
// GET /api/accounts every account with session, lives, deaths and resets
|
||||
// GET /api/accounts/<uuid> one account and its life requests
|
||||
// GET /api/regions the world's regions, leases and heads
|
||||
// GET /api/regions/<n>/view the region's live view (render_cellular_admin_view)
|
||||
namespace evo::server::admin {
|
||||
struct AdminAsset {
|
||||
std::string path; // "/index.html", ...; "/" serves "/index.html".
|
||||
std::string content_type, body;
|
||||
};
|
||||
struct AdminConfig {
|
||||
std::uint64_t world{};
|
||||
std::vector<std::uint64_t> view_regions; // Regions whose live view can be fetched.
|
||||
std::string portal_config_json; // Served at /config.json.
|
||||
std::string content_security_policy; // Sent with every portal file.
|
||||
std::chrono::milliseconds db_timeout{3000};
|
||||
std::chrono::milliseconds view_cache{750}; // A fetched view answers repeats this long.
|
||||
};
|
||||
using AdminConnect = std::function<std::unique_ptr<persistence::Postgres>()>;
|
||||
// The region's /admin/view body, or nullopt when it cannot be reached or is not ready.
|
||||
using AdminRegionView = std::function<std::optional<std::string>(std::uint64_t region)>;
|
||||
|
||||
class AdminApi {
|
||||
public:
|
||||
AdminApi(AdminConfig config, broker::TokenVerifier verifier, AdminConnect connect,
|
||||
AdminRegionView view, std::vector<AdminAsset> assets);
|
||||
// `now_seconds` is wall time (token expiry); `now` paces the view cache.
|
||||
[[nodiscard]] OpsResponse handle(const ApiRequest& request, std::uint64_t now_seconds,
|
||||
std::chrono::steady_clock::time_point now);
|
||||
|
||||
private:
|
||||
[[nodiscard]] OpsResponse api(std::string_view path, const broker::AccessTokenClaims& admin,
|
||||
std::chrono::steady_clock::time_point now);
|
||||
[[nodiscard]] OpsResponse accounts(std::optional<std::string_view> account);
|
||||
[[nodiscard]] OpsResponse regions();
|
||||
[[nodiscard]] OpsResponse view(std::uint64_t region, std::chrono::steady_clock::time_point now);
|
||||
[[nodiscard]] std::optional<persistence::PgRows> query(const std::string& sql,
|
||||
std::vector<std::string> parameters);
|
||||
|
||||
AdminConfig config_;
|
||||
broker::TokenVerifier verifier_;
|
||||
AdminConnect connect_;
|
||||
AdminRegionView view_;
|
||||
std::vector<AdminAsset> assets_;
|
||||
std::unique_ptr<persistence::Postgres> db_;
|
||||
struct CachedView {
|
||||
std::chrono::steady_clock::time_point at;
|
||||
std::string body;
|
||||
};
|
||||
std::map<std::uint64_t, CachedView> views_;
|
||||
};
|
||||
|
||||
// Bounded blocking HTTP/1.1 GET of `path` from "host:port" (a name is resolved): the body of
|
||||
// a 200 answer of at most `limit` bytes, or nullopt on any error, other status or timeout.
|
||||
[[nodiscard]] std::optional<std::string> http_get(std::string_view address, std::string_view path,
|
||||
std::chrono::milliseconds timeout,
|
||||
std::size_t limit);
|
||||
// JSON string literal (quotes included) with control characters escaped.
|
||||
[[nodiscard]] std::string json_string(std::string_view text);
|
||||
} // namespace evo::server::admin
|
||||
@@ -17,10 +17,13 @@ struct AccessTokenRules {
|
||||
std::string audience; // Must appear in `aud` (string or array).
|
||||
std::string authorized_party; // `azp`: the game's public client.
|
||||
std::uint64_t leeway_seconds{30};
|
||||
// ADR-0182: when set, the role must appear in `realm_access.roles` (the admin portal).
|
||||
std::string realm_role{};
|
||||
};
|
||||
struct AccessTokenClaims {
|
||||
std::string issuer, subject;
|
||||
std::uint64_t expires_at{};
|
||||
std::string email{}; // Empty when absent; shown to the admin, never used as identity.
|
||||
};
|
||||
enum class TokenError : std::uint8_t {
|
||||
malformed,
|
||||
@@ -34,7 +37,8 @@ enum class TokenError : std::uint8_t {
|
||||
expired,
|
||||
not_yet_valid,
|
||||
unverified_email,
|
||||
missing_subject
|
||||
missing_subject,
|
||||
missing_role
|
||||
};
|
||||
inline constexpr std::size_t max_access_token_bytes = 6144;
|
||||
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
#pragma once
|
||||
|
||||
#include "evo/server/lifecycle/cellular_lives.hpp"
|
||||
|
||||
#include <cstddef>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
|
||||
// ADR-0182 read-only region view for the admin portal: every cell, pool and bubble of a
|
||||
// cellular owner as compact JSON. It reads the committed in-memory state and changes nothing;
|
||||
// it is not a simulation output, a checkpoint or a client protocol.
|
||||
//
|
||||
// {"world":W,"region":R,"tick":T,"rules":N,"area":[w,h],
|
||||
// "spent":[e,c,n,p,o],"cells_total":N,"deposits_total":N,
|
||||
// "cells":[["life","organism","account",x,y,extent,flags,members,
|
||||
// reserve_e,reserve_c,reserve_n,reserve_p,reserve_o,body_mass],...],
|
||||
// "deposits":[[id,kind,x,y,radius,e,c,n,p,o],...]}
|
||||
//
|
||||
// Cell positions are the lower-left corner of the square footprint and deposits their centre,
|
||||
// in micrometres. Life and organism ids are decimal strings (bud ids exceed 2^53); `account`
|
||||
// is the lowercase UUID, empty for wildlife. Flags: 1 wildlife, 2 the account's session is
|
||||
// connected, 4 lingering, 8 suspended. Deposit kind: 0 patch, 1 pool, 2 bubble. Energy in
|
||||
// pJ, matter in fg. Cells and deposits beyond the limits are left out (by ascending life id
|
||||
// and deposit id); the totals still count them.
|
||||
namespace evo::server {
|
||||
struct CellularAdminViewLimits {
|
||||
std::size_t cells{4096}, deposits{16384};
|
||||
};
|
||||
// True when the account's session is connected to this region.
|
||||
using CellularAdminOnline = std::function<bool(const LifeAccount&)>;
|
||||
[[nodiscard]] std::string render_cellular_admin_view(const CellularLives& state,
|
||||
const CellularAdminOnline& online,
|
||||
CellularAdminViewLimits limits = {});
|
||||
// Lowercase 8-4-4-4-12 text of a 16-byte account.
|
||||
[[nodiscard]] std::string cellular_account_text(const LifeAccount& account);
|
||||
} // namespace evo::server
|
||||
@@ -328,6 +328,9 @@ class CellularLives {
|
||||
[[nodiscard]] accounting::Inventory heat() const noexcept;
|
||||
// Rules 13: burned matter and kill remainders waiting to drip back as bubbles.
|
||||
[[nodiscard]] accounting::Inventory spent() const noexcept;
|
||||
// ADR-0182 observers: a life's square footprint side in micrometres, as the step uses it;
|
||||
// nullopt when its genome cannot be costed. Reads the state; changes nothing.
|
||||
[[nodiscard]] std::optional<std::uint32_t> extent_of(const CellularOwnedLife& life) const;
|
||||
[[nodiscard]] accounting::Inventory opening_total() const noexcept;
|
||||
[[nodiscard]] accounting::Inventory current_total() const noexcept;
|
||||
[[nodiscard]] const CellularBoundaryLedger& boundary_ledger() const noexcept;
|
||||
|
||||
@@ -19,6 +19,7 @@ struct OpsResponse {
|
||||
int status{200};
|
||||
std::string body;
|
||||
std::string content_type{"text/plain; charset=utf-8"};
|
||||
std::string headers{}; // Extra header lines, each ending in CRLF (ADR-0182 portal).
|
||||
};
|
||||
// Receives the request path (no query handling: probes use exact paths).
|
||||
using OpsHandler = std::function<OpsResponse(std::string_view path)>;
|
||||
@@ -38,12 +39,16 @@ class OpsServer {
|
||||
static constexpr std::size_t max_accepts_per_serve = 4;
|
||||
static constexpr std::size_t max_request_bytes = 4096;
|
||||
static constexpr std::size_t max_api_request_bytes = 8192; // Room for an access token.
|
||||
static constexpr std::size_t max_response_bytes = 16384;
|
||||
static constexpr std::size_t max_response_bytes = 16384; // The default bound.
|
||||
// ADR-0182: the admin view and portal answer up to this many bytes when asked to.
|
||||
static constexpr std::size_t max_configurable_response_bytes = std::size_t{4} << 20U;
|
||||
static constexpr std::chrono::milliseconds connection_deadline{1000};
|
||||
|
||||
// Numeric address only ("127.0.0.1:9100" or "[::1]:9100"); port 0 picks one.
|
||||
// Numeric address only ("127.0.0.1:9100" or "[::1]:9100"); port 0 picks one. A
|
||||
// response over `response_limit` bytes (at most max_configurable_response_bytes) is
|
||||
// replaced by a 500.
|
||||
[[nodiscard]] static std::expected<std::unique_ptr<OpsServer>, OpsError>
|
||||
listen(std::string_view address);
|
||||
listen(std::string_view address, std::size_t response_limit = max_response_bytes);
|
||||
OpsServer(const OpsServer&) = delete;
|
||||
OpsServer& operator=(const OpsServer&) = delete;
|
||||
OpsServer(OpsServer&&) = delete;
|
||||
@@ -72,12 +77,14 @@ class OpsServer {
|
||||
std::size_t sent{};
|
||||
std::chrono::steady_clock::time_point deadline{};
|
||||
};
|
||||
OpsServer(int fd, std::uint16_t port) : fd_(fd), port_(port) {}
|
||||
OpsServer(int fd, std::uint16_t port, std::size_t response_limit)
|
||||
: fd_(fd), port_(port), response_limit_(response_limit) {}
|
||||
void respond(Connection& c, const OpsHandler& handler);
|
||||
void respond_api(Connection& c, const ApiHandler& handler);
|
||||
template <typename Answer> void serve_with(std::size_t request_limit, const Answer& answer);
|
||||
int fd_;
|
||||
std::uint16_t port_;
|
||||
std::size_t response_limit_;
|
||||
std::vector<Connection> connections_;
|
||||
std::uint64_t refused_{};
|
||||
};
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
-- Admin portal read views (ADR-0182, 2026-10-27). Three read-only, bounded SECURITY DEFINER
|
||||
-- functions for the DEV admin API: a world's accounts with their lives and session control,
|
||||
-- one account's lives, and a world's regions with their heads. Nothing is written; no table,
|
||||
-- row, constraint or existing function changes. The runtime group may execute them; DEV's
|
||||
-- admin API logs in within that group, as the grant broker does (ADR-0131).
|
||||
|
||||
-- Every account known to the world: Keycloak identities and accounts that reserved a life.
|
||||
-- A life is a published, unrefused reservation; a death is an ended one. The control row is
|
||||
-- the account's session claim (region and expiry), as the region last renewed it.
|
||||
CREATE FUNCTION evolution.admin_accounts_v1(p_world evolution.u64)
|
||||
RETURNS TABLE (account_id uuid, created_at timestamptz, issuer text, subject text,
|
||||
control_region evolution.u64, control_expires timestamptz, lives bigint, deaths bigint,
|
||||
active_life evolution.u64, active_region evolution.u64, mutation_choices bigint)
|
||||
LANGUAGE sql STABLE SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
WITH accounts AS (
|
||||
SELECT i.account_id FROM evolution.account_identities i
|
||||
UNION
|
||||
SELECT r.account_id FROM evolution.life_reservations r WHERE r.world_id = p_world
|
||||
), lives AS (
|
||||
SELECT r.account_id, r.identity, r.region_id, r.request_id, r.ended_commit
|
||||
FROM evolution.life_reservations r
|
||||
JOIN evolution.primitive_life_bindings b ON b.world_id = r.world_id
|
||||
AND b.account_id = r.account_id AND b.request_id = r.request_id
|
||||
WHERE r.world_id = p_world AND r.rejection = 0
|
||||
)
|
||||
SELECT a.account_id, i.created_at, i.issuer, i.subject, c.region_id, c.expires_at,
|
||||
(SELECT count(*) FROM lives l WHERE l.account_id = a.account_id),
|
||||
(SELECT count(*) FROM lives l WHERE l.account_id = a.account_id
|
||||
AND l.ended_commit IS NOT NULL),
|
||||
active.identity, active.region_id,
|
||||
(SELECT count(*) FROM evolution.cellular_mutation_reservations m
|
||||
WHERE m.world_id = p_world AND m.account_id = a.account_id)
|
||||
FROM accounts a
|
||||
LEFT JOIN evolution.account_identities i ON i.account_id = a.account_id
|
||||
LEFT JOIN evolution.account_controls c ON c.world_id = p_world AND c.account_id = a.account_id
|
||||
LEFT JOIN LATERAL (SELECT l.identity, l.region_id FROM lives l
|
||||
WHERE l.account_id = a.account_id AND l.ended_commit IS NULL
|
||||
ORDER BY l.request_id DESC LIMIT 1) active ON true
|
||||
ORDER BY i.created_at NULLS LAST, a.account_id
|
||||
LIMIT 10000
|
||||
$$;
|
||||
REVOKE ALL ON FUNCTION evolution.admin_accounts_v1(evolution.u64) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.admin_accounts_v1(evolution.u64) TO :"runtime_role";
|
||||
|
||||
-- One account's life requests in order: published or not, refused or not, and when an
|
||||
-- ended life's commit was published (its last tick and time).
|
||||
CREATE FUNCTION evolution.admin_account_lives_v1(p_world evolution.u64, p_account uuid)
|
||||
RETURNS TABLE (request_id evolution.u64, identity evolution.u64, region_id evolution.u64,
|
||||
rejection smallint, born evolution.u64, ended_tick evolution.u64, ended_at timestamptz)
|
||||
LANGUAGE sql STABLE SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
SELECT r.request_id, r.identity, r.region_id, r.rejection, b.born, e.end_tick, e.committed_at
|
||||
FROM evolution.life_reservations r
|
||||
LEFT JOIN evolution.primitive_life_bindings b ON b.world_id = r.world_id
|
||||
AND b.account_id = r.account_id AND b.request_id = r.request_id
|
||||
LEFT JOIN evolution.region_commits e ON e.commit_id = r.ended_commit
|
||||
WHERE r.world_id = p_world AND r.account_id = p_account
|
||||
ORDER BY r.request_id
|
||||
LIMIT 1000
|
||||
$$;
|
||||
REVOKE ALL ON FUNCTION evolution.admin_account_lives_v1(evolution.u64, uuid) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.admin_account_lives_v1(evolution.u64, uuid)
|
||||
TO :"runtime_role";
|
||||
|
||||
-- A world's regions: lease (epoch, whether held and until when) and the head commit.
|
||||
CREATE FUNCTION evolution.admin_regions_v1(p_world evolution.u64)
|
||||
RETURNS TABLE (region_id evolution.u64, frame_id evolution.u64, lease_epoch evolution.u64,
|
||||
lease_held boolean, lease_expires timestamptz, commit_sequence evolution.u64,
|
||||
end_tick evolution.u64, committed_at timestamptz, build_identity text)
|
||||
LANGUAGE sql STABLE SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
SELECT l.region_id, l.frame_id, l.epoch, l.holder IS NOT NULL, l.expires_at,
|
||||
h.commit_sequence, h.end_tick, c.committed_at, encode(c.build_identity, 'hex')
|
||||
FROM evolution.region_leases l
|
||||
LEFT JOIN evolution.region_heads h ON h.world_id = l.world_id AND h.region_id = l.region_id
|
||||
LEFT JOIN evolution.region_commits c ON c.commit_id = h.commit_id
|
||||
WHERE l.world_id = p_world
|
||||
ORDER BY l.region_id
|
||||
LIMIT 1000
|
||||
$$;
|
||||
REVOKE ALL ON FUNCTION evolution.admin_regions_v1(evolution.u64) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.admin_regions_v1(evolution.u64) TO :"runtime_role";
|
||||
|
||||
INSERT INTO evolution.schema_migrations(version,sha256) VALUES(61,:'migration_sha_61');
|
||||
+15
-3
@@ -136,6 +136,7 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
|
||||
SELECT :'history_v57' || ',58:' || :'migration_sha_58' AS history_v58 \gset
|
||||
SELECT :'history_v58' || ',59:' || :'migration_sha_59' AS history_v59 \gset
|
||||
SELECT :'history_v59' || ',60:' || :'migration_sha_60' AS history_v60 \gset
|
||||
SELECT :'history_v60' || ',61:' || :'migration_sha_61' AS history_v61 \gset
|
||||
SELECT :'history' = :'history_v22' AS at_v22,
|
||||
:'history' = :'history_v23' AS at_v23,
|
||||
:'history' = :'history_v24' AS at_v24,
|
||||
@@ -174,8 +175,10 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
|
||||
:'history' = :'history_v57' AS at_v57,
|
||||
:'history' = :'history_v58' AS at_v58,
|
||||
:'history' = :'history_v59' AS at_v59,
|
||||
:'history' = :'history_v60' AS at_v60 \gset
|
||||
\if :at_v60
|
||||
:'history' = :'history_v60' AS at_v60,
|
||||
:'history' = :'history_v61' AS at_v61 \gset
|
||||
\if :at_v61
|
||||
\elif :at_v60
|
||||
\elif :at_v59
|
||||
\elif :at_v58
|
||||
\elif :at_v57
|
||||
@@ -589,7 +592,8 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
|
||||
coalesce(max(version), 0) = 57 AS at_v57,
|
||||
coalesce(max(version), 0) = 58 AS at_v58,
|
||||
coalesce(max(version), 0) = 59 AS at_v59,
|
||||
coalesce(max(version), 0) = 60 AS at_v60
|
||||
coalesce(max(version), 0) = 60 AS at_v60,
|
||||
coalesce(max(version), 0) = 61 AS at_v61
|
||||
FROM evolution.schema_migrations \gset
|
||||
\if :at_v24
|
||||
\ir 0025_cellular_v2_bundle.sql
|
||||
@@ -818,6 +822,7 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
|
||||
\elif :at_v58
|
||||
\elif :at_v59
|
||||
\elif :at_v60
|
||||
\elif :at_v61
|
||||
\else
|
||||
\echo 'Unknown or changed migration history after v43'
|
||||
DO $$ BEGIN RAISE EXCEPTION 'unknown or changed migration history'; END $$;
|
||||
@@ -890,6 +895,10 @@ SELECT coalesce(max(version), 0) = 59 AS needs_v60 FROM evolution.schema_migrati
|
||||
\if :needs_v60
|
||||
\ir 0060_cellular_revamp_bundle.sql
|
||||
\endif
|
||||
SELECT coalesce(max(version), 0) = 60 AS needs_v61 FROM evolution.schema_migrations \gset
|
||||
\if :needs_v61
|
||||
\ir 0061_admin_read_views.sql
|
||||
\endif
|
||||
-- Effective-privilege audit on every run, including no-ops (ADR-0060). Attributes
|
||||
-- alone are insufficient: predefined roles such as pg_write_all_data, PUBLIC
|
||||
-- grants or SET-able memberships would bypass the fenced functions. Checks the
|
||||
@@ -963,6 +972,9 @@ BEGIN
|
||||
('evolution.load_cellular_mutation_publications(evolution.u64,evolution.u64,uuid,evolution.u64,uuid)'::regprocedure::oid),
|
||||
('evolution.end_cellular_lives(evolution.u64,evolution.u64,uuid,evolution.u64,uuid,bytea)'::regprocedure::oid),
|
||||
('evolution.issue_account_grant(evolution.u64,text,text)'::regprocedure::oid),
|
||||
('evolution.admin_accounts_v1(evolution.u64)'::regprocedure::oid),
|
||||
('evolution.admin_account_lives_v1(evolution.u64,uuid)'::regprocedure::oid),
|
||||
('evolution.admin_regions_v1(evolution.u64)'::regprocedure::oid),
|
||||
('evolution.revoke_account_grants(evolution.u64,text,text)'::regprocedure::oid),
|
||||
('evolution.load_cellular_publication_actions(evolution.u64,evolution.u64,uuid,evolution.u64,uuid)'::regprocedure::oid),
|
||||
('evolution.load_cellular_publication_births(evolution.u64,evolution.u64,uuid,evolution.u64,uuid)'::regprocedure::oid),
|
||||
|
||||
@@ -0,0 +1,375 @@
|
||||
#include "evo/server/admin/admin_api.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cerrno>
|
||||
#include <charconv>
|
||||
#include <netdb.h>
|
||||
#include <poll.h>
|
||||
#include <sys/socket.h>
|
||||
#include <unistd.h>
|
||||
|
||||
namespace evo::server::admin {
|
||||
namespace {
|
||||
using broker::TokenError;
|
||||
|
||||
OpsResponse json(int status, std::string body) {
|
||||
return {status, std::move(body), "application/json"};
|
||||
}
|
||||
OpsResponse error(int status, std::string_view code) {
|
||||
return json(status, "{\"error\":\"" + std::string(code) + "\"}\n");
|
||||
}
|
||||
const char* token_error(TokenError e) {
|
||||
switch (e) {
|
||||
case TokenError::expired:
|
||||
return "token_expired";
|
||||
case TokenError::missing_role:
|
||||
return "not_an_admin";
|
||||
case TokenError::wrong_audience:
|
||||
case TokenError::wrong_party:
|
||||
case TokenError::wrong_issuer:
|
||||
case TokenError::wrong_type:
|
||||
return "token_not_for_this_service";
|
||||
default:
|
||||
return "invalid_token";
|
||||
}
|
||||
}
|
||||
bool is_uuid(std::string_view text) {
|
||||
if (text.size() != 36)
|
||||
return false;
|
||||
for (std::size_t i = 0; i < text.size(); ++i) {
|
||||
const char ch = text[i];
|
||||
if (i == 8 || i == 13 || i == 18 || i == 23
|
||||
? ch != '-'
|
||||
: !((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f')))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
std::optional<std::uint64_t> number(std::string_view text) {
|
||||
std::uint64_t value{};
|
||||
const auto [end, ec] = std::from_chars(text.data(), text.data() + text.size(), value);
|
||||
if (text.empty() || ec != std::errc{} || end != text.data() + text.size())
|
||||
return std::nullopt;
|
||||
return value;
|
||||
}
|
||||
// Columns as JSON values: absent is null. Identities and ticks go out as strings (they may
|
||||
// exceed 2^53); counts and wall seconds as numbers.
|
||||
std::string text_value(const std::optional<std::string>& value) {
|
||||
return value ? json_string(*value) : "null";
|
||||
}
|
||||
std::string count_value(const std::optional<std::string>& value) {
|
||||
return value && number(*value) ? *value : "null";
|
||||
}
|
||||
std::string seconds_value(const std::optional<std::string>& value) {
|
||||
// Wall seconds before 1970 do not occur; a negative or absent value is null.
|
||||
return value && number(*value) ? *value : "null";
|
||||
}
|
||||
std::string bool_value(const std::optional<std::string>& value) {
|
||||
return value == "t" ? "true" : value == "f" ? "false" : "null";
|
||||
}
|
||||
const std::optional<std::string>& at(const std::vector<std::optional<std::string>>& row,
|
||||
std::size_t index) {
|
||||
static const std::optional<std::string> none;
|
||||
return index < row.size() ? row[index] : none;
|
||||
}
|
||||
|
||||
std::string account_json(const std::vector<std::optional<std::string>>& row) {
|
||||
// 0 account, 1 created, 2 issuer, 3 subject, 4 control region, 5 control expires,
|
||||
// 6 logged in, 7 lives, 8 deaths, 9 active life, 10 active region, 11 mutation choices.
|
||||
const auto lives = number(at(row, 7).value_or("0")).value_or(0);
|
||||
const bool alive = at(row, 9).has_value();
|
||||
const char* status = alive ? "alive" : lives > 0 ? "dead" : "no_life";
|
||||
return "{\"account\":" + text_value(at(row, 0)) +
|
||||
",\"created_at\":" + seconds_value(at(row, 1)) +
|
||||
",\"issuer\":" + text_value(at(row, 2)) + ",\"subject\":" + text_value(at(row, 3)) +
|
||||
",\"control_region\":" + text_value(at(row, 4)) +
|
||||
",\"control_expires\":" + seconds_value(at(row, 5)) +
|
||||
",\"logged_in\":" + (at(row, 6) == "t" ? "true" : "false") + ",\"status\":\"" + status +
|
||||
"\",\"lives\":" + std::to_string(lives) + ",\"deaths\":" + count_value(at(row, 8)) +
|
||||
",\"resets\":" + std::to_string(lives > 0 ? lives - 1 : 0) +
|
||||
",\"active_life\":" + text_value(at(row, 9)) +
|
||||
",\"active_region\":" + text_value(at(row, 10)) +
|
||||
",\"mutation_choices\":" + count_value(at(row, 11)) + "}";
|
||||
}
|
||||
|
||||
const std::string accounts_sql =
|
||||
"SELECT account_id::text, floor(extract(epoch FROM created_at))::bigint, issuer, subject, "
|
||||
"control_region, floor(extract(epoch FROM control_expires))::bigint, "
|
||||
"control_expires > clock_timestamp(), lives, deaths, active_life, active_region, "
|
||||
"mutation_choices FROM evolution.admin_accounts_v1($1)";
|
||||
|
||||
struct Socket {
|
||||
int fd{-1};
|
||||
Socket(const Socket&) = delete;
|
||||
Socket& operator=(const Socket&) = delete;
|
||||
explicit Socket(int value) : fd{value} {}
|
||||
~Socket() {
|
||||
if (fd >= 0)
|
||||
::close(fd);
|
||||
}
|
||||
};
|
||||
// Waits for `events` on the socket until the deadline.
|
||||
bool wait(int fd, short events, std::chrono::steady_clock::time_point deadline) {
|
||||
for (;;) {
|
||||
const auto left = std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||
deadline - std::chrono::steady_clock::now());
|
||||
if (left.count() <= 0)
|
||||
return false;
|
||||
pollfd entry{fd, events, 0};
|
||||
const int ready = ::poll(&entry, 1, static_cast<int>(left.count()));
|
||||
if (ready > 0)
|
||||
return true;
|
||||
if (ready < 0 && errno != EINTR)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
std::string json_string(std::string_view text) {
|
||||
constexpr std::string_view digits = "0123456789abcdef";
|
||||
std::string out = "\"";
|
||||
for (const char ch : text) {
|
||||
const auto byte = static_cast<unsigned char>(ch);
|
||||
if (ch == '"' || ch == '\\') {
|
||||
out.push_back('\\');
|
||||
out.push_back(ch);
|
||||
} else if (byte < 0x20 || byte == 0x7F) {
|
||||
out += "\\u00";
|
||||
out.push_back(digits[byte >> 4U]);
|
||||
out.push_back(digits[byte & 0x0FU]);
|
||||
} else {
|
||||
out.push_back(ch);
|
||||
}
|
||||
}
|
||||
return out + "\"";
|
||||
}
|
||||
|
||||
std::optional<std::string> http_get(std::string_view address, std::string_view path,
|
||||
std::chrono::milliseconds timeout, std::size_t limit) {
|
||||
const auto colon = address.rfind(':');
|
||||
if (colon == std::string_view::npos || colon == 0 || colon + 1 >= address.size() ||
|
||||
path.empty() || path.front() != '/')
|
||||
return std::nullopt;
|
||||
auto host = std::string(address.substr(0, colon));
|
||||
const auto port = std::string(address.substr(colon + 1));
|
||||
if (host.size() >= 2 && host.front() == '[' && host.back() == ']')
|
||||
host = host.substr(1, host.size() - 2);
|
||||
const auto deadline = std::chrono::steady_clock::now() + timeout;
|
||||
addrinfo hints{};
|
||||
hints.ai_family = AF_UNSPEC;
|
||||
hints.ai_socktype = SOCK_STREAM;
|
||||
addrinfo* found = nullptr;
|
||||
if (::getaddrinfo(host.c_str(), port.c_str(), &hints, &found) != 0 || found == nullptr)
|
||||
return std::nullopt;
|
||||
const std::unique_ptr<addrinfo, decltype(&::freeaddrinfo)> results{found, ::freeaddrinfo};
|
||||
for (const addrinfo* candidate = found; candidate != nullptr; candidate = candidate->ai_next) {
|
||||
Socket socket{::socket(candidate->ai_family,
|
||||
candidate->ai_socktype | SOCK_NONBLOCK | SOCK_CLOEXEC,
|
||||
candidate->ai_protocol)};
|
||||
if (socket.fd < 0)
|
||||
continue;
|
||||
if (::connect(socket.fd, candidate->ai_addr, candidate->ai_addrlen) != 0) {
|
||||
int failure = 0;
|
||||
socklen_t length = sizeof failure;
|
||||
if (errno != EINPROGRESS || !wait(socket.fd, POLLOUT, deadline) ||
|
||||
::getsockopt(socket.fd, SOL_SOCKET, SO_ERROR, &failure, &length) != 0 ||
|
||||
failure != 0)
|
||||
continue;
|
||||
}
|
||||
const std::string request = "GET " + std::string(path) + " HTTP/1.1\r\nHost: " + host +
|
||||
"\r\nConnection: close\r\n\r\n";
|
||||
std::size_t sent = 0;
|
||||
while (sent < request.size()) {
|
||||
if (!wait(socket.fd, POLLOUT, deadline))
|
||||
return std::nullopt;
|
||||
const auto n =
|
||||
::send(socket.fd, request.data() + sent, request.size() - sent, MSG_NOSIGNAL);
|
||||
if (n < 0 && errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
|
||||
return std::nullopt;
|
||||
if (n > 0)
|
||||
sent += static_cast<std::size_t>(n);
|
||||
}
|
||||
constexpr std::size_t header_room = 4096;
|
||||
std::string answer;
|
||||
for (;;) {
|
||||
if (!wait(socket.fd, POLLIN, deadline))
|
||||
return std::nullopt;
|
||||
char chunk[16384];
|
||||
const auto n = ::recv(socket.fd, chunk, sizeof chunk, 0);
|
||||
if (n == 0)
|
||||
break;
|
||||
if (n < 0) {
|
||||
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
|
||||
continue;
|
||||
return std::nullopt;
|
||||
}
|
||||
answer.append(chunk, static_cast<std::size_t>(n));
|
||||
if (answer.size() > limit + header_room)
|
||||
return std::nullopt;
|
||||
}
|
||||
const auto end = answer.find("\r\n\r\n");
|
||||
if (end == std::string::npos || answer.rfind("HTTP/1.1 200 ", 0) != 0)
|
||||
return std::nullopt;
|
||||
auto body = answer.substr(end + 4);
|
||||
if (body.size() > limit)
|
||||
return std::nullopt;
|
||||
return body;
|
||||
}
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
AdminApi::AdminApi(AdminConfig config, broker::TokenVerifier verifier, AdminConnect connect,
|
||||
AdminRegionView view, std::vector<AdminAsset> assets)
|
||||
: config_{std::move(config)}, verifier_{std::move(verifier)}, connect_{std::move(connect)},
|
||||
view_{std::move(view)}, assets_{std::move(assets)} {}
|
||||
|
||||
OpsResponse AdminApi::handle(const ApiRequest& request, std::uint64_t now_seconds,
|
||||
std::chrono::steady_clock::time_point now) {
|
||||
auto path = request.path.substr(0, request.path.find('?'));
|
||||
if (request.method != "GET")
|
||||
return {405, "method not allowed\n"};
|
||||
if (path == "/healthz")
|
||||
return {200, "ok\n"};
|
||||
if (path == "/config.json")
|
||||
return json(200, config_.portal_config_json);
|
||||
if (!path.starts_with("/api/")) {
|
||||
if (path == "/")
|
||||
path = "/index.html";
|
||||
const auto asset = std::ranges::find(assets_, path, &AdminAsset::path);
|
||||
if (asset == assets_.end())
|
||||
return {404, "not found\n"};
|
||||
OpsResponse response{200, asset->body, asset->content_type};
|
||||
response.headers = "Content-Security-Policy: " + config_.content_security_policy +
|
||||
"\r\nX-Content-Type-Options: nosniff\r\nReferrer-Policy: no-referrer"
|
||||
"\r\nX-Frame-Options: DENY\r\n";
|
||||
return response;
|
||||
}
|
||||
auto authorization = request.authorization;
|
||||
constexpr std::string_view scheme = "bearer ";
|
||||
if (authorization.size() <= scheme.size() ||
|
||||
!std::ranges::equal(authorization.substr(0, scheme.size()), scheme,
|
||||
[](char a, char b) { return (a | 0x20) == b; }))
|
||||
return error(401, "missing_token");
|
||||
authorization.remove_prefix(scheme.size());
|
||||
const auto claims = verifier_.verify(authorization, now_seconds);
|
||||
if (!claims)
|
||||
return error(claims.error() == TokenError::missing_role ? 403 : 401,
|
||||
token_error(claims.error()));
|
||||
return api(path, *claims, now);
|
||||
}
|
||||
|
||||
OpsResponse AdminApi::api(std::string_view path, const broker::AccessTokenClaims& admin,
|
||||
std::chrono::steady_clock::time_point now) {
|
||||
if (path == "/api/me")
|
||||
return json(200, "{\"subject\":" + json_string(admin.subject) +
|
||||
",\"email\":" + json_string(admin.email) +
|
||||
",\"world\":" + std::to_string(config_.world) + "}\n");
|
||||
if (path == "/api/accounts")
|
||||
return accounts(std::nullopt);
|
||||
constexpr std::string_view account_prefix = "/api/accounts/";
|
||||
if (path.starts_with(account_prefix)) {
|
||||
const auto id = path.substr(account_prefix.size());
|
||||
return is_uuid(id) ? accounts(id) : error(404, "not_found");
|
||||
}
|
||||
if (path == "/api/regions")
|
||||
return regions();
|
||||
constexpr std::string_view region_prefix = "/api/regions/";
|
||||
constexpr std::string_view view_suffix = "/view";
|
||||
if (path.starts_with(region_prefix) && path.ends_with(view_suffix)) {
|
||||
const auto region = number(path.substr(
|
||||
region_prefix.size(), path.size() - region_prefix.size() - view_suffix.size()));
|
||||
return region ? view(*region, now) : error(404, "not_found");
|
||||
}
|
||||
return error(404, "not_found");
|
||||
}
|
||||
|
||||
std::optional<persistence::PgRows> AdminApi::query(const std::string& sql,
|
||||
std::vector<std::string> parameters) {
|
||||
if (!db_ && connect_)
|
||||
db_ = connect_();
|
||||
if (!db_)
|
||||
return std::nullopt;
|
||||
auto rows = db_->query(sql, parameters, config_.db_timeout);
|
||||
if (!rows) {
|
||||
db_.reset();
|
||||
return std::nullopt;
|
||||
}
|
||||
return std::move(*rows);
|
||||
}
|
||||
|
||||
OpsResponse AdminApi::accounts(std::optional<std::string_view> account) {
|
||||
const auto world = std::to_string(config_.world);
|
||||
if (!account) {
|
||||
const auto rows = query(accounts_sql, {world});
|
||||
if (!rows)
|
||||
return error(503, "unavailable");
|
||||
std::string out = "{\"world\":" + world + ",\"accounts\":[";
|
||||
for (std::size_t i = 0; i < rows->size(); ++i)
|
||||
out += (i == 0 ? "" : ",") + account_json((*rows)[i]);
|
||||
return json(200, out + "]}\n");
|
||||
}
|
||||
const auto rows =
|
||||
query(accounts_sql + " WHERE account_id = $2::uuid", {world, std::string(*account)});
|
||||
if (!rows)
|
||||
return error(503, "unavailable");
|
||||
if (rows->empty())
|
||||
return error(404, "not_found");
|
||||
const auto lives = query("SELECT request_id, identity, region_id, rejection, born, ended_tick, "
|
||||
"floor(extract(epoch FROM ended_at))::bigint "
|
||||
"FROM evolution.admin_account_lives_v1($1, $2::uuid)",
|
||||
{world, std::string(*account)});
|
||||
if (!lives)
|
||||
return error(503, "unavailable");
|
||||
std::string out =
|
||||
"{\"world\":" + world + ",\"account\":" + account_json(rows->front()) + ",\"lives\":[";
|
||||
for (std::size_t i = 0; i < lives->size(); ++i) {
|
||||
const auto& row = (*lives)[i];
|
||||
out += std::string(i == 0 ? "" : ",") + "{\"request\":" + text_value(at(row, 0)) +
|
||||
",\"identity\":" + text_value(at(row, 1)) + ",\"region\":" + text_value(at(row, 2)) +
|
||||
",\"rejection\":" + count_value(at(row, 3)) + ",\"born\":" + text_value(at(row, 4)) +
|
||||
",\"ended_tick\":" + text_value(at(row, 5)) +
|
||||
",\"ended_at\":" + seconds_value(at(row, 6)) + "}";
|
||||
}
|
||||
return json(200, out + "]}\n");
|
||||
}
|
||||
|
||||
OpsResponse AdminApi::regions() {
|
||||
const auto world = std::to_string(config_.world);
|
||||
const auto rows = query("SELECT region_id, frame_id, lease_epoch, lease_held, "
|
||||
"floor(extract(epoch FROM lease_expires))::bigint, commit_sequence, "
|
||||
"end_tick, floor(extract(epoch FROM committed_at))::bigint, "
|
||||
"build_identity FROM evolution.admin_regions_v1($1)",
|
||||
{world});
|
||||
if (!rows)
|
||||
return error(503, "unavailable");
|
||||
std::string out = "{\"world\":" + world + ",\"regions\":[";
|
||||
for (std::size_t i = 0; i < rows->size(); ++i) {
|
||||
const auto& row = (*rows)[i];
|
||||
const auto region = number(at(row, 0).value_or(""));
|
||||
const bool viewable = region && std::ranges::contains(config_.view_regions, *region);
|
||||
out += std::string(i == 0 ? "" : ",") + "{\"region\":" + text_value(at(row, 0)) +
|
||||
",\"frame\":" + text_value(at(row, 1)) +
|
||||
",\"lease_epoch\":" + text_value(at(row, 2)) +
|
||||
",\"lease_held\":" + bool_value(at(row, 3)) +
|
||||
",\"lease_expires\":" + seconds_value(at(row, 4)) +
|
||||
",\"sequence\":" + text_value(at(row, 5)) + ",\"tick\":" + text_value(at(row, 6)) +
|
||||
",\"committed_at\":" + seconds_value(at(row, 7)) +
|
||||
",\"build\":" + text_value(at(row, 8)) +
|
||||
",\"viewable\":" + (viewable ? "true" : "false") + "}";
|
||||
}
|
||||
return json(200, out + "]}\n");
|
||||
}
|
||||
|
||||
OpsResponse AdminApi::view(std::uint64_t region, std::chrono::steady_clock::time_point now) {
|
||||
if (!std::ranges::contains(config_.view_regions, region))
|
||||
return error(404, "not_viewable");
|
||||
const auto cached = views_.find(region);
|
||||
if (cached != views_.end() && now - cached->second.at < config_.view_cache)
|
||||
return json(200, cached->second.body);
|
||||
auto body = view_ ? view_(region) : std::nullopt;
|
||||
if (!body)
|
||||
return error(503, "region_unavailable");
|
||||
views_[region] = {now, *body};
|
||||
return json(200, std::move(*body));
|
||||
}
|
||||
} // namespace evo::server::admin
|
||||
@@ -211,6 +211,17 @@ TokenVerifier::verify(std::string_view token, std::uint64_t now_seconds) const {
|
||||
const auto subject = text("sub");
|
||||
if (!subject || subject->empty() || subject->size() > 255)
|
||||
return std::unexpected{TokenError::missing_subject};
|
||||
return AccessTokenClaims{rules_.issuer, std::string(*subject), *expires};
|
||||
if (!rules_.realm_role.empty()) {
|
||||
const auto* realm = payload->member("realm_access");
|
||||
const auto* roles = realm ? realm->member("roles") : nullptr;
|
||||
if (!roles || !roles->array() ||
|
||||
std::ranges::none_of(*roles->array(), [&](const JsonValue& role) {
|
||||
return role.string() == rules_.realm_role;
|
||||
}))
|
||||
return std::unexpected{TokenError::missing_role};
|
||||
}
|
||||
const auto email = text("email");
|
||||
return AccessTokenClaims{rules_.issuer, std::string(*subject), *expires,
|
||||
email && email->size() <= 254 ? std::string(*email) : std::string{}};
|
||||
}
|
||||
} // namespace evo::server::broker
|
||||
|
||||
@@ -0,0 +1,134 @@
|
||||
#include "evo/server/lifecycle/cellular_admin_view.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <string_view>
|
||||
#include <vector>
|
||||
|
||||
namespace evo::server {
|
||||
namespace {
|
||||
void append(std::string& out, std::uint64_t value) {
|
||||
out += std::to_string(value);
|
||||
}
|
||||
void append_inventory(std::string& out, const accounting::Inventory& inventory) {
|
||||
append(out, inventory.energy.value);
|
||||
for (const auto& channel : inventory.matter) {
|
||||
out.push_back(',');
|
||||
append(out, channel.value);
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
std::string cellular_account_text(const LifeAccount& account) {
|
||||
constexpr std::string_view digits = "0123456789abcdef";
|
||||
std::string out;
|
||||
out.reserve(36);
|
||||
for (std::size_t i = 0; i < account.size(); ++i) {
|
||||
if (i == 4 || i == 6 || i == 8 || i == 10)
|
||||
out.push_back('-');
|
||||
out.push_back(digits[account[i] >> 4U]);
|
||||
out.push_back(digits[account[i] & 0x0FU]);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
std::string render_cellular_admin_view(const CellularLives& state,
|
||||
const CellularAdminOnline& online,
|
||||
CellularAdminViewLimits limits) {
|
||||
const auto lives = state.lives();
|
||||
const auto patches = state.habitat().patches();
|
||||
std::string out;
|
||||
out.reserve(256 + std::min(lives.size(), limits.cells) * 128 +
|
||||
std::min(patches.size(), limits.deposits) * 64);
|
||||
out += "{\"world\":";
|
||||
append(out, state.world());
|
||||
out += ",\"region\":";
|
||||
append(out, state.region());
|
||||
out += ",\"tick\":";
|
||||
append(out, state.tick());
|
||||
out += ",\"rules\":";
|
||||
append(out, state.rules_version());
|
||||
out += ",\"area\":[";
|
||||
append(out, state.area().width_um);
|
||||
out.push_back(',');
|
||||
append(out, state.area().height_um);
|
||||
out += "],\"spent\":[";
|
||||
append_inventory(out, state.spent());
|
||||
out += "],\"cells_total\":";
|
||||
append(out, lives.size());
|
||||
out += ",\"deposits_total\":";
|
||||
append(out, patches.size());
|
||||
|
||||
// Lives are kept in ascending life id; a prefix is the lowest ids.
|
||||
out += ",\"cells\":[";
|
||||
const auto cells = std::min(lives.size(), limits.cells);
|
||||
for (std::size_t i = 0; i < cells; ++i) {
|
||||
const auto& life = lives[i];
|
||||
const bool wildlife = life.account == LifeAccount{};
|
||||
std::uint64_t flags = wildlife ? 1U : 0U;
|
||||
if (!wildlife && online && online(life.account))
|
||||
flags |= 2U;
|
||||
if (life.presence == CellularPresence::lingering)
|
||||
flags |= 4U;
|
||||
if (life.presence == CellularPresence::suspended)
|
||||
flags |= 8U;
|
||||
std::uint64_t body_mass{};
|
||||
for (const auto& channel : life.body.matter)
|
||||
body_mass += channel.value;
|
||||
if (i != 0)
|
||||
out.push_back(',');
|
||||
out += "[\"";
|
||||
append(out, life.identity.life);
|
||||
out += "\",\"";
|
||||
append(out, life.identity.organism);
|
||||
out += "\",\"";
|
||||
if (!wildlife)
|
||||
out += cellular_account_text(life.account);
|
||||
out += "\",";
|
||||
append(out, life.position.x_um);
|
||||
out.push_back(',');
|
||||
append(out, life.position.y_um);
|
||||
out.push_back(',');
|
||||
append(out, state.extent_of(life).value_or(0));
|
||||
out.push_back(',');
|
||||
append(out, flags);
|
||||
out.push_back(',');
|
||||
append(out, life.revamp.members);
|
||||
out.push_back(',');
|
||||
append_inventory(out, life.reserve);
|
||||
out.push_back(',');
|
||||
append(out, body_mass);
|
||||
out.push_back(']');
|
||||
}
|
||||
|
||||
// Patches are kept by address; the view lists them by ascending id.
|
||||
std::vector<const biology::CellularPatch*> listed;
|
||||
listed.reserve(patches.size());
|
||||
for (const auto& patch : patches)
|
||||
listed.push_back(&patch);
|
||||
const auto deposits = std::min(listed.size(), limits.deposits);
|
||||
std::ranges::partial_sort(listed, listed.begin() + static_cast<std::ptrdiff_t>(deposits), {},
|
||||
[](const biology::CellularPatch* patch) { return patch->id; });
|
||||
out += "],\"deposits\":[";
|
||||
for (std::size_t i = 0; i < deposits; ++i) {
|
||||
const auto& patch = *listed[i];
|
||||
if (i != 0)
|
||||
out.push_back(',');
|
||||
out.push_back('[');
|
||||
append(out, patch.id);
|
||||
out.push_back(',');
|
||||
append(out, static_cast<std::uint64_t>(patch.kind));
|
||||
out.push_back(',');
|
||||
append(out, patch.address.x_um);
|
||||
out.push_back(',');
|
||||
append(out, patch.address.y_um);
|
||||
out.push_back(',');
|
||||
append(out, patch.radius_um);
|
||||
out.push_back(',');
|
||||
append_inventory(out, patch.stock);
|
||||
out.push_back(']');
|
||||
}
|
||||
out += "]}\n";
|
||||
return out;
|
||||
}
|
||||
} // namespace evo::server
|
||||
@@ -1127,6 +1127,13 @@ accounting::Inventory CellularLives::heat() const noexcept {
|
||||
accounting::Inventory CellularLives::spent() const noexcept {
|
||||
return state_->spent;
|
||||
}
|
||||
std::optional<std::uint32_t> CellularLives::extent_of(const CellularOwnedLife& life) const {
|
||||
const auto budget = budget_for(
|
||||
state_->archive, life, state_->config.ambient_temperature_millikelvin, state_->revamp.body);
|
||||
if (!budget)
|
||||
return std::nullopt;
|
||||
return budget->phenotype.extent;
|
||||
}
|
||||
accounting::Inventory CellularLives::opening_total() const noexcept {
|
||||
return state_->opening_total;
|
||||
}
|
||||
|
||||
+10
-4
@@ -17,6 +17,8 @@ const char* reason(int status) {
|
||||
return "Bad Request";
|
||||
case 401:
|
||||
return "Unauthorized";
|
||||
case 403:
|
||||
return "Forbidden";
|
||||
case 404:
|
||||
return "Not Found";
|
||||
case 429:
|
||||
@@ -40,6 +42,7 @@ std::string encode(const OpsResponse& r) {
|
||||
out += "Allow: GET, POST\r\n";
|
||||
if (r.status == 401)
|
||||
out += "WWW-Authenticate: Bearer\r\n";
|
||||
out += r.headers;
|
||||
return out + "\r\n" + r.body;
|
||||
}
|
||||
bool printable(std::string_view s) {
|
||||
@@ -50,7 +53,10 @@ bool printable(std::string_view s) {
|
||||
}
|
||||
} // namespace
|
||||
|
||||
std::expected<std::unique_ptr<OpsServer>, OpsError> OpsServer::listen(std::string_view address) {
|
||||
std::expected<std::unique_ptr<OpsServer>, OpsError> OpsServer::listen(std::string_view address,
|
||||
std::size_t response_limit) {
|
||||
if (response_limit == 0 || response_limit > max_configurable_response_bytes)
|
||||
return std::unexpected{OpsError::address};
|
||||
const auto colon = address.rfind(':');
|
||||
if (colon == std::string_view::npos || colon + 1 >= address.size())
|
||||
return std::unexpected{OpsError::address};
|
||||
@@ -96,7 +102,7 @@ std::expected<std::unique_ptr<OpsServer>, OpsError> OpsServer::listen(std::strin
|
||||
const auto actual = family == AF_INET6
|
||||
? ntohs(reinterpret_cast<sockaddr_in6*>(&bound)->sin6_port)
|
||||
: ntohs(reinterpret_cast<sockaddr_in*>(&bound)->sin_port);
|
||||
return std::unique_ptr<OpsServer>(new OpsServer(fd, actual));
|
||||
return std::unique_ptr<OpsServer>(new OpsServer(fd, actual, response_limit));
|
||||
}
|
||||
|
||||
OpsServer::~OpsServer() {
|
||||
@@ -123,7 +129,7 @@ void OpsServer::respond(Connection& c, const OpsHandler& handler) {
|
||||
else
|
||||
response = handler(path);
|
||||
}
|
||||
if (response.body.size() > max_response_bytes)
|
||||
if (response.body.size() > response_limit_)
|
||||
response = {500, "response too large\n"};
|
||||
c.out = encode(response);
|
||||
}
|
||||
@@ -172,7 +178,7 @@ void OpsServer::respond_api(Connection& c, const ApiHandler& handler) {
|
||||
response = {400, "bad request\n"};
|
||||
else
|
||||
response = handler({method, path, authorization});
|
||||
if (response.body.size() > max_response_bytes)
|
||||
if (response.body.size() > response_limit_)
|
||||
response = {500, "response too large\n"};
|
||||
c.out = encode(response);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
#include "evo/server/lifecycle/cellular_admin_view.hpp"
|
||||
#include "fixtures/cellular_ecology.hpp"
|
||||
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
|
||||
// ADR-0182 admin region view: every cell and deposit of a cellular owner, read without change.
|
||||
namespace {
|
||||
using namespace evo;
|
||||
using namespace evo::server;
|
||||
using namespace evo::fixture;
|
||||
|
||||
std::size_t count(const std::string& text, const std::string& part) {
|
||||
std::size_t found = 0;
|
||||
for (auto at = text.find(part); at != std::string::npos; at = text.find(part, at + 1))
|
||||
++found;
|
||||
return found;
|
||||
}
|
||||
|
||||
void renders_cells_and_deposits() {
|
||||
const auto state = opening(7, true);
|
||||
const auto before = state->snapshot();
|
||||
LifeAccount first{};
|
||||
first.back() = 1;
|
||||
const auto view = render_cellular_admin_view(
|
||||
*state, [&](const LifeAccount& account) { return account == first; });
|
||||
require(state->snapshot() == before, "rendering the view changed the owner");
|
||||
require(view.starts_with("{\"world\":207,\"region\":1,\"tick\":" +
|
||||
std::to_string(state->tick()) + ",\"rules\":"),
|
||||
"view header");
|
||||
require(view.ends_with("]}\n"), "view terminator");
|
||||
require(view.find("\"area\":[6000,6000]") != std::string::npos, "view area");
|
||||
require(view.find("\"cells_total\":4,") != std::string::npos, "cell total");
|
||||
require(view.find("\"deposits_total\":" + std::to_string(state->habitat().patches().size())) !=
|
||||
std::string::npos,
|
||||
"deposit total");
|
||||
|
||||
// Four player cells, each with its account text; only the first is connected.
|
||||
require(cellular_account_text(first) == "00000000-0000-0000-0000-000000000001", "account text");
|
||||
require(count(view, "[\"10") == 4, "every life listed with its id as a string");
|
||||
for (const auto& life : state->lives()) {
|
||||
const auto extent = state->extent_of(life).value_or(0);
|
||||
require(extent > 0, "a living cell has an extent");
|
||||
const auto row =
|
||||
"[\"" + std::to_string(life.identity.life) + "\",\"" +
|
||||
std::to_string(life.identity.organism) + "\",\"" + cellular_account_text(life.account) +
|
||||
"\"," + std::to_string(life.position.x_um) + "," + std::to_string(life.position.y_um) +
|
||||
"," + std::to_string(extent) + "," + (life.account == first ? "2" : "0") + ",1,";
|
||||
require(view.find(row) != std::string::npos, "cell row");
|
||||
}
|
||||
|
||||
// Deposits by ascending id, and limits keep the lowest ids while totals stay complete.
|
||||
const auto limited = render_cellular_admin_view(*state, {}, {.cells = 1, .deposits = 2});
|
||||
require(count(limited, "[\"10") == 1, "cell limit");
|
||||
require(limited.find("\"cells_total\":4,") != std::string::npos, "total beyond the limit");
|
||||
require(limited.find("\"deposits\":[[1,") != std::string::npos &&
|
||||
limited.find("],[2,") != std::string::npos &&
|
||||
limited.find("],[3,") == std::string::npos,
|
||||
"deposit limit keeps ids 1 and 2");
|
||||
const auto none = render_cellular_admin_view(*state, {}, {.cells = 0, .deposits = 0});
|
||||
require(none.find("\"cells\":[],\"deposits\":[]}") != std::string::npos, "empty lists");
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
try {
|
||||
renders_cells_and_deposits();
|
||||
} catch (const std::exception& error) {
|
||||
std::fprintf(stderr, "%s\n", error.what());
|
||||
return 1;
|
||||
}
|
||||
std::puts("cellular admin view tests passed");
|
||||
return 0;
|
||||
}
|
||||
@@ -1,8 +1,11 @@
|
||||
// ADR-0131 grant broker: bounded JSON, offline RS256 access-token checks, and real
|
||||
// PostgreSQL schema v39 identities, serials and logout revocation. Isolated world 9831.
|
||||
// ADR-0182 admin API: the admin realm role, the portal's files and the schema v61 read views
|
||||
// over the same world.
|
||||
#include "evo/persistence/account_control_store.hpp"
|
||||
#include "evo/persistence/account_identity_store.hpp"
|
||||
#include "evo/persistence/region_lease_store.hpp"
|
||||
#include "evo/server/admin/admin_api.hpp"
|
||||
#include "evo/server/broker/grant_broker.hpp"
|
||||
#include "evo/server/broker/json.hpp"
|
||||
|
||||
@@ -194,6 +197,26 @@ void token_tests(const Realm& realm) {
|
||||
CHECK(failure(stranger.token(header, claims("user-a")), TokenError::bad_signature));
|
||||
CHECK(failure("a.b", TokenError::malformed));
|
||||
CHECK(failure(std::string(max_access_token_bytes + 1, 'a'), TokenError::malformed));
|
||||
|
||||
// ADR-0182: a required realm role, and the email returned for display.
|
||||
auto admin_rules = rules();
|
||||
admin_rules.realm_role = "aevolution-admin";
|
||||
const auto admins = TokenVerifier::from_jwks(realm.jwks("sig-1"), admin_rules);
|
||||
CHECK(admins);
|
||||
const auto role = [&](std::string_view extra) {
|
||||
return admins->verify(realm.token(header, claims("u", extra)), now);
|
||||
};
|
||||
const auto granted =
|
||||
role(R"(,"email":"ops@example.test","realm_access":{"roles":["x","aevolution-admin"]})");
|
||||
CHECK(granted && granted->email == "ops@example.test" && granted->subject == "u");
|
||||
CHECK(good->email.empty());
|
||||
for (const std::string_view without :
|
||||
{"", R"(,"realm_access":{"roles":["x"]})",
|
||||
R"(,"realm_access":{"roles":"aevolution-admin"})", R"(,"realm_access":{})",
|
||||
R"(,"roles":["aevolution-admin"])"}) {
|
||||
const auto refused = role(without);
|
||||
CHECK(!refused && refused.error() == TokenError::missing_role);
|
||||
}
|
||||
}
|
||||
|
||||
struct Grant {
|
||||
@@ -331,6 +354,134 @@ void broker_tests(const Realm& realm) {
|
||||
// Runtime role cannot read or write identities except through the functions.
|
||||
CHECK(!region->query("SELECT count(*) FROM evolution.account_identities", {}, 5s));
|
||||
}
|
||||
|
||||
// ADR-0182 admin API over world 9831 as broker_tests left it: alice and bob have identities,
|
||||
// alice holds session control in region 1, nobody has a life.
|
||||
void admin_api_tests(const Realm& realm) {
|
||||
using server::admin::AdminApi;
|
||||
AccessTokenRules admin_rules{std::string(issuer), "aevolution-admin", "aevolution-admin-portal",
|
||||
30, "aevolution-admin"};
|
||||
const auto admin_claims = [](std::string_view subject, std::string_view roles) {
|
||||
return claims(subject,
|
||||
R"(,"email":"ops@example.test","realm_access":{"roles":)" +
|
||||
std::string(roles) + "}",
|
||||
R"(["account","aevolution-admin"])", "aevolution-admin-portal");
|
||||
};
|
||||
const auto admin =
|
||||
"Bearer " + realm.token(header, admin_claims("ops", R"(["aevolution-admin"])"));
|
||||
const auto player = "Bearer " + realm.token(header, admin_claims("ops", R"(["player"])"));
|
||||
const auto game = "Bearer " + realm.token(header, claims("alice-sub"));
|
||||
int connects = 0;
|
||||
int fetches = 0;
|
||||
const auto make = [&](bool online) {
|
||||
server::admin::AdminConfig config;
|
||||
config.world = 9831;
|
||||
config.view_regions = {1, 3};
|
||||
config.portal_config_json = "{\"world\":9831}\n";
|
||||
config.content_security_policy = "default-src 'none'";
|
||||
return AdminApi{config,
|
||||
*TokenVerifier::from_jwks(realm.jwks("sig-1"), admin_rules),
|
||||
[&, online]() -> std::unique_ptr<persistence::Postgres> {
|
||||
++connects;
|
||||
return online ? connect_as(env("EVO_PG_RUNTIME_USER")) : nullptr;
|
||||
},
|
||||
[&](std::uint64_t region) -> std::optional<std::string> {
|
||||
++fetches;
|
||||
return region == 1 ? std::optional<std::string>{"{\"region\":1}\n"}
|
||||
: std::nullopt;
|
||||
},
|
||||
{{"/index.html", "text/html; charset=utf-8", "<!doctype html>"},
|
||||
{"/app.js", "text/javascript; charset=utf-8", "start();"}}};
|
||||
};
|
||||
auto api = make(true);
|
||||
const auto t0 = std::chrono::steady_clock::time_point{} + 1h;
|
||||
const auto get = [&](std::string_view path, const std::string& authorization = {},
|
||||
std::chrono::steady_clock::time_point at = {}) {
|
||||
return api.handle({"GET", path, authorization}, now, at == decltype(at){} ? t0 : at);
|
||||
};
|
||||
|
||||
// Public: health, the portal's files with their policy headers, and its settings.
|
||||
CHECK(get("/healthz").status == 200);
|
||||
const auto index = get("/");
|
||||
CHECK(index.status == 200 && index.body == "<!doctype html>" &&
|
||||
index.content_type == "text/html; charset=utf-8" &&
|
||||
index.headers.find("Content-Security-Policy: default-src 'none'\r\n") == 0 &&
|
||||
index.headers.find("X-Content-Type-Options: nosniff\r\n") != std::string::npos);
|
||||
CHECK(get("/app.js?v=2").body == "start();");
|
||||
CHECK(get("/style.css").status == 404 && get("/../etc/passwd").status == 404);
|
||||
CHECK(get("/config.json").body == "{\"world\":9831}\n");
|
||||
CHECK(api.handle({"POST", "/api/me", admin}, now, t0).status == 405);
|
||||
|
||||
// Every /api route needs an admin's token; nothing reaches the database before that.
|
||||
CHECK(get("/api/accounts").status == 401);
|
||||
const auto no_role = get("/api/accounts", player);
|
||||
CHECK(no_role.status == 403 && no_role.body.find("not_an_admin") != std::string::npos);
|
||||
const auto foreign = get("/api/accounts", game);
|
||||
CHECK(foreign.status == 401 &&
|
||||
foreign.body.find("token_not_for_this_service") != std::string::npos);
|
||||
CHECK(connects == 0);
|
||||
const auto me = must(JsonValue::parse(get("/api/me", admin).body));
|
||||
CHECK(me.member("subject")->string() == "ops" &&
|
||||
me.member("email")->string() == "ops@example.test" &&
|
||||
me.member("world")->integer() == 9831);
|
||||
|
||||
// Accounts: alice is connected to region 1; neither has a life yet.
|
||||
const auto listed = get("/api/accounts", admin);
|
||||
CHECK(listed.status == 200 && listed.content_type == "application/json");
|
||||
const auto accounts = must(JsonValue::parse(listed.body));
|
||||
CHECK(accounts.member("world")->integer() == 9831);
|
||||
const JsonValue* alice = nullptr;
|
||||
const JsonValue* bob = nullptr;
|
||||
for (const auto& entry : *accounts.member("accounts")->array()) {
|
||||
if (entry.member("subject")->string() == "alice-sub")
|
||||
alice = &entry;
|
||||
if (entry.member("subject")->string() == "bob-sub")
|
||||
bob = &entry;
|
||||
}
|
||||
CHECK(alice && bob);
|
||||
CHECK(alice->member("logged_in")->boolean() == true &&
|
||||
alice->member("control_region")->string() == "1" &&
|
||||
alice->member("status")->string() == "no_life" &&
|
||||
alice->member("lives")->integer() == 0 && alice->member("deaths")->integer() == 0 &&
|
||||
alice->member("resets")->integer() == 0 &&
|
||||
alice->member("mutation_choices")->integer() == 0 &&
|
||||
alice->member("issuer")->string() == issuer && alice->member("created_at")->integer());
|
||||
CHECK(bob->member("logged_in")->boolean() == false &&
|
||||
bob->member("control_region")->kind() == JsonValue::Kind::null);
|
||||
const auto alice_id = std::string(must(alice->member("account")->string()));
|
||||
const auto one = must(JsonValue::parse(get("/api/accounts/" + alice_id, admin).body));
|
||||
CHECK(one.member("account")->member("subject")->string() == "alice-sub" &&
|
||||
one.member("lives")->array() && one.member("lives")->array()->empty());
|
||||
CHECK(get("/api/accounts/00000000-0000-4000-8000-000000000000", admin).status == 404);
|
||||
CHECK(get("/api/accounts/" + alice_id.substr(1), admin).status == 404);
|
||||
CHECK(get("/api/accounts/" + std::string(36, 'A'), admin).status == 404);
|
||||
|
||||
// Regions: the lease broker_tests took, and which views can be fetched.
|
||||
const auto regions = must(JsonValue::parse(get("/api/regions", admin).body));
|
||||
const auto& region = regions.member("regions")->array()->at(0);
|
||||
CHECK(region.member("region")->string() == "1" && region.member("frame")->string() == "7" &&
|
||||
region.member("lease_held")->boolean() == true &&
|
||||
region.member("viewable")->boolean() == true);
|
||||
|
||||
// Views are cached briefly; unknown and unreachable regions are refused.
|
||||
CHECK(get("/api/regions/1/view", admin).body == "{\"region\":1}\n" && fetches == 1);
|
||||
CHECK(get("/api/regions/1/view", admin, t0 + 500ms).status == 200 && fetches == 1);
|
||||
CHECK(get("/api/regions/1/view", admin, t0 + 800ms).status == 200 && fetches == 2);
|
||||
CHECK(get("/api/regions/2/view", admin).status == 404 && fetches == 2);
|
||||
CHECK(get("/api/regions/3/view", admin).status == 503 && fetches == 3);
|
||||
CHECK(get("/api/regions/x/view", admin).status == 404 &&
|
||||
get("/api/other", admin).status == 404);
|
||||
|
||||
// An unreachable database is a 503, retried on the next request.
|
||||
auto offline = make(false);
|
||||
CHECK(offline.handle({"GET", "/api/accounts", admin}, now, t0).status == 503);
|
||||
CHECK(offline.handle({"GET", "/api/regions", admin}, now, t0).status == 503);
|
||||
|
||||
// The read views are the only way in: the runtime role still cannot read the tables.
|
||||
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
|
||||
CHECK(!runtime->query("SELECT count(*) FROM evolution.life_reservations", {}, 5s));
|
||||
CHECK(server::admin::json_string("a\"b\\c\n\x01") == "\"a\\\"b\\\\c\\u000a\\u0001\"");
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void run_grant_broker_tests() {
|
||||
@@ -338,4 +489,5 @@ void run_grant_broker_tests() {
|
||||
const Realm realm;
|
||||
token_tests(realm);
|
||||
broker_tests(realm);
|
||||
admin_api_tests(realm);
|
||||
}
|
||||
|
||||
@@ -226,6 +226,7 @@ void upgrade_across_migration_and_barrier() {
|
||||
" -v migration_sha_58=$(s 0058_liquid_bundle.sql)"
|
||||
" -v migration_sha_59=$(s 0059_durable_mutation_queue.sql)"
|
||||
" -v migration_sha_60=$(s 0060_cellular_revamp_bundle.sql)"
|
||||
" -v migration_sha_61=$(s 0061_admin_read_views.sql)"
|
||||
" -v runtime_role=evo_runtime_test -f migrations/apply.sql"
|
||||
" > /dev/null 2>&1") != 0);
|
||||
CHECK(history(*owner_db) == "1,2,3,4,5,6,7");
|
||||
@@ -243,7 +244,7 @@ void upgrade_across_migration_and_barrier() {
|
||||
"tools/migrate-postgres.sh\" > /dev/null") == 0);
|
||||
CHECK(history(*owner_db) == "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,"
|
||||
"25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,"
|
||||
"47,48,49,50,51,52,53,54,55,56,57,58,59,60");
|
||||
"47,48,49,50,51,52,53,54,55,56,57,58,59,60,61");
|
||||
CHECK(scalar(*owner_db, "SELECT (c.condeferrable AND c.condeferred AND "
|
||||
"c.confrelid = 'evolution.region_commits'::regclass)::text "
|
||||
"FROM pg_catalog.pg_constraint c WHERE c.conrelid = "
|
||||
|
||||
@@ -75,6 +75,9 @@ awk '/^CREATE FUNCTION evolution\.(publish_cellular_checkpoint|publish_cellular_
|
||||
awk '/^CREATE OR REPLACE FUNCTION evolution\.valid_cellular_action_input\(/ {capture=1} capture {print} capture && /^END \$\$;/ {capture=0}' \
|
||||
"$root/migrations/0036_cellular_v5_budding_bundle.sql" | sql > /dev/null
|
||||
sql -v runtime_role="$EVO_PG_RUNTIME_ROLE" > /dev/null <<'SQL'
|
||||
DROP FUNCTION evolution.admin_regions_v1(evolution.u64);
|
||||
DROP FUNCTION evolution.admin_account_lives_v1(evolution.u64,uuid);
|
||||
DROP FUNCTION evolution.admin_accounts_v1(evolution.u64);
|
||||
DROP FUNCTION evolution.publish_cellular_profile_migration(bytea);
|
||||
ALTER FUNCTION evolution.publish_cellular_profile_migration_v59(bytea) RENAME TO publish_cellular_profile_migration;
|
||||
DROP FUNCTION evolution.cellular_births(bytea,bytea);
|
||||
|
||||
@@ -168,7 +168,7 @@ PGDATABASE=upgrade_path psql -X -v ON_ERROR_STOP=1 -1 -v "migration_sha=$v1_sha"
|
||||
-f "$root/migrations/0001_region_bootstrap.sql" > /dev/null
|
||||
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',') FROM evolution.schema_migrations")" = 1
|
||||
PGDATABASE=upgrade_path bash "$root/tools/migrate-postgres.sh"
|
||||
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60
|
||||
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61
|
||||
# v2 heads have no payload binding: v2->v3 fails closed and leaves history at v2.
|
||||
v2_sha="$(sha256sum "$root/migrations/0002_region_fencing.sql")"
|
||||
v2_sha="${v2_sha%% *}"
|
||||
@@ -189,7 +189,7 @@ PGDATABASE=v3_commits psql -X -v ON_ERROR_STOP=1 \
|
||||
-c "INSERT INTO evolution.retained_builds VALUES (decode(repeat('b1', 32), 'hex'))" \
|
||||
-c "SELECT evolution.provision_region_checkpoint(decode('4145564f52434d31' || '01000000' || '01000000' || '0100000000000000' || '0100000000000000' || '0900000000000000' || repeat('11', 16) || repeat('00', 8) || repeat('00', 16) || repeat('00', 32) || repeat('00', 16) || repeat('00', 16) || repeat('00', 8) || '50c3000000000000' || '020000000200000001000000010000000100000001000000010000000100000001000000' || repeat('b1', 32) || '00000000' || '00000000' || '01000000' || '6400000000000000' || repeat('a0', 32), 'hex'))" > /dev/null
|
||||
PGDATABASE=v3_commits bash "$root/tools/migrate-postgres.sh"
|
||||
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) || ':' || string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 60:1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60
|
||||
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) || ':' || string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 61:1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61
|
||||
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) FROM evolution.region_commits")" = 1
|
||||
# Review P1: a v4 database holding a published (possibly terminal) checkpoint has
|
||||
# no durable decisions for it. The v5 upgrade must refuse before changing anything.
|
||||
@@ -243,7 +243,7 @@ PGDATABASE=v6_populated psql -X -v ON_ERROR_STOP=1 \
|
||||
-c "INSERT INTO evolution.retained_builds VALUES (decode(repeat('b1', 32), 'hex'))" \
|
||||
-c "SELECT evolution.provision_region_checkpoint(decode('4145564f52434d31' || '02000000' || '01000000' || '0100000000000000' || '0100000000000000' || '0900000000000000' || repeat('11', 16) || repeat('00', 8) || repeat('00', 16) || repeat('00', 32) || repeat('00', 16) || repeat('00', 16) || repeat('00', 8) || '50c3000000000000' || '020000000200000001000000010000000100000001000000010000000100000001000000' || repeat('b1', 32) || '00000000' || '00000000' || '01000000' || '6400000000000000' || repeat('a0', 32) || repeat('00', 80), 'hex'))" > /dev/null
|
||||
PGDATABASE=v6_populated bash "$root/tools/migrate-postgres.sh"
|
||||
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60
|
||||
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61
|
||||
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT count(*) FROM evolution.region_commits c, LATERAL evolution.parse_checkpoint_manifest(c.manifest) m WHERE m.commit_sequence = 0 AND m.predecessor_commit IS NULL")" = 1
|
||||
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(conname, ',') FROM pg_constraint WHERE conrelid = 'evolution.region_heads'::regclass AND contype = 'c' AND pg_get_constraintdef(oid) LIKE '%end_tick%'")" = region_heads_published_tick
|
||||
phase permission-audit
|
||||
@@ -301,9 +301,9 @@ expect_audit_failure 'REVOKE EXECUTE ON FUNCTION evolution.load_world_cellular_m
|
||||
expect_audit_failure 'GRANT EXECUTE ON FUNCTION evolution.fork_restored_history_v1(uuid) TO evo_runtime_test' 'REVOKE EXECUTE ON FUNCTION evolution.fork_restored_history_v1(uuid) FROM evo_runtime_test'
|
||||
phase checksum-drift
|
||||
# Unknown future versions and checksum drift must not be repaired silently.
|
||||
psql -X -v ON_ERROR_STOP=1 -c 'UPDATE evolution.schema_migrations SET version=61 WHERE version=60'
|
||||
psql -X -v ON_ERROR_STOP=1 -c 'UPDATE evolution.schema_migrations SET version=62 WHERE version=61'
|
||||
if bash "$root/tools/migrate-postgres.sh"; then exit 1; fi
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET version=60 WHERE version=61"
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET version=61 WHERE version=62"
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET sha256=repeat('0',64) WHERE version=14"
|
||||
if bash "$root/tools/migrate-postgres.sh"; then exit 1; fi
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET sha256=repeat('0',64) WHERE version=13"
|
||||
|
||||
@@ -26,12 +26,23 @@ if [[ "$code" -ne 2 ]] || ! grep -q '^usage: evo-world-clone ' <<<"$tool"; then
|
||||
printf 'evo-world-clone smoke failed (exit %s):\n%s\n' "$code" "$tool" >&2
|
||||
exit 1
|
||||
fi
|
||||
# The admin API (ADR-0182) refuses to start without configuration, and its portal files ship.
|
||||
set +e
|
||||
admin="$(run --entrypoint /usr/local/bin/evo-admin-api "$image" 2>&1)"
|
||||
code=$?
|
||||
set -e
|
||||
if [[ "$code" -ne 2 ]] || ! grep -q '^usage: evo-admin-api ' <<<"$admin"; then
|
||||
printf 'evo-admin-api smoke failed (exit %s):\n%s\n' "$code" "$admin" >&2
|
||||
exit 1
|
||||
fi
|
||||
# Non-root, every shared library resolved, no credential material in the image.
|
||||
run --entrypoint /bin/sh "$image" -c '
|
||||
set -eu
|
||||
test "$(id -u)" = 10001 && test "$(id -g)" = 10001
|
||||
! ldd /usr/local/bin/evo-server | grep -q "not found"
|
||||
! ldd /usr/local/bin/evo-world-clone | grep -q "not found"
|
||||
! ldd /usr/local/bin/evo-admin-api | grep -q "not found"
|
||||
for f in index.html app.js style.css; do test -s "/usr/local/share/evo-admin-portal/$f"; done
|
||||
test -z "$(find / -xdev \( -name "*pgpass*" -o -name "pg_service.conf" -o -name "*.pem" \
|
||||
-o -name "*.key" \) -not -path "/etc/ssl/*" -not -path "/usr/lib/ssl/*" \
|
||||
-not -path "/usr/share/*" -print 2>/dev/null)"
|
||||
|
||||
@@ -132,6 +132,8 @@ digest_59="$(sha256sum "$root/migrations/0059_durable_mutation_queue.sql")"
|
||||
digest_59="${digest_59%% *}"
|
||||
digest_60="$(sha256sum "$root/migrations/0060_cellular_revamp_bundle.sql")"
|
||||
digest_60="${digest_60%% *}"
|
||||
digest_61="$(sha256sum "$root/migrations/0061_admin_read_views.sql")"
|
||||
digest_61="${digest_61%% *}"
|
||||
psql -X --no-password --set=ON_ERROR_STOP=1 --set="migration_sha=$digest" \
|
||||
--set="migration_sha_2=$digest_2" --set="migration_sha_3=$digest_3" \
|
||||
--set="migration_sha_4=$digest_4" --set="migration_sha_5=$digest_5" \
|
||||
@@ -180,6 +182,6 @@ psql -X --no-password --set=ON_ERROR_STOP=1 --set="migration_sha=$digest" \
|
||||
--set="migration_sha_53=$digest_53" --set="migration_sha_54=$digest_54" \
|
||||
--set="migration_sha_55=$digest_55" --set="migration_sha_56=$digest_56" \
|
||||
--set="migration_sha_57=$digest_57" --set="migration_sha_58=$digest_58" --set="migration_sha_59=$digest_59" \
|
||||
--set="migration_sha_60=$digest_60" \
|
||||
--set="migration_sha_60=$digest_60" --set="migration_sha_61=$digest_61" \
|
||||
--set="runtime_role=$runtime_role" \
|
||||
--file="$root/migrations/apply.sql"
|
||||
|
||||
Reference in New Issue
Block a user