feat(admin): live admin commands in trace 5 (schema 63)
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 5s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / postgres-tools (push) Successful in 30s
Foundation / server-image (push) Successful in 4m44s
Foundation / image (push) Successful in 5m33s
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 5s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / postgres-tools (push) Successful in 30s
Foundation / server-image (push) Successful in 4m44s
Foundation / image (push) Successful in 5m33s
The admin portal can now spawn wildlife, add bubbles, add to or release the spent pool, remove a cell and grant a cell's reserve on a running rules-13 region (ADR-0182 section 10). No new owner format or region opening. - Trace 5: trace 4 plus 64-byte command records counted in the tick header's last word; a batch without commands stays trace 4 (older builds replay it). Bundle 15 admits trace 5. - CellularLives::admin_candidate applies a tick's commands after its births, each on a copy kept only when it applies and closes: imports through the boundary ledger, removals into the spent pool with a new `removed` corpse cause, spawned roots via the ADR-0180 seed (now a shared helper) funded by an exact import. Refused commands change nothing. - Schema 63: the immutable admin_commands queue (spawn identities from the life allocator), pending/history reads, and binding of every recorded command exactly once inside both cellular publishers; the SQL trace parsers read trace 5 through its trace-4 normal form. - The region polls pending commands every 2 s and appends up to 16 per tick; the admin API and portal gain region actions, per-cell Remove/Grant and the command history. - Fixes an existing test that did not advance its head after a tick commit. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -349,6 +349,86 @@ function sessionWindowCard(region) {
|
||||
return { card, load };
|
||||
}
|
||||
|
||||
// Amounts typed in friendly units: energy in µJ (10^6 pJ), matter in ng (10^6 fg).
|
||||
function amountInputs() {
|
||||
const make = (label) => h('input', { type: 'number', min: 0, step: 'any', placeholder: label, class: 'amount' });
|
||||
const fields = { energy: make('energy µJ'), carbon: make('C ng'), nitrogen: make('N ng'), phosphorus: make('P ng'), other: make('other ng') };
|
||||
const read = () => {
|
||||
const out = {};
|
||||
for (const [name, input] of Object.entries(fields)) {
|
||||
const v = Number(input.value || 0);
|
||||
if (!Number.isFinite(v) || v < 0) throw new Error(`${name} must be a positive number`);
|
||||
out[name] = String(Math.round(v * 1e6));
|
||||
}
|
||||
return out;
|
||||
};
|
||||
const clear = () => Object.values(fields).forEach((input) => { input.value = ''; });
|
||||
return { node: h('div', { class: 'amounts' }, Object.values(fields)), read, clear };
|
||||
}
|
||||
|
||||
const kindLabels = {
|
||||
remove_cell: 'remove cell', grant_reserve: 'grant reserve', add_bubbles: 'add bubbles',
|
||||
add_pool: 'add to pool', release_pool: 'release pool', spawn_wildlife: 'spawn wildlife',
|
||||
};
|
||||
|
||||
// Admin commands (ADR-0182): queued now, applied by the region at its next ticks.
|
||||
function commandsCard(region) {
|
||||
const note = h('div', { class: 'muted small' });
|
||||
const history = h('div');
|
||||
const reason = h('input', { type: 'text', maxlength: 200, placeholder: 'Reason (optional)' });
|
||||
async function send(params, label) {
|
||||
try {
|
||||
const q = new URLSearchParams(params);
|
||||
if (reason.value.trim()) q.set('reason', reason.value.trim());
|
||||
const r = await api(`/api/regions/${region}/commands?${q}`, true, 'POST');
|
||||
note.textContent = `Queued #${r.id} (${label}). The region applies it within a few seconds.`;
|
||||
reason.value = '';
|
||||
load();
|
||||
return true;
|
||||
} catch (e) {
|
||||
note.textContent = `Could not queue ${label}: ${e.code || e.message}`;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
const spawnCount = h('input', { type: 'number', min: 1, max: 64, value: 10, class: 'count' });
|
||||
const bubbleCount = h('input', { type: 'number', min: 1, max: 256, value: 20, class: 'count' });
|
||||
const bubbleAmount = amountInputs();
|
||||
const poolAmount = amountInputs();
|
||||
const releaseCount = h('input', { type: 'number', min: 1, max: 256, value: 20, class: 'count' });
|
||||
const releaseAmount = amountInputs();
|
||||
const withAmount = (amount, extra, label) => {
|
||||
let values;
|
||||
try { values = amount.read(); } catch (e) { note.textContent = e.message; return; }
|
||||
send({ ...extra, ...values }, label).then((ok) => { if (ok) amount.clear(); });
|
||||
};
|
||||
async function load() {
|
||||
try {
|
||||
const data = await api(`/api/regions/${region}/commands`);
|
||||
history.replaceChildren(data.commands.length ? h('table', { class: 'compact' }, h('tbody', {}, data.commands.slice(0, 10).map((c) =>
|
||||
h('tr', {}, h('td', { class: 'mono' }, `#${c.id}`), h('td', {}, kindLabels[c.kind] || c.kind,
|
||||
c.count ? ` ×${c.count}` : '', c.kind === 'remove_cell' || c.kind === 'grant_reserve' ? ` ${c.target}` : ''),
|
||||
h('td', {}, c.applied_tick ? h('span', { class: 'badge alive' }, `tick ${c.applied_tick}`) : h('span', { class: 'badge warn' }, 'pending')),
|
||||
h('td', { class: 'muted', title: c.author || '' }, (c.author || '').split(' (')[0]))))) : h('p', { class: 'muted' }, 'No commands yet.'));
|
||||
} catch (e) {
|
||||
history.textContent = `Unavailable: ${e.message}`;
|
||||
}
|
||||
}
|
||||
const card = h('div', { class: 'card' },
|
||||
h('h2', {}, 'Region actions'),
|
||||
h('div', { class: 'action' }, h('strong', {}, 'Spawn wildlife'), h('div', { class: 'row' }, spawnCount,
|
||||
h('button', { onclick: () => send({ kind: 'spawn_wildlife', count: spawnCount.value }, 'spawn wildlife') }, 'Spawn'))),
|
||||
h('div', { class: 'action' }, h('strong', {}, 'Add bubbles'), bubbleAmount.node, h('div', { class: 'row' }, bubbleCount, h('span', { class: 'muted' }, 'bubbles'),
|
||||
h('button', { onclick: () => withAmount(bubbleAmount, { kind: 'add_bubbles', count: bubbleCount.value }, 'add bubbles') }, 'Add'))),
|
||||
h('div', { class: 'action' }, h('strong', {}, 'Add to spent pool'), poolAmount.node,
|
||||
h('div', { class: 'row' }, h('button', { onclick: () => withAmount(poolAmount, { kind: 'add_pool' }, 'add to pool') }, 'Add to pool'))),
|
||||
h('div', { class: 'action' }, h('strong', {}, 'Release spent pool as bubbles'), releaseAmount.node,
|
||||
h('div', { class: 'row' }, releaseCount, h('span', { class: 'muted' }, 'bubbles'),
|
||||
h('button', { onclick: () => withAmount(releaseAmount, { kind: 'release_pool', count: releaseCount.value }, 'release pool') }, 'Release'))),
|
||||
reason, note, h('h2', {}, 'Recent commands'), history);
|
||||
load();
|
||||
return { card, load, send };
|
||||
}
|
||||
|
||||
// ---------- Region view ----------
|
||||
const channelNames = ['energy', 'carbon', 'nitrogen', 'phosphorus', 'other'];
|
||||
const css = (name) => getComputedStyle(document.documentElement).getPropertyValue(`--${name}`).trim();
|
||||
@@ -365,6 +445,7 @@ async function regionPage(region, params) {
|
||||
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 });
|
||||
const sessions = sessionWindowCard(region);
|
||||
const commands = commandsCard(region);
|
||||
let view = null, selected = null, timer = null, beats = 0;
|
||||
let zoom = 1, panX = 0, panY = 0, drag = null;
|
||||
|
||||
@@ -377,6 +458,7 @@ async function regionPage(region, params) {
|
||||
h('div', { class: 'side' },
|
||||
sessions.card,
|
||||
detail,
|
||||
commands.card,
|
||||
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' },
|
||||
@@ -480,9 +562,22 @@ async function regionPage(region, params) {
|
||||
}
|
||||
function showDetail(c) {
|
||||
selected = c;
|
||||
const grant = amountInputs();
|
||||
const remove = () => {
|
||||
if (!confirm(`Remove ${c.flags & 1 ? 'wildlife' : 'player'} cell ${c.life}? Its body and reserve go to the spent pool.`)) return;
|
||||
commands.send({ kind: 'remove_cell', target: c.life }, `remove cell ${c.life}`);
|
||||
};
|
||||
const give = () => {
|
||||
let values;
|
||||
try { values = grant.read(); } catch (e) { return alert(e.message); }
|
||||
commands.send({ kind: 'grant_reserve', target: c.life, ...values }, `grant reserve to ${c.life}`)
|
||||
.then((ok) => { if (ok) grant.clear(); });
|
||||
};
|
||||
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);
|
||||
c.account ? h('p', {}, h('a', { href: `#/accounts/${c.account}` }, 'Open account →')) : null,
|
||||
h('div', { class: 'action' }, h('strong', {}, 'Grant reserve'), grant.node,
|
||||
h('div', { class: 'row' }, h('button', { onclick: give }, 'Grant'), h('button', { class: 'danger', onclick: remove }, 'Remove cell'))));
|
||||
paint();
|
||||
}
|
||||
|
||||
@@ -562,6 +657,7 @@ async function regionPage(region, params) {
|
||||
if (live.checked && !document.hidden) {
|
||||
await load();
|
||||
if (++beats % 10 === 0) sessions.load();
|
||||
if (beats % 5 === 0) commands.load();
|
||||
}
|
||||
tick();
|
||||
}, 1000);
|
||||
|
||||
@@ -58,7 +58,7 @@ button {
|
||||
button:hover { border-color: var(--accent); }
|
||||
button.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
|
||||
button.ghost { background: transparent; }
|
||||
input[type="search"], input[type="text"], select {
|
||||
input[type="search"], input[type="text"], input[type="number"], select {
|
||||
font: inherit;
|
||||
color: var(--text);
|
||||
background: var(--panel);
|
||||
@@ -188,3 +188,9 @@ dl.facts dd { margin: 0; }
|
||||
table.compact { margin-top: 10px; font-size: 12.5px; background: transparent; }
|
||||
table.compact td { padding: 4px 6px; white-space: normal; }
|
||||
button:disabled { opacity: 0.5; cursor: default; }
|
||||
.action { border-top: 1px solid var(--line); padding-top: 10px; margin-top: 10px; }
|
||||
.action .row { display: flex; gap: 8px; align-items: center; margin-top: 6px; flex-wrap: wrap; }
|
||||
.amounts { display: grid; grid-template-columns: repeat(auto-fill, minmax(88px, 1fr)); gap: 6px; margin-top: 6px; }
|
||||
input.amount, input.count { min-width: 0; width: 100%; }
|
||||
input.count { width: 80px; }
|
||||
button.danger { color: var(--bad); border-color: var(--bad); }
|
||||
|
||||
@@ -1338,8 +1338,19 @@ int serve_cellular(Options& o) {
|
||||
});
|
||||
const std::span<const persistence::CellularMutationReservation> mutations =
|
||||
unbound;
|
||||
// ADR-0182: queued admin commands not already in this batch.
|
||||
auto admin = host.unbound_admin_commands();
|
||||
std::erase_if(admin, [&](const auto& queued) {
|
||||
return std::ranges::any_of(
|
||||
batch_builder->batch().ticks, [&](const auto& previous) {
|
||||
return std::ranges::find(previous.admin, queued.id,
|
||||
&server::CellularAdminCommand::id) !=
|
||||
previous.admin.end();
|
||||
});
|
||||
});
|
||||
const auto admin_before = batch_builder->admin_results().size();
|
||||
auto appended = batch_builder->append_with_birth_refusals(
|
||||
tick, baseline, actions, births, mutations);
|
||||
tick, baseline, actions, births, mutations, admin);
|
||||
if (!appended && !actions.empty()) {
|
||||
// ADR-0127: one account's unusable action (its life died, or it
|
||||
// names an unperceived patch) refuses only that action, never the
|
||||
@@ -1354,7 +1365,7 @@ int serve_cellular(Options& o) {
|
||||
bridge->dropped(refused, true);
|
||||
actions = std::move(usable);
|
||||
appended = batch_builder->append_with_birth_refusals(
|
||||
tick, baseline, actions, births, mutations);
|
||||
tick, baseline, actions, births, mutations, admin);
|
||||
}
|
||||
if (!appended) {
|
||||
const auto lives = batch_builder->last_lives_error();
|
||||
@@ -1370,7 +1381,14 @@ int serve_cellular(Options& o) {
|
||||
actions.end());
|
||||
batch_actions.insert(batch_actions.end(), actions.begin(),
|
||||
actions.end());
|
||||
const bool prompt = !births.empty() || !mutations.empty();
|
||||
const auto results = batch_builder->admin_results();
|
||||
for (std::size_t i = admin_before; i < results.size(); ++i)
|
||||
std::printf("cellular admin command=%llu tick=%llu %s\n",
|
||||
static_cast<unsigned long long>(results[i].id),
|
||||
static_cast<unsigned long long>(tick),
|
||||
results[i].applied ? "applied" : "refused");
|
||||
const bool prompt =
|
||||
!births.empty() || !mutations.empty() || !admin.empty();
|
||||
if (prompt || batch_builder->batch().ticks.size() >= flush_ticks)
|
||||
flush();
|
||||
}
|
||||
|
||||
@@ -1,5 +1,14 @@
|
||||
# Project status and next steps
|
||||
|
||||
## Admin commands: spawn wildlife, resources, remove and grant - 2026-10-27
|
||||
|
||||
The admin portal can now spawn wildlife, add bubbles, add to or release the spent pool,
|
||||
remove a cell and grant a cell's reserve, live. Commands are queued in SQL (schema 63) and
|
||||
the region applies each once, recording it in its history (trace 5) so replay and recovery
|
||||
reproduce it. Imports are counted in the region's boundary ledger. No new region is needed.
|
||||
See [ADR-0182](adr/0182-admin-portal-and-world-tuning.md) section 10 and
|
||||
[validation](engineering/VALIDATION.md).
|
||||
|
||||
## Session windows from the admin portal - 2026-10-27
|
||||
|
||||
The dev session window now lives in SQL (schema 62) instead of Git: the admin portal opens,
|
||||
|
||||
@@ -175,6 +175,38 @@ revoked from the runtime group. The admin API logs in with its own login in that
|
||||
Writes go through POST without a body (`?minutes=M&reason=R`); the bearer token in the
|
||||
`Authorization` header, never a cookie, is the only credential.
|
||||
|
||||
### 10. Admin commands (delivered, schema 63, trace 5)
|
||||
|
||||
The commands of section 3 are delivered without a new owner format or region opening:
|
||||
|
||||
- **Trace 5.** A rules-13 batch may record operator commands: trace 4 plus 64-byte records
|
||||
(id, kind, count, target, energy and four matter amounts) counted in the tick header's last
|
||||
word, which trace 4 keeps zero. A batch without commands stays trace 4, so builds before
|
||||
this one still replay it; only commits that carry commands need this build or later.
|
||||
Bundle 15 admits trace 5 (`cellular_checkpoint_trace_admits`); the manifest is unchanged.
|
||||
- **Application.** `CellularLives::admin_candidate` applies a tick's commands after its
|
||||
births, by ascending id, each on a copy kept only if it applies and still closes:
|
||||
`remove_cell` (body and reserve to the spent pool, a corpse with the new `removed` cause;
|
||||
a player's life then ends as any death does), `grant_reserve`, `add_bubbles` and
|
||||
`add_pool` (imports in the boundary ledger), `release_pool` (moves at most what the pool
|
||||
holds into bubbles) and `spawn_wildlife` (1-64 randomized founder roots, the ADR-0180 seed
|
||||
with an exact import for their reserve, body and construction). A command whose target is
|
||||
gone, or that does not fit (region cap, deposit limit, a taken identity), is refused and
|
||||
changes nothing.
|
||||
- **Queue and binding.** `admin_enqueue_command_v1` (admin role) stores the exact command;
|
||||
spawning reserves its identities from the world's life allocator. The region reads
|
||||
`load_pending_admin_commands_v1` every 2 s and appends up to 16 per tick. Both cellular
|
||||
publishers bind every recorded command to its queue row exactly once, in the publishing
|
||||
transaction; a differing or already-applied command refuses the publication. The SQL trace
|
||||
parsers read a trace 5 through its trace-4 normal form, after binding the real trace to
|
||||
the manifest.
|
||||
- **Portal.** Region actions (spawn wildlife, add bubbles, add to or release the spent pool),
|
||||
per-cell Remove and Grant reserve, and the command history with the tick each applied at.
|
||||
Amounts are entered in µJ and ng.
|
||||
|
||||
Still pending from this ADR: drip/source settings (section 4), tuning amendments
|
||||
(sections 1-2), data-defined mutations (section 5), bans and time played (section 6).
|
||||
|
||||
## Delivery order
|
||||
|
||||
1. Read-only portal: login, accounts (from existing data), regions, region view (schema 61,
|
||||
|
||||
@@ -10508,3 +10508,36 @@ Limits: no live region has read a SQL window yet, and no process test drives the
|
||||
window through a real session; the elapsed-time guard of the 2026-10-08 clock amendment is
|
||||
still pending. Applying it needs the DEV `aevolution_admin` role and the admin portal's own
|
||||
login first.
|
||||
|
||||
## 2026-10-27 - Admin commands in trace 5 (schema 63)
|
||||
|
||||
Scope: ADR-0182 section 10. Operators queue commands in the admin portal (remove a cell,
|
||||
grant a reserve, add bubbles, add to or release the spent pool, spawn wildlife); the
|
||||
cellular region applies each once after a tick's births and records it in trace 5, which
|
||||
bundle 15 admits beside trace 4. Publication binds each recorded command to its queue row
|
||||
in the same transaction. No owner format, rules, manifest bundle, genome, wire version or
|
||||
golden changed; a corpse may carry the new `removed` cause (refused by older readers).
|
||||
The ADR-0180 seeding loop moved into a shared helper with identical draws.
|
||||
|
||||
Executed (WSL Ubuntu, GCC 14.2 Release/NDEBUG, build/m97-postgres):
|
||||
|
||||
- `cellular-revamp-owner-contracts`: new case applying all six kinds plus a refused one
|
||||
(missing target): results, closure through the boundary ledger, the exact spent pool,
|
||||
bubble counts, the removed corpse, spawned wildlife, restore, determinism, trace-5
|
||||
round trip and replay equality, trace 4 refusing commands; the existing starting-wildlife
|
||||
and trace cases still pass after the seeding refactor.
|
||||
- `tools/ci/postgres-check.sh --full` passed (637 s, every phase). New PostgreSQL cases: on
|
||||
the starting-wildlife region, commands queued through `admin_enqueue_command_v1` (spawn
|
||||
identities from the life allocator), a tampered trace-5 batch refused by the binding, the
|
||||
exact batch published with three bindings at its tick and no pending commands left,
|
||||
recovery equal to the applied state, and a second publication of the same commands
|
||||
refused; admin API command endpoints (shape refusals, unknown region, author/reason,
|
||||
history order, runtime role limited to the pending read, rows immutable).
|
||||
- An existing test bug surfaced: the starting-wildlife publication test did not advance its
|
||||
head after its tick commit; it now does before the command batch.
|
||||
- clang-tidy 19 (warnings as errors) on the changed sources after narrowing the command kind
|
||||
to a byte (the trace keeps a u16 and refuses values over 255); clang-format 19.1.5;
|
||||
`node --check` on the portal script.
|
||||
|
||||
Limits: no live region has applied a command yet; the portal's command forms were not
|
||||
driven in a browser.
|
||||
|
||||
@@ -120,7 +120,8 @@ enum class CellularDeathCause : std::uint8_t {
|
||||
starved = 1,
|
||||
engulfed = 2,
|
||||
merged = 3,
|
||||
emerged = 4
|
||||
emerged = 4,
|
||||
removed = 5 // ADR-0182: an operator removed the cell (rules 13).
|
||||
};
|
||||
struct CellularCorpseCandidate {
|
||||
std::uint64_t life_id{};
|
||||
|
||||
@@ -118,6 +118,14 @@ cellular_checkpoint_trace_format(const CellularVersionBundle& b) noexcept {
|
||||
: server::cellular_batch_v2_format;
|
||||
}
|
||||
|
||||
// ADR-0182: a bundle-15 commit may carry admin commands in trace 5; every other format is
|
||||
// exactly the bundle's.
|
||||
[[nodiscard]] constexpr bool cellular_checkpoint_trace_admits(const CellularVersionBundle& b,
|
||||
std::uint32_t format) noexcept {
|
||||
return format == cellular_checkpoint_trace_format(b) ||
|
||||
(format == server::cellular_batch_admin_format && b == cellular_v15_versions);
|
||||
}
|
||||
|
||||
// Batch evidence bound by manifest v2 (ADR-0063); all zero at genesis.
|
||||
struct BatchDigests {
|
||||
std::uint64_t trace_bytes{};
|
||||
|
||||
@@ -31,6 +31,11 @@
|
||||
// opens or extends the window for M (1..240) minutes
|
||||
// from now, or closes it (M = 0), as the signed-in admin
|
||||
// (ADR-0087 amendment). No request body.
|
||||
// GET /api/regions/<n>/commands the region's last admin commands and where they applied
|
||||
// POST /api/regions/<n>/commands?kind=K[&count=N][&target=ID][&energy=PJ][&carbon=FG]
|
||||
// [&nitrogen=FG][&phosphorus=FG][&other=FG][&reason=R]
|
||||
// queues a command (remove_cell, grant_reserve,
|
||||
// add_bubbles, add_pool, release_pool, spawn_wildlife)
|
||||
namespace evo::server::admin {
|
||||
struct AdminAsset {
|
||||
std::string path; // "/index.html", ...; "/" serves "/index.html".
|
||||
@@ -64,6 +69,9 @@ class AdminApi {
|
||||
[[nodiscard]] OpsResponse regions();
|
||||
[[nodiscard]] OpsResponse view(std::uint64_t region, std::chrono::steady_clock::time_point now);
|
||||
[[nodiscard]] OpsResponse window(std::uint64_t region);
|
||||
[[nodiscard]] OpsResponse commands(std::uint64_t region);
|
||||
[[nodiscard]] OpsResponse enqueue(std::uint64_t region, std::string_view query,
|
||||
const broker::AccessTokenClaims& admin);
|
||||
[[nodiscard]] OpsResponse set_window(std::uint64_t region, std::string_view query,
|
||||
const broker::AccessTokenClaims& admin);
|
||||
[[nodiscard]] std::optional<persistence::PgRows> query(const std::string& sql,
|
||||
|
||||
@@ -152,6 +152,9 @@ class CellularRegionHost {
|
||||
}
|
||||
// Queued choices not carried by the commit in flight: the open batch binds these.
|
||||
[[nodiscard]] std::vector<persistence::CellularMutationReservation> unbound_mutations() const;
|
||||
// ADR-0182: queued admin commands (rules 13) not carried by the commit in flight, oldest
|
||||
// first, at most one tick's worth. Publication binds each to its queue row once.
|
||||
[[nodiscard]] std::vector<CellularAdminCommand> unbound_admin_commands() const;
|
||||
[[nodiscard]] std::vector<FinalCellularMutation> take_finalized_mutations();
|
||||
// v5 requests allocate durably, then wait for the scheduler to include the exact
|
||||
// reservation in a profile-4 batch. Repeating the request is idempotent.
|
||||
@@ -207,6 +210,7 @@ class CellularRegionHost {
|
||||
void finalize_births(std::span<const CellularTickIntents::Birth> births);
|
||||
void queue_birth(const CellularTickIntents::Birth& birth);
|
||||
void reload_mutations();
|
||||
void reload_admin_commands();
|
||||
// ADR-0127: owned lives that died record their ending so the account may start again.
|
||||
void note_endings(const CellularLives& before, const CellularLives& after,
|
||||
const persistence::Uuid& commit);
|
||||
@@ -285,6 +289,8 @@ class CellularRegionHost {
|
||||
std::vector<CellularTickIntents::Birth> queued_births_;
|
||||
std::vector<CellularBirthRefusal> pending_birth_refusals_;
|
||||
std::vector<persistence::CellularMutationReservation> queued_mutations_;
|
||||
std::vector<CellularAdminCommand> queued_admin_;
|
||||
std::chrono::steady_clock::time_point next_admin_reload_{};
|
||||
// A reservation may exist that the queue does not show; reload before publishing.
|
||||
bool mutations_uncertain_{};
|
||||
std::vector<FinalCellularMutation> finalized_mutations_;
|
||||
|
||||
@@ -58,7 +58,8 @@ class CellularSessionBatchBuilder {
|
||||
append(std::uint64_t tick, std::span<const CellularLifeIntent> baseline,
|
||||
std::span<const network::CarriedAction> actions,
|
||||
std::span<const CellularTickIntents::Birth> births = {},
|
||||
std::span<const persistence::CellularMutationReservation> mutations = {});
|
||||
std::span<const persistence::CellularMutationReservation> mutations = {},
|
||||
std::span<const CellularAdminCommand> admin = {});
|
||||
// Scheduler path: expected placement/funding/existing-life refusals are reported
|
||||
// separately, so they cannot prevent other births or the ordinary tick. Unexpected
|
||||
// failures retain append's all-or-nothing behavior. Persist reports only after publish.
|
||||
@@ -66,13 +67,18 @@ class CellularSessionBatchBuilder {
|
||||
std::uint64_t tick, std::span<const CellularLifeIntent> baseline,
|
||||
std::span<const network::CarriedAction> actions,
|
||||
std::span<const CellularTickIntents::Birth> births = {},
|
||||
std::span<const persistence::CellularMutationReservation> mutations = {});
|
||||
std::span<const persistence::CellularMutationReservation> mutations = {},
|
||||
std::span<const CellularAdminCommand> admin = {});
|
||||
[[nodiscard]] std::span<const CellularBirthRefusal> refused_births() const noexcept {
|
||||
return refused_births_;
|
||||
}
|
||||
[[nodiscard]] const CellularBatch& batch() const noexcept {
|
||||
return batch_;
|
||||
}
|
||||
// ADR-0182: each admin command appended so far and whether it applied, in trace order.
|
||||
[[nodiscard]] std::span<const CellularAdminResult> admin_results() const noexcept {
|
||||
return admin_results_;
|
||||
}
|
||||
[[nodiscard]] std::span<const CellularActionRecord> actions() const noexcept {
|
||||
return actions_;
|
||||
}
|
||||
@@ -106,7 +112,7 @@ class CellularSessionBatchBuilder {
|
||||
std::span<const network::CarriedAction> actions,
|
||||
std::span<const CellularTickIntents::Birth> births,
|
||||
std::span<const persistence::CellularMutationReservation> mutations,
|
||||
bool allow_refusals);
|
||||
std::span<const CellularAdminCommand> admin, bool allow_refusals);
|
||||
explicit CellularSessionBatchBuilder(std::unique_ptr<CellularLives> working)
|
||||
: working_{std::move(working)} {}
|
||||
std::unique_ptr<CellularLives> working_;
|
||||
@@ -114,6 +120,7 @@ class CellularSessionBatchBuilder {
|
||||
std::vector<CellularActionRecord> actions_;
|
||||
std::vector<CellularMutationActionRecord> mutation_actions_;
|
||||
std::vector<CellularBirthRefusal> refused_births_;
|
||||
std::vector<CellularAdminResult> admin_results_;
|
||||
std::optional<CellularLivesError> last_lives_error_;
|
||||
};
|
||||
} // namespace evo::server
|
||||
|
||||
@@ -22,6 +22,8 @@ struct CellularBatchHeader {
|
||||
inline constexpr std::uint32_t cellular_batch_format = 3;
|
||||
// ADR-0166: explicit opt-in for owner format 8/rules 10; the default remains 3.
|
||||
inline constexpr std::uint32_t cellular_batch_inheritance_format = 4;
|
||||
// ADR-0182: trace 4 plus admin commands, for rules 13 only. A batch without commands stays 4.
|
||||
inline constexpr std::uint32_t cellular_batch_admin_format = 5;
|
||||
inline constexpr std::uint32_t cellular_batch_v2_format = 2;
|
||||
inline constexpr std::uint32_t cellular_batch_legacy_format = 1;
|
||||
struct CellularTickIntents {
|
||||
@@ -38,6 +40,8 @@ struct CellularTickIntents {
|
||||
// Choices accepted against the preceding checkpoint and scheduled for this tick.
|
||||
// The successor identity is durably reserved before the batch is replayed.
|
||||
std::vector<CellularMutationSelection> mutations;
|
||||
// Format 5 (ADR-0182): operator commands applied after the births, by ascending id.
|
||||
std::vector<CellularAdminCommand> admin{};
|
||||
friend bool operator==(const CellularTickIntents&, const CellularTickIntents&) = default;
|
||||
};
|
||||
// Transient scheduler report, not part of the replay trace. A refused birth changes
|
||||
@@ -81,13 +85,17 @@ inline constexpr std::size_t cellular_batch_tick_header_bytes = 16;
|
||||
inline constexpr std::size_t cellular_batch_intent_bytes = 24;
|
||||
inline constexpr std::size_t cellular_batch_birth_bytes = 40;
|
||||
inline constexpr std::size_t cellular_batch_mutation_bytes = 40;
|
||||
// Format 5: id u64, kind u16, count u16, zero u32, target u64, energy and four matter u64.
|
||||
inline constexpr std::size_t cellular_batch_admin_bytes = 64;
|
||||
inline constexpr std::size_t max_cellular_tick_admin_commands = 16;
|
||||
inline constexpr std::size_t max_cellular_batch_ticks = 64;
|
||||
inline constexpr std::size_t max_cellular_batch_bytes =
|
||||
cellular_batch_header_bytes +
|
||||
max_cellular_batch_ticks * (cellular_batch_tick_header_bytes +
|
||||
biology::max_cellular_tick_lives *
|
||||
(cellular_batch_intent_bytes + cellular_batch_birth_bytes +
|
||||
cellular_batch_mutation_bytes));
|
||||
cellular_batch_mutation_bytes) +
|
||||
max_cellular_tick_admin_commands * cellular_batch_admin_bytes);
|
||||
enum class CellularBatchError : std::uint8_t { format, version, scope, state };
|
||||
inline constexpr std::size_t cellular_action_record_bytes = 48;
|
||||
inline constexpr std::size_t max_cellular_action_records = 1'024;
|
||||
@@ -118,6 +126,11 @@ struct CellularMutationOutcome {
|
||||
[[nodiscard]] std::expected<std::unique_ptr<CellularLives>, CellularBatchError>
|
||||
replay_cellular_batch(const CellularLives& base, const CellularBatch& batch,
|
||||
std::vector<CellularMutationOutcome>& mutation_outcomes);
|
||||
// ADR-0182: also reports every admin command's result in trace order.
|
||||
[[nodiscard]] std::expected<std::unique_ptr<CellularLives>, CellularBatchError>
|
||||
replay_cellular_batch(const CellularLives& base, const CellularBatch& batch,
|
||||
std::vector<CellularMutationOutcome>& mutation_outcomes,
|
||||
std::vector<CellularAdminResult>& admin_results);
|
||||
// The canonical 34-byte reserved choice (schema v29): tick, life, event and offer tick as
|
||||
// u64 and the operator as u16, little-endian.
|
||||
inline constexpr std::size_t cellular_mutation_input_bytes = 34;
|
||||
|
||||
@@ -179,6 +179,33 @@ struct CellularLifeIntent {
|
||||
biology::CellularStepIntent intent{};
|
||||
auto operator<=>(const CellularLifeIntent&) const = default;
|
||||
};
|
||||
// ADR-0182 admin commands: operator inputs recorded in the trace (batch format 5) and applied
|
||||
// after a tick's births, in ascending id. Imports enter the boundary ledger as a named game
|
||||
// source; removed matter goes to the spent pool. A command whose target is gone or that does
|
||||
// not fit is refused and changes nothing; the others still apply.
|
||||
enum class CellularAdminKind : std::uint8_t { // A u16 in the trace.
|
||||
remove_cell = 1, // `target` life: body and reserve go to the spent pool.
|
||||
grant_reserve = 2, // `amount` imported into the `target` life's reserve.
|
||||
add_bubbles = 3, // `amount` imported as `count` (1..256) bubbles sharing it.
|
||||
add_pool = 4, // `amount` imported into the spent pool.
|
||||
release_pool = 5, // Up to `amount` moved from the spent pool into `count` bubbles.
|
||||
spawn_wildlife = 6, // `count` (1..64) random-genome roots, identities `target`.., imported.
|
||||
};
|
||||
struct CellularAdminCommand {
|
||||
std::uint64_t id{}; // The durable queue id.
|
||||
CellularAdminKind kind{};
|
||||
std::uint16_t count{};
|
||||
std::uint64_t target{};
|
||||
accounting::Inventory amount{};
|
||||
friend bool operator==(const CellularAdminCommand&, const CellularAdminCommand&) = default;
|
||||
};
|
||||
// Shape only (kind, counts, amounts, identity range); whether it applies is decided at its tick.
|
||||
[[nodiscard]] bool cellular_admin_command_valid(const CellularAdminCommand& command) noexcept;
|
||||
struct CellularAdminResult {
|
||||
std::uint64_t id{};
|
||||
bool applied{};
|
||||
friend bool operator==(const CellularAdminResult&, const CellularAdminResult&) = default;
|
||||
};
|
||||
struct CellularMutationSelection {
|
||||
std::uint64_t life_id{}, event_index{}, offer_tick{}, successor_id{};
|
||||
std::uint16_t operator_id{};
|
||||
@@ -412,6 +439,11 @@ class CellularLives {
|
||||
[[nodiscard]] std::expected<CellularTickExecution, CellularLivesError>
|
||||
advance_tick_with_mutations(std::span<const CellularLifeIntent> intents,
|
||||
std::span<const CellularMutationSelection> selections);
|
||||
// ADR-0182: a detached candidate after `commands` (valid, strictly ascending ids) at the
|
||||
// current tick, after its births. Rules 13 only. `results` reports each command, in order.
|
||||
[[nodiscard]] std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
|
||||
admin_candidate(std::span<const CellularAdminCommand> commands,
|
||||
std::vector<CellularAdminResult>* results = nullptr) const;
|
||||
|
||||
private:
|
||||
friend class CellularMigration;
|
||||
@@ -432,6 +464,11 @@ class CellularLives {
|
||||
migration_replacement(std::vector<CellularOwnedLife>, const biology::LineageArchive&,
|
||||
CellularBoundaryLedger) const;
|
||||
struct State;
|
||||
// ADR-0180/0182: one randomized founder root `id` placed at a seeded free spot, funded
|
||||
// from the nursery, or (with `imported`) by a game-source import added to it.
|
||||
[[nodiscard]] static std::optional<CellularLivesError>
|
||||
seed_wildlife_root(State& next, std::uint64_t world, std::uint64_t region, std::uint64_t tick,
|
||||
std::uint64_t id, accounting::Inventory* imported);
|
||||
explicit CellularLives(std::unique_ptr<State> state);
|
||||
std::unique_ptr<State> state_;
|
||||
std::vector<CellularLifeTickFeedback> last_tick_feedback_;
|
||||
|
||||
@@ -121,6 +121,13 @@ cellular_mutation_cost(const biology::CellularMutationTuning& tuning) noexcept;
|
||||
const CellularRevampRules& rules, std::uint64_t world,
|
||||
std::uint64_t region, std::uint64_t tick,
|
||||
std::uint64_t source);
|
||||
// ADR-0182 admin bubbles: `amount` as `count` bubbles, each channel split evenly (the remainder
|
||||
// in the last), at seeded random spots nudged east past taken addresses, with the next deposit
|
||||
// ids and `source`. False, with `config` unchanged, when the habitat cannot take them all.
|
||||
[[nodiscard]] bool cellular_scatter_bubbles(biology::CellularHabitatConfig& config,
|
||||
const accounting::Inventory& amount,
|
||||
std::uint16_t count, std::uint64_t seed,
|
||||
std::uint64_t source);
|
||||
// A body's handling carrying reserve matter: thrust, reverse thrust and turning scale by
|
||||
// body / (body + load), full-output costs by (body + load) / body, where load is the declared
|
||||
// share of `carried` matter. Drag is unchanged. No load leaves the handling as it is.
|
||||
|
||||
@@ -0,0 +1,341 @@
|
||||
-- Admin commands (ADR-0182, 2026-10-27). The admin portal queues operator commands for a
|
||||
-- region: remove a cell, grant a reserve, add bubbles, add to or release the spent pool, and
|
||||
-- spawn wildlife. The region applies each once, after a tick's births, and records it in the
|
||||
-- trace (format 5: trace 4 plus 64-byte command records counted in the tick header's last
|
||||
-- word), so replay and recovery reproduce it. Publication binds every recorded command to
|
||||
-- its queue row exactly once. A bundle-15 trace without commands stays trace 4; the existing
|
||||
-- parsers read a trace 5 through its trace-4 normal form, so nothing else changes.
|
||||
|
||||
-- u64 values as little-endian bytes.
|
||||
CREATE FUNCTION evolution.le_bytes(v numeric, n integer)
|
||||
RETURNS bytea LANGUAGE plpgsql IMMUTABLE SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE out bytea := ''::bytea; x numeric := v;
|
||||
BEGIN
|
||||
FOR i IN 1 .. n LOOP
|
||||
out := out || set_byte('\x00'::bytea, 0, (x % 256)::integer);
|
||||
x := floor(x / 256);
|
||||
END LOOP;
|
||||
RETURN out;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.le_bytes(numeric, integer) FROM PUBLIC;
|
||||
|
||||
-- The trace-4 normal form of a trace 5: version 4, command counts zero, records dropped.
|
||||
CREATE FUNCTION evolution.cellular_trace_without_admin(t bytea)
|
||||
RETURNS bytea LANGUAGE plpgsql IMMUTABLE SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE
|
||||
ticks integer;
|
||||
off integer := 112;
|
||||
out bytea;
|
||||
records integer;
|
||||
admin integer;
|
||||
BEGIN
|
||||
IF t IS NULL OR octet_length(t) < 112 OR evolution.manifest_uint(t, 8, 4) <> 5 THEN
|
||||
RETURN t;
|
||||
END IF;
|
||||
ticks := evolution.manifest_uint(t, 104, 4)::integer;
|
||||
out := overlay(substring(t FROM 1 FOR 112) PLACING '\x04000000'::bytea FROM 9 FOR 4);
|
||||
FOR i IN 1 .. ticks LOOP
|
||||
IF octet_length(t) < off + 16 THEN
|
||||
RAISE EXCEPTION 'invalid admin trace' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
records := evolution.manifest_uint(t, off, 4)::integer * 24
|
||||
+ evolution.manifest_uint(t, off + 4, 4)::integer * 40
|
||||
+ evolution.manifest_uint(t, off + 8, 4)::integer * 40;
|
||||
admin := evolution.manifest_uint(t, off + 12, 4)::integer;
|
||||
IF admin > 16 OR octet_length(t) < off + 16 + records + admin * 64 THEN
|
||||
RAISE EXCEPTION 'invalid admin trace' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
out := out || substring(t FROM off + 1 FOR 12) || '\x00000000'::bytea
|
||||
|| substring(t FROM off + 17 FOR records);
|
||||
off := off + 16 + records + admin * 64;
|
||||
END LOOP;
|
||||
IF off <> octet_length(t) THEN
|
||||
RAISE EXCEPTION 'invalid admin trace' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
RETURN out;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.cellular_trace_without_admin(bytea) FROM PUBLIC;
|
||||
|
||||
-- A trace 5's command records with the tick each applies at, in trace order.
|
||||
CREATE FUNCTION evolution.cellular_trace_admin(t bytea, m bytea)
|
||||
RETURNS TABLE (tick evolution.u64, command_id bigint, kind integer, cell_count integer,
|
||||
target evolution.u64, energy evolution.u64, carbon evolution.u64, nitrogen evolution.u64,
|
||||
phosphorus evolution.u64, other evolution.u64)
|
||||
LANGUAGE plpgsql IMMUTABLE SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE
|
||||
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
|
||||
ticks integer;
|
||||
off integer := 112;
|
||||
records integer;
|
||||
admin integer;
|
||||
previous numeric;
|
||||
BEGIN
|
||||
IF t IS NULL OR octet_length(t) < 112 OR evolution.manifest_uint(t, 8, 4) <> 5 THEN
|
||||
RETURN;
|
||||
END IF;
|
||||
ticks := evolution.manifest_uint(t, 104, 4)::integer;
|
||||
FOR tick_index IN 0 .. ticks - 1 LOOP
|
||||
records := evolution.manifest_uint(t, off, 4)::integer * 24
|
||||
+ evolution.manifest_uint(t, off + 4, 4)::integer * 40
|
||||
+ evolution.manifest_uint(t, off + 8, 4)::integer * 40;
|
||||
admin := evolution.manifest_uint(t, off + 12, 4)::integer;
|
||||
off := off + 16 + records;
|
||||
previous := 0;
|
||||
FOR i IN 1 .. admin LOOP
|
||||
tick := c.begin_tick + tick_index + 1;
|
||||
command_id := evolution.manifest_uint(t, off, 8)::bigint;
|
||||
kind := evolution.manifest_uint(t, off + 8, 2)::integer;
|
||||
cell_count := evolution.manifest_uint(t, off + 10, 2)::integer;
|
||||
target := evolution.manifest_uint(t, off + 16, 8);
|
||||
energy := evolution.manifest_uint(t, off + 24, 8);
|
||||
carbon := evolution.manifest_uint(t, off + 32, 8);
|
||||
nitrogen := evolution.manifest_uint(t, off + 40, 8);
|
||||
phosphorus := evolution.manifest_uint(t, off + 48, 8);
|
||||
other := evolution.manifest_uint(t, off + 56, 8);
|
||||
IF command_id <= previous OR substring(t FROM off + 13 FOR 4) <> '\x00000000'::bytea THEN
|
||||
RAISE EXCEPTION 'invalid admin trace' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
previous := command_id;
|
||||
off := off + 64;
|
||||
RETURN NEXT;
|
||||
END LOOP;
|
||||
END LOOP;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.cellular_trace_admin(bytea, bytea) FROM PUBLIC;
|
||||
|
||||
-- The trace parsers read a bundle-15 trace 5 through its normal form, after binding the real
|
||||
-- trace to the manifest (as schema 55 did for retained plans).
|
||||
CREATE FUNCTION evolution.cellular_trace_normal(INOUT t bytea, INOUT m bytea)
|
||||
LANGUAGE plpgsql IMMUTABLE SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE
|
||||
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
|
||||
b15 constant bytea := '\x0d0000000b00000002000000010000000100000007000000060000000200000001000000';
|
||||
BEGIN
|
||||
IF t IS NULL OR octet_length(t) < 12 OR evolution.manifest_uint(t, 8, 4) <> 5 THEN
|
||||
RETURN;
|
||||
END IF;
|
||||
IF c.versions <> b15 OR octet_length(t) <> c.trace_bytes OR sha256(t) <> c.trace_sha256 THEN
|
||||
RAISE EXCEPTION 'invalid admin trace binding' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
t := evolution.cellular_trace_without_admin(t);
|
||||
m := overlay(m PLACING evolution.le_bytes(octet_length(t), 8) FROM 281 FOR 8);
|
||||
m := overlay(m PLACING sha256(t) FROM 289 FOR 32);
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.cellular_trace_normal(bytea, bytea) FROM PUBLIC;
|
||||
|
||||
ALTER FUNCTION evolution.cellular_births(bytea,bytea) RENAME TO cellular_births_v62;
|
||||
REVOKE ALL ON FUNCTION evolution.cellular_births_v62(bytea,bytea) FROM PUBLIC, :"runtime_role";
|
||||
CREATE FUNCTION evolution.cellular_births(t bytea, m bytea)
|
||||
RETURNS TABLE(account_id uuid, request_id evolution.u64, generation evolution.u64,
|
||||
identity evolution.u64, born evolution.u64)
|
||||
LANGUAGE plpgsql IMMUTABLE SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE n record := evolution.cellular_trace_normal(t, m);
|
||||
BEGIN
|
||||
RETURN QUERY SELECT * FROM evolution.cellular_births_v62(n.t, n.m);
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.cellular_births(bytea,bytea) FROM PUBLIC;
|
||||
|
||||
ALTER FUNCTION evolution.cellular_mutation_selections(bytea,bytea)
|
||||
RENAME TO cellular_mutation_selections_v62;
|
||||
REVOKE ALL ON FUNCTION evolution.cellular_mutation_selections_v62(bytea,bytea)
|
||||
FROM PUBLIC, :"runtime_role";
|
||||
CREATE FUNCTION evolution.cellular_mutation_selections(p_trace bytea, p_manifest bytea)
|
||||
RETURNS TABLE (tick evolution.u64, life_id evolution.u64, event_index evolution.u64,
|
||||
offer_tick evolution.u64, successor_identity evolution.u64, operator_id integer)
|
||||
LANGUAGE plpgsql IMMUTABLE SECURITY INVOKER SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE n record := evolution.cellular_trace_normal(p_trace, p_manifest);
|
||||
BEGIN
|
||||
RETURN QUERY SELECT * FROM evolution.cellular_mutation_selections_v62(n.t, n.m);
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.cellular_mutation_selections(bytea,bytea) FROM PUBLIC;
|
||||
|
||||
-- The queue. A row is the operator's exact command; its application is recorded separately.
|
||||
CREATE TABLE evolution.admin_commands (
|
||||
command_id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
|
||||
world_id evolution.u64 NOT NULL,
|
||||
region_id evolution.u64 NOT NULL,
|
||||
kind smallint NOT NULL CHECK (kind BETWEEN 1 AND 6),
|
||||
cell_count integer NOT NULL CHECK (cell_count BETWEEN 0 AND 256),
|
||||
target evolution.u64 NOT NULL,
|
||||
energy evolution.u64 NOT NULL,
|
||||
carbon evolution.u64 NOT NULL,
|
||||
nitrogen evolution.u64 NOT NULL,
|
||||
phosphorus evolution.u64 NOT NULL,
|
||||
other evolution.u64 NOT NULL,
|
||||
author_subject text NOT NULL CHECK (octet_length(author_subject) BETWEEN 1 AND 255),
|
||||
reason text NOT NULL DEFAULT '' CHECK (octet_length(reason) <= 500),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
FOREIGN KEY (world_id, region_id) REFERENCES evolution.region_leases
|
||||
);
|
||||
CREATE TRIGGER admin_commands_immutable BEFORE UPDATE OR DELETE ON evolution.admin_commands
|
||||
FOR EACH ROW EXECUTE FUNCTION evolution.refuse_history_rewrite();
|
||||
CREATE TRIGGER admin_commands_no_truncate BEFORE TRUNCATE ON evolution.admin_commands
|
||||
FOR EACH STATEMENT EXECUTE FUNCTION evolution.refuse_history_rewrite();
|
||||
CREATE TABLE evolution.admin_command_applications (
|
||||
command_id bigint PRIMARY KEY REFERENCES evolution.admin_commands,
|
||||
commit_id uuid NOT NULL,
|
||||
commit_sequence evolution.u64 NOT NULL,
|
||||
tick evolution.u64 NOT NULL
|
||||
);
|
||||
CREATE TRIGGER admin_command_applications_immutable BEFORE UPDATE OR DELETE
|
||||
ON evolution.admin_command_applications
|
||||
FOR EACH ROW EXECUTE FUNCTION evolution.refuse_history_rewrite();
|
||||
|
||||
-- Queues a command (the same shapes the owner accepts). Spawning takes its identities from the
|
||||
-- world's life allocator, so they never meet a player's.
|
||||
CREATE FUNCTION evolution.admin_enqueue_command_v1(p_world evolution.u64, p_region evolution.u64,
|
||||
p_kind integer, p_count integer, p_target evolution.u64, p_energy evolution.u64,
|
||||
p_carbon evolution.u64, p_nitrogen evolution.u64, p_phosphorus evolution.u64,
|
||||
p_other evolution.u64, p_subject text, p_reason text)
|
||||
RETURNS TABLE (command_id bigint, target evolution.u64)
|
||||
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
#variable_conflict use_column
|
||||
DECLARE
|
||||
has_amount boolean := p_energy + p_carbon + p_nitrogen + p_phosphorus + p_other > 0;
|
||||
first numeric := p_target;
|
||||
BEGIN
|
||||
IF NOT ((p_kind IN (1, 2) AND p_target > 0 AND p_count = 0 AND has_amount = (p_kind = 2))
|
||||
OR (p_kind IN (3, 5) AND p_target = 0 AND p_count BETWEEN 1 AND 256 AND has_amount)
|
||||
OR (p_kind = 4 AND p_target = 0 AND p_count = 0 AND has_amount)
|
||||
OR (p_kind = 6 AND p_count BETWEEN 1 AND 64 AND NOT has_amount)) THEN
|
||||
RAISE EXCEPTION 'invalid admin command' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
IF NOT EXISTS (SELECT 1 FROM evolution.region_leases l
|
||||
WHERE l.world_id = p_world AND l.region_id = p_region) THEN
|
||||
RAISE EXCEPTION 'unknown region' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
IF p_kind = 6 THEN
|
||||
SELECT a.next_identity INTO first FROM evolution.life_allocators a
|
||||
WHERE a.world_id = p_world FOR UPDATE;
|
||||
IF first IS NULL OR first + p_count > 9223372036854775808 THEN
|
||||
RAISE EXCEPTION 'no identities for wildlife' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
UPDATE evolution.life_allocators SET next_identity = first + p_count
|
||||
WHERE world_id = p_world;
|
||||
END IF;
|
||||
RETURN QUERY
|
||||
WITH queued AS (
|
||||
INSERT INTO evolution.admin_commands AS q(world_id, region_id, kind, cell_count, target,
|
||||
energy, carbon, nitrogen, phosphorus, other, author_subject, reason)
|
||||
VALUES (p_world, p_region, p_kind, p_count, first, p_energy, p_carbon, p_nitrogen,
|
||||
p_phosphorus, p_other, p_subject, coalesce(p_reason, ''))
|
||||
RETURNING q.command_id, q.target)
|
||||
SELECT queued.command_id, queued.target FROM queued;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.admin_enqueue_command_v1(evolution.u64, evolution.u64, integer,
|
||||
integer, evolution.u64, evolution.u64, evolution.u64, evolution.u64, evolution.u64,
|
||||
evolution.u64, text, text) FROM PUBLIC;
|
||||
|
||||
-- The region's commands not yet published, oldest first.
|
||||
CREATE FUNCTION evolution.load_pending_admin_commands_v1(p_world evolution.u64,
|
||||
p_region evolution.u64)
|
||||
RETURNS TABLE (command_id bigint, kind integer, cell_count integer, target evolution.u64,
|
||||
energy evolution.u64, carbon evolution.u64, nitrogen evolution.u64, phosphorus evolution.u64,
|
||||
other evolution.u64)
|
||||
LANGUAGE sql STABLE SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
SELECT q.command_id, q.kind, q.cell_count, q.target, q.energy, q.carbon, q.nitrogen,
|
||||
q.phosphorus, q.other
|
||||
FROM evolution.admin_commands q
|
||||
WHERE q.world_id = p_world AND q.region_id = p_region
|
||||
AND NOT EXISTS (SELECT 1 FROM evolution.admin_command_applications a
|
||||
WHERE a.command_id = q.command_id)
|
||||
ORDER BY q.command_id
|
||||
LIMIT 64
|
||||
$$;
|
||||
REVOKE ALL ON FUNCTION evolution.load_pending_admin_commands_v1(evolution.u64, evolution.u64)
|
||||
FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.load_pending_admin_commands_v1(evolution.u64, evolution.u64)
|
||||
TO :"runtime_role";
|
||||
|
||||
-- The region's last 100 commands, newest first, with the tick each applied at.
|
||||
CREATE FUNCTION evolution.admin_commands_v1(p_world evolution.u64, p_region evolution.u64)
|
||||
RETURNS TABLE (command_id bigint, kind integer, cell_count integer, target evolution.u64,
|
||||
energy evolution.u64, carbon evolution.u64, nitrogen evolution.u64, phosphorus evolution.u64,
|
||||
other evolution.u64, author_subject text, reason text, created_at timestamptz,
|
||||
applied_tick evolution.u64)
|
||||
LANGUAGE sql STABLE SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
SELECT q.command_id, q.kind, q.cell_count, q.target, q.energy, q.carbon, q.nitrogen,
|
||||
q.phosphorus, q.other, q.author_subject, q.reason, q.created_at, a.tick
|
||||
FROM evolution.admin_commands q
|
||||
LEFT JOIN evolution.admin_command_applications a ON a.command_id = q.command_id
|
||||
WHERE q.world_id = p_world AND q.region_id = p_region
|
||||
ORDER BY q.command_id DESC
|
||||
LIMIT 100
|
||||
$$;
|
||||
REVOKE ALL ON FUNCTION evolution.admin_commands_v1(evolution.u64, evolution.u64) FROM PUBLIC;
|
||||
|
||||
-- Every command recorded in a published trace is exactly its queue row and applies once.
|
||||
CREATE FUNCTION evolution.bind_cellular_admin_commands(p_manifest bytea, p_trace bytea)
|
||||
RETURNS void LANGUAGE plpgsql SECURITY INVOKER SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE
|
||||
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(p_manifest);
|
||||
r record;
|
||||
BEGIN
|
||||
FOR r IN SELECT * FROM evolution.cellular_trace_admin(p_trace, p_manifest) LOOP
|
||||
IF NOT EXISTS (SELECT 1 FROM evolution.admin_commands q
|
||||
WHERE q.command_id = r.command_id AND q.world_id = c.world_id
|
||||
AND q.region_id = c.region_id AND q.kind = r.kind AND q.cell_count = r.cell_count
|
||||
AND q.target = r.target AND q.energy = r.energy AND q.carbon = r.carbon
|
||||
AND q.nitrogen = r.nitrogen AND q.phosphorus = r.phosphorus AND q.other = r.other) THEN
|
||||
RAISE EXCEPTION 'admin command differs from its queue' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
IF EXISTS (SELECT 1 FROM evolution.admin_command_applications a
|
||||
WHERE a.command_id = r.command_id AND (a.commit_id <> c.commit_id OR a.tick <> r.tick)) THEN
|
||||
RAISE EXCEPTION 'admin command already applied' USING ERRCODE = 'EVL07';
|
||||
END IF;
|
||||
INSERT INTO evolution.admin_command_applications(command_id, commit_id, commit_sequence, tick)
|
||||
VALUES (r.command_id, c.commit_id, c.commit_sequence, r.tick)
|
||||
ON CONFLICT (command_id) DO NOTHING;
|
||||
END LOOP;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.bind_cellular_admin_commands(bytea, bytea) FROM PUBLIC;
|
||||
|
||||
-- Schema 59's publishers, binding admin commands in the same transaction.
|
||||
ALTER FUNCTION evolution.publish_cellular_checkpoint(bytea,bytea,bytea,bytea)
|
||||
RENAME TO publish_cellular_checkpoint_v62;
|
||||
REVOKE ALL ON FUNCTION evolution.publish_cellular_checkpoint_v62(bytea,bytea,bytea,bytea)
|
||||
FROM PUBLIC, :"runtime_role";
|
||||
CREATE FUNCTION evolution.publish_cellular_checkpoint(p_manifest bytea, p_decisions bytea,
|
||||
p_actions bytea, p_trace bytea)
|
||||
RETURNS TABLE(region_frame evolution.u64, head_sequence evolution.u64, head_commit uuid,
|
||||
head_digest text, head_tick evolution.u64)
|
||||
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE h record;
|
||||
BEGIN
|
||||
SELECT * INTO h FROM evolution.publish_cellular_checkpoint_v62(p_manifest, p_decisions,
|
||||
p_actions, p_trace);
|
||||
IF NOT FOUND THEN
|
||||
RAISE EXCEPTION 'publication returned no head' USING ERRCODE = 'XX000';
|
||||
END IF;
|
||||
PERFORM evolution.bind_cellular_admin_commands(p_manifest, p_trace);
|
||||
RETURN QUERY SELECT h.region_frame, h.head_sequence, h.head_commit, h.head_digest, h.head_tick;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.publish_cellular_checkpoint(bytea,bytea,bytea,bytea) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.publish_cellular_checkpoint(bytea,bytea,bytea,bytea)
|
||||
TO :"runtime_role";
|
||||
|
||||
ALTER FUNCTION evolution.publish_cellular_mutation_checkpoint(bytea,bytea,bytea,bytea,bytea,bytea)
|
||||
RENAME TO publish_cellular_mutation_checkpoint_v62;
|
||||
REVOKE ALL ON FUNCTION evolution.publish_cellular_mutation_checkpoint_v62(bytea,bytea,bytea,bytea,
|
||||
bytea,bytea) FROM PUBLIC, :"runtime_role";
|
||||
CREATE FUNCTION evolution.publish_cellular_mutation_checkpoint(p_manifest bytea,
|
||||
p_decisions bytea, p_actions bytea, p_trace bytea, p_mutations bytea, p_results bytea)
|
||||
RETURNS TABLE(region_frame evolution.u64, head_sequence evolution.u64, head_commit uuid,
|
||||
head_digest text, head_tick evolution.u64)
|
||||
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE h record;
|
||||
BEGIN
|
||||
SELECT * INTO h FROM evolution.publish_cellular_mutation_checkpoint_v62(p_manifest,
|
||||
p_decisions, p_actions, p_trace, p_mutations, p_results);
|
||||
IF NOT FOUND THEN
|
||||
RAISE EXCEPTION 'publication returned no head' USING ERRCODE = 'XX000';
|
||||
END IF;
|
||||
PERFORM evolution.bind_cellular_admin_commands(p_manifest, p_trace);
|
||||
RETURN QUERY SELECT h.region_frame, h.head_sequence, h.head_commit, h.head_digest, h.head_tick;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.publish_cellular_mutation_checkpoint(bytea,bytea,bytea,bytea,
|
||||
bytea,bytea) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.publish_cellular_mutation_checkpoint(bytea,bytea,bytea,bytea,
|
||||
bytea,bytea) TO :"runtime_role";
|
||||
|
||||
INSERT INTO evolution.schema_migrations(version,sha256) VALUES(63,:'migration_sha_63');
|
||||
+21
-4
@@ -138,6 +138,7 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
|
||||
SELECT :'history_v59' || ',60:' || :'migration_sha_60' AS history_v60 \gset
|
||||
SELECT :'history_v60' || ',61:' || :'migration_sha_61' AS history_v61 \gset
|
||||
SELECT :'history_v61' || ',62:' || :'migration_sha_62' AS history_v62 \gset
|
||||
SELECT :'history_v62' || ',63:' || :'migration_sha_63' AS history_v63 \gset
|
||||
SELECT :'history' = :'history_v22' AS at_v22,
|
||||
:'history' = :'history_v23' AS at_v23,
|
||||
:'history' = :'history_v24' AS at_v24,
|
||||
@@ -178,8 +179,10 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
|
||||
:'history' = :'history_v59' AS at_v59,
|
||||
:'history' = :'history_v60' AS at_v60,
|
||||
:'history' = :'history_v61' AS at_v61,
|
||||
:'history' = :'history_v62' AS at_v62 \gset
|
||||
\if :at_v62
|
||||
:'history' = :'history_v62' AS at_v62,
|
||||
:'history' = :'history_v63' AS at_v63 \gset
|
||||
\if :at_v63
|
||||
\elif :at_v62
|
||||
\elif :at_v61
|
||||
\elif :at_v60
|
||||
\elif :at_v59
|
||||
@@ -597,7 +600,8 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
|
||||
coalesce(max(version), 0) = 59 AS at_v59,
|
||||
coalesce(max(version), 0) = 60 AS at_v60,
|
||||
coalesce(max(version), 0) = 61 AS at_v61,
|
||||
coalesce(max(version), 0) = 62 AS at_v62
|
||||
coalesce(max(version), 0) = 62 AS at_v62,
|
||||
coalesce(max(version), 0) = 63 AS at_v63
|
||||
FROM evolution.schema_migrations \gset
|
||||
\if :at_v24
|
||||
\ir 0025_cellular_v2_bundle.sql
|
||||
@@ -828,6 +832,7 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
|
||||
\elif :at_v60
|
||||
\elif :at_v61
|
||||
\elif :at_v62
|
||||
\elif :at_v63
|
||||
\else
|
||||
\echo 'Unknown or changed migration history after v43'
|
||||
DO $$ BEGIN RAISE EXCEPTION 'unknown or changed migration history'; END $$;
|
||||
@@ -908,6 +913,10 @@ SELECT coalesce(max(version), 0) = 61 AS needs_v62 FROM evolution.schema_migrati
|
||||
\if :needs_v62
|
||||
\ir 0062_session_windows.sql
|
||||
\endif
|
||||
SELECT coalesce(max(version), 0) = 62 AS needs_v63 FROM evolution.schema_migrations \gset
|
||||
\if :needs_v63
|
||||
\ir 0063_admin_commands.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
|
||||
@@ -982,6 +991,7 @@ BEGIN
|
||||
('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.load_session_window_v1(evolution.u64,evolution.u64)'::regprocedure::oid),
|
||||
('evolution.load_pending_admin_commands_v1(evolution.u64,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),
|
||||
@@ -1050,6 +1060,11 @@ GRANT EXECUTE ON FUNCTION evolution.admin_session_windows_v1(evolution.u64, evol
|
||||
TO :"admin_role";
|
||||
GRANT EXECUTE ON FUNCTION evolution.admin_set_session_window_v1(evolution.u64, evolution.u64,
|
||||
integer, text, text) TO :"admin_role";
|
||||
GRANT EXECUTE ON FUNCTION evolution.admin_enqueue_command_v1(evolution.u64, evolution.u64, integer,
|
||||
integer, evolution.u64, evolution.u64, evolution.u64, evolution.u64, evolution.u64,
|
||||
evolution.u64, text, text) TO :"admin_role";
|
||||
GRANT EXECUTE ON FUNCTION evolution.admin_commands_v1(evolution.u64, evolution.u64)
|
||||
TO :"admin_role";
|
||||
SELECT pg_catalog.set_config('evolution.admin_role', :'admin_role', true);
|
||||
DO $$
|
||||
DECLARE
|
||||
@@ -1072,7 +1087,9 @@ BEGIN
|
||||
('evolution.admin_regions_v1(evolution.u64)'::regprocedure::oid),
|
||||
('evolution.load_session_window_v1(evolution.u64,evolution.u64)'::regprocedure::oid),
|
||||
('evolution.admin_session_windows_v1(evolution.u64,evolution.u64)'::regprocedure::oid),
|
||||
('evolution.admin_set_session_window_v1(evolution.u64,evolution.u64,integer,text,text)'::regprocedure::oid)
|
||||
('evolution.admin_set_session_window_v1(evolution.u64,evolution.u64,integer,text,text)'::regprocedure::oid),
|
||||
('evolution.admin_enqueue_command_v1(evolution.u64,evolution.u64,integer,integer,evolution.u64,evolution.u64,evolution.u64,evolution.u64,evolution.u64,evolution.u64,text,text)'::regprocedure::oid),
|
||||
('evolution.admin_commands_v1(evolution.u64,evolution.u64)'::regprocedure::oid)
|
||||
), violations(reason) AS (
|
||||
SELECT 'admin role is the runtime role' WHERE admin = runtime
|
||||
UNION ALL
|
||||
|
||||
@@ -149,7 +149,7 @@ bool prepared_is_canonical(const CellularPreparedCommit& prepared,
|
||||
const auto encoded_trace = server::encode_cellular_batch(trace);
|
||||
const auto digest = sha256(prepared.trace);
|
||||
const bool trace_version_matches =
|
||||
trace.format_version == cellular_checkpoint_trace_format(manifest.cellular_versions);
|
||||
cellular_checkpoint_trace_admits(manifest.cellular_versions, trace.format_version);
|
||||
return manifest.profile == CheckpointProfile::cellular_lives_v1 && trace_version_matches &&
|
||||
manifest.key == prepared.key && manifest.commit == prepared.commit &&
|
||||
manifest.sequence > 0 && manifest.batch.trace_bytes == prepared.trace.size() && digest &&
|
||||
@@ -561,7 +561,9 @@ publish_cellular_batch(Postgres& db, const FilesystemObjectStore& objects, const
|
||||
const auto previous = decode_manifest(predecessor.manifest);
|
||||
const auto predecessor_digest = sha256(predecessor.manifest);
|
||||
auto committed_batch = batch;
|
||||
if (previous)
|
||||
if (previous && !(committed_batch.format_version == server::cellular_batch_admin_format &&
|
||||
cellular_checkpoint_trace_admits(previous->cellular_versions,
|
||||
committed_batch.format_version)))
|
||||
committed_batch.format_version =
|
||||
cellular_checkpoint_trace_format(previous->cellular_versions);
|
||||
const auto trace = server::encode_cellular_batch(committed_batch);
|
||||
@@ -834,7 +836,7 @@ recover_cellular_loaded(Postgres& db, const FilesystemObjectStore& objects, Regi
|
||||
auto trace = server::decode_cellular_batch(*trace_bytes);
|
||||
if (!trace)
|
||||
return fail_with(RecoveryError::tail);
|
||||
if (trace->format_version != cellular_checkpoint_trace_format(manifest->cellular_versions))
|
||||
if (!cellular_checkpoint_trace_admits(manifest->cellular_versions, trace->format_version))
|
||||
return fail_with(RecoveryError::tail);
|
||||
if (trace->header.world != key.world || trace->header.region != key.region ||
|
||||
trace->header.frame != manifest->frame ||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#include "evo/server/admin/admin_api.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cerrno>
|
||||
#include <charconv>
|
||||
#include <netdb.h>
|
||||
@@ -263,10 +264,10 @@ OpsResponse AdminApi::handle(const ApiRequest& request, std::uint64_t now_second
|
||||
auto path = request.path.substr(0, mark);
|
||||
const auto query =
|
||||
mark == std::string_view::npos ? std::string_view{} : request.path.substr(mark + 1);
|
||||
// Only the session window accepts POST; everything else is read-only.
|
||||
// Only session windows and commands accept POST; everything else is read-only.
|
||||
if (request.method != "GET" &&
|
||||
!(request.method == "POST" && path.starts_with("/api/regions/") &&
|
||||
path.ends_with("/session-window")))
|
||||
(path.ends_with("/session-window") || path.ends_with("/commands"))))
|
||||
return {405, "method not allowed\n"};
|
||||
if (path == "/healthz")
|
||||
return {200, "ok\n"};
|
||||
@@ -330,6 +331,15 @@ OpsResponse AdminApi::api(std::string_view method, std::string_view path, std::s
|
||||
return error(404, "not_found");
|
||||
return method == "POST" ? set_window(*region, query, admin) : window(*region);
|
||||
}
|
||||
constexpr std::string_view commands_suffix = "/commands";
|
||||
if (path.starts_with(region_prefix) && path.ends_with(commands_suffix) &&
|
||||
path.size() > region_prefix.size() + commands_suffix.size()) {
|
||||
const auto region = number(path.substr(
|
||||
region_prefix.size(), path.size() - region_prefix.size() - commands_suffix.size()));
|
||||
if (!region)
|
||||
return error(404, "not_found");
|
||||
return method == "POST" ? enqueue(*region, query, admin) : commands(*region);
|
||||
}
|
||||
return error(404, "not_found");
|
||||
}
|
||||
|
||||
@@ -464,6 +474,92 @@ OpsResponse AdminApi::set_window(std::uint64_t region, std::string_view query_te
|
||||
",\"expires_at\":" + seconds_value(at(rows->front(), 1)) + "}\n");
|
||||
}
|
||||
|
||||
namespace {
|
||||
constexpr std::array<std::string_view, 7> command_kinds{
|
||||
"", "remove_cell", "grant_reserve", "add_bubbles",
|
||||
"add_pool", "release_pool", "spawn_wildlife"};
|
||||
} // namespace
|
||||
|
||||
OpsResponse AdminApi::commands(std::uint64_t region) {
|
||||
const auto rows =
|
||||
query("SELECT command_id, kind, cell_count, target, energy, carbon, nitrogen, phosphorus, "
|
||||
"other, author_subject, reason, floor(extract(epoch FROM created_at))::bigint, "
|
||||
"applied_tick FROM evolution.admin_commands_v1($1, $2)",
|
||||
{std::to_string(config_.world), std::to_string(region)});
|
||||
if (!rows)
|
||||
return error(503, "unavailable");
|
||||
std::string out = "{\"region\":\"" + std::to_string(region) + "\",\"commands\":[";
|
||||
for (std::size_t i = 0; i < rows->size(); ++i) {
|
||||
const auto& row = (*rows)[i];
|
||||
const auto kind = number(at(row, 1).value_or("0")).value_or(0);
|
||||
out +=
|
||||
std::string(i == 0 ? "" : ",") + "{\"id\":" + text_value(at(row, 0)) + ",\"kind\":\"" +
|
||||
std::string(kind < command_kinds.size() ? command_kinds[kind] : "") +
|
||||
"\",\"count\":" + count_value(at(row, 2)) + ",\"target\":" + text_value(at(row, 3)) +
|
||||
",\"amount\":[" + text_value(at(row, 4)) + "," + text_value(at(row, 5)) + "," +
|
||||
text_value(at(row, 6)) + "," + text_value(at(row, 7)) + "," + text_value(at(row, 8)) +
|
||||
"],\"author\":" + text_value(at(row, 9)) + ",\"reason\":" + text_value(at(row, 10)) +
|
||||
",\"created_at\":" + seconds_value(at(row, 11)) +
|
||||
",\"applied_tick\":" + text_value(at(row, 12)) + "}";
|
||||
}
|
||||
return json(200, out + "]}\n");
|
||||
}
|
||||
|
||||
OpsResponse AdminApi::enqueue(std::uint64_t region, std::string_view query_text,
|
||||
const broker::AccessTokenClaims& admin) {
|
||||
const auto kind_text = query_value(query_text, "kind", 20);
|
||||
const auto kind =
|
||||
kind_text ? std::ranges::find(command_kinds, *kind_text) : command_kinds.end();
|
||||
if (!kind_text || kind_text->empty() || kind == command_kinds.end())
|
||||
return error(400, "bad_kind");
|
||||
// Absent numbers are zero; present ones must be plain u64 decimals.
|
||||
const auto value = [&](std::string_view name) -> std::optional<std::uint64_t> {
|
||||
const auto text = query_value(query_text, name, 20);
|
||||
if (!text)
|
||||
return query_text.find(std::string(name) + "=") == std::string_view::npos
|
||||
? std::optional<std::uint64_t>{0}
|
||||
: std::nullopt;
|
||||
return number(*text);
|
||||
};
|
||||
std::array<std::optional<std::uint64_t>, 7> v{
|
||||
value("count"), value("target"), value("energy"), value("carbon"),
|
||||
value("nitrogen"), value("phosphorus"), value("other")};
|
||||
if (std::ranges::any_of(v, [](const auto& x) { return !x; }))
|
||||
return error(400, "bad_number");
|
||||
const auto reason = query_value(query_text, "reason");
|
||||
if (!reason && query_text.find("reason=") != std::string_view::npos)
|
||||
return error(400, "bad_reason");
|
||||
auto author = admin.email.empty() ? admin.subject : admin.email + " (" + admin.subject + ")";
|
||||
if (author.size() > 255)
|
||||
author = admin.subject;
|
||||
std::vector<std::string> parameters{std::to_string(config_.world), std::to_string(region),
|
||||
std::to_string(kind - command_kinds.begin())};
|
||||
for (const auto& x : v)
|
||||
parameters.push_back(std::to_string(x.value_or(0))); // All present: checked above.
|
||||
parameters.push_back(author);
|
||||
parameters.push_back(reason.value_or(""));
|
||||
if (!db_ && connect_)
|
||||
db_ = connect_();
|
||||
if (!db_)
|
||||
return error(503, "unavailable");
|
||||
const auto rows =
|
||||
db_->query("SELECT command_id, target FROM evolution.admin_enqueue_command_v1("
|
||||
"$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)",
|
||||
parameters, config_.db_timeout);
|
||||
if (!rows) {
|
||||
// An invalid command is refused by the database (SQLSTATE 22023); keep the connection.
|
||||
const bool invalid = rows.error().kind == persistence::PgError::sql &&
|
||||
std::string_view{rows.error().sqlstate.data(), 5} == "22023";
|
||||
if (!invalid)
|
||||
db_.reset();
|
||||
return error(invalid ? 400 : 503, invalid ? "invalid_command" : "unavailable");
|
||||
}
|
||||
if (rows->empty())
|
||||
return error(503, "unavailable");
|
||||
return json(200, "{\"id\":" + text_value(at(rows->front(), 0)) +
|
||||
",\"target\":" + text_value(at(rows->front(), 1)) + "}\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");
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <atomic>
|
||||
#include <charconv>
|
||||
#include <chrono>
|
||||
#include <limits>
|
||||
#include <thread>
|
||||
@@ -448,6 +449,9 @@ void CellularRegionHost::resolve() {
|
||||
finalized_actions_.push_back({action, committed_->head.sequence});
|
||||
finalize_births(pending_->births);
|
||||
finalize_mutations(pending_->mutation_actions, pending_->prepared.results);
|
||||
// The store knows which admin commands this commit bound: read the queue again.
|
||||
queued_admin_.clear();
|
||||
next_admin_reload_ = {};
|
||||
pending_.reset();
|
||||
++status_.commits;
|
||||
status_.committed_sequence = committed_->head.sequence;
|
||||
@@ -738,6 +742,8 @@ const HostStatus& CellularRegionHost::step() {
|
||||
reconcile_interval();
|
||||
if (!pending_ && state_ && mutations_uncertain_ && status_.phase == HostPhase::running)
|
||||
reload_mutations();
|
||||
if (!pending_ && state_ && status_.phase == HostPhase::running)
|
||||
reload_admin_commands();
|
||||
if (!pending_ && state_ && status_.phase == HostPhase::running)
|
||||
flush_endings();
|
||||
refresh();
|
||||
@@ -928,6 +934,64 @@ CellularRegionHost::select_mutation(const persistence::Uuid& account, std::uint6
|
||||
return {admitted, tick, {}};
|
||||
}
|
||||
|
||||
std::vector<CellularAdminCommand> CellularRegionHost::unbound_admin_commands() const {
|
||||
std::vector<CellularAdminCommand> unbound;
|
||||
for (const auto& queued : queued_admin_) {
|
||||
if (unbound.size() >= max_cellular_tick_admin_commands)
|
||||
break;
|
||||
const bool flying =
|
||||
in_flight_ && std::ranges::any_of(in_flight_->batch.ticks, [&](const auto& tick) {
|
||||
return std::ranges::find(tick.admin, queued.id, &CellularAdminCommand::id) !=
|
||||
tick.admin.end();
|
||||
});
|
||||
if (!flying)
|
||||
unbound.push_back(queued);
|
||||
}
|
||||
return unbound;
|
||||
}
|
||||
|
||||
// ADR-0182: the region's unpublished admin commands, every 2 s (rules 13 only).
|
||||
void CellularRegionHost::reload_admin_commands() {
|
||||
const auto now = std::chrono::steady_clock::now();
|
||||
if (now < next_admin_reload_ || !committed_ ||
|
||||
state_->rules_version() < cellular_lives_revamp_rules || !database())
|
||||
return;
|
||||
next_admin_reload_ = now + std::chrono::seconds{2};
|
||||
const std::array<std::string, 2> parameters{std::to_string(config_.key.world),
|
||||
std::to_string(config_.key.region)};
|
||||
const auto rows = db_->query(
|
||||
"SELECT command_id, kind, cell_count, target, energy, carbon, nitrogen, phosphorus, other "
|
||||
"FROM evolution.load_pending_admin_commands_v1($1::evolution.u64, $2::evolution.u64)",
|
||||
parameters, config_.lease.commit_timeout);
|
||||
if (!rows) {
|
||||
db_.reset();
|
||||
++status_.store_failures;
|
||||
return;
|
||||
}
|
||||
std::vector<CellularAdminCommand> loaded;
|
||||
for (const auto& row : *rows) {
|
||||
std::array<std::uint64_t, 9> v{};
|
||||
bool ok = row.size() == v.size();
|
||||
for (std::size_t i = 0; ok && i < v.size(); ++i) {
|
||||
const auto& text = row[i];
|
||||
ok = text.has_value() &&
|
||||
std::from_chars(text->data(), text->data() + text->size(), v[i]).ec == std::errc{};
|
||||
}
|
||||
if (!ok || v[1] > 0xFF || v[2] > 0xFFFF)
|
||||
continue;
|
||||
CellularAdminCommand command{v[0],
|
||||
static_cast<CellularAdminKind>(v[1]),
|
||||
static_cast<std::uint16_t>(v[2]),
|
||||
v[3],
|
||||
{{v[4]}, {}}};
|
||||
for (std::size_t c = 0; c < command.amount.matter.size(); ++c)
|
||||
command.amount.matter[c].value = v[5 + c];
|
||||
if (cellular_admin_command_valid(command))
|
||||
loaded.push_back(command);
|
||||
}
|
||||
queued_admin_ = std::move(loaded);
|
||||
}
|
||||
|
||||
std::vector<persistence::CellularMutationReservation>
|
||||
CellularRegionHost::unbound_mutations() const {
|
||||
std::vector<persistence::CellularMutationReservation> unbound;
|
||||
@@ -1091,6 +1155,10 @@ CellularRegionHost::finish_publication(
|
||||
for (const auto result : published->mutation_results)
|
||||
results.push_back(static_cast<std::uint8_t>(result));
|
||||
finalize_mutations(mutation_actions, results);
|
||||
for (const auto& tick : batch.ticks)
|
||||
for (const auto& command : tick.admin)
|
||||
std::erase_if(queued_admin_,
|
||||
[&](const auto& queued) { return queued.id == command.id; });
|
||||
++status_.commits;
|
||||
status_.committed_sequence = committed_->head.sequence;
|
||||
status_.committed_tick = committed_->head.end_tick;
|
||||
|
||||
@@ -34,20 +34,29 @@ bool valid_header(const CellularBatchHeader& h, std::size_t ticks) {
|
||||
}
|
||||
bool known_format(std::uint32_t format) {
|
||||
return format == cellular_batch_legacy_format || format == cellular_batch_v2_format ||
|
||||
format == cellular_batch_format || format == cellular_batch_inheritance_format;
|
||||
format == cellular_batch_format || format == cellular_batch_inheritance_format ||
|
||||
format == cellular_batch_admin_format;
|
||||
}
|
||||
bool owner_version_matches(const CellularLives& owner, const CellularBatch& batch) {
|
||||
if (!known_format(batch.format_version))
|
||||
return false;
|
||||
if (batch.format_version == cellular_batch_admin_format)
|
||||
return owner.format_version() == cellular_lives_revamp_format &&
|
||||
owner.rules_version() >= cellular_lives_revamp_rules;
|
||||
if (batch.format_version == cellular_batch_inheritance_format)
|
||||
return owner.format_version() >= cellular_lives_inheritance_format &&
|
||||
cellular_retained_plans(owner.rules_version());
|
||||
return owner.format_version() < cellular_lives_inheritance_format;
|
||||
}
|
||||
bool payload_version_matches(const CellularBatch& batch) {
|
||||
// ADR-0182: trace 5 only with a command; a batch without one is trace 4.
|
||||
if (batch.format_version == cellular_batch_admin_format &&
|
||||
std::ranges::none_of(batch.ticks, [](const auto& tick) { return !tick.admin.empty(); }))
|
||||
return false;
|
||||
return std::ranges::all_of(batch.ticks, [&](const auto& tick) {
|
||||
return (batch.format_version >= cellular_batch_v2_format || tick.births.empty()) &&
|
||||
(batch.format_version >= cellular_batch_format || tick.mutations.empty());
|
||||
(batch.format_version >= cellular_batch_format || tick.mutations.empty()) &&
|
||||
(batch.format_version == cellular_batch_admin_format || tick.admin.empty());
|
||||
});
|
||||
}
|
||||
bool valid_intent(const CellularLifeIntent& life) {
|
||||
@@ -84,6 +93,12 @@ bool valid_ticks(std::span<const CellularTickIntents> ticks) {
|
||||
if (!identities.insert(birth.identity).second || !accounts.insert(birth.account).second)
|
||||
return false;
|
||||
}
|
||||
if (tick.admin.size() > max_cellular_tick_admin_commands)
|
||||
return false;
|
||||
for (std::size_t i = 0; i < tick.admin.size(); ++i)
|
||||
if (!cellular_admin_command_valid(tick.admin[i]) ||
|
||||
(i > 0 && tick.admin[i - 1].id >= tick.admin[i].id))
|
||||
return false;
|
||||
for (std::size_t i = 0; i < tick.mutations.size(); ++i) {
|
||||
const auto& mutation = tick.mutations[i];
|
||||
if (mutation.life_id == 0 || mutation.event_index == 0 || mutation.offer_tick == 0 ||
|
||||
@@ -198,7 +213,8 @@ encode_cellular_batch(const CellularBatch& batch) {
|
||||
: 0) +
|
||||
(batch.format_version >= cellular_batch_format
|
||||
? tick.mutations.size() * cellular_batch_mutation_bytes
|
||||
: 0);
|
||||
: 0) +
|
||||
tick.admin.size() * cellular_batch_admin_bytes;
|
||||
if (records > max_cellular_batch_bytes - size - tick_header_bytes)
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
size += tick_header_bytes + records;
|
||||
@@ -224,7 +240,7 @@ encode_cellular_batch(const CellularBatch& batch) {
|
||||
put(out, tick.births.size(), 4);
|
||||
if (batch.format_version >= cellular_batch_format) {
|
||||
put(out, tick.mutations.size(), 4);
|
||||
put(out, 0, 4);
|
||||
put(out, tick.admin.size(), 4); // Zero before format 5.
|
||||
}
|
||||
for (const auto& life : tick.lives)
|
||||
put_intent(out, life);
|
||||
@@ -247,6 +263,16 @@ encode_cellular_batch(const CellularBatch& batch) {
|
||||
put(out, mutation.become ? 1 : 0, 1); // Byte 34 (rules 13).
|
||||
put(out, 0, 5);
|
||||
}
|
||||
for (const auto& command : tick.admin) {
|
||||
put(out, command.id, 8);
|
||||
put(out, static_cast<std::uint16_t>(command.kind), 2);
|
||||
put(out, command.count, 2);
|
||||
put(out, 0, 4);
|
||||
put(out, command.target, 8);
|
||||
put(out, command.amount.energy.value, 8);
|
||||
for (const auto& channel : command.amount.matter)
|
||||
put(out, channel.value, 8);
|
||||
}
|
||||
}
|
||||
if (out.size() != size)
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
@@ -259,8 +285,8 @@ decode_cellular_batch(std::span<const std::uint8_t> bytes) {
|
||||
!std::ranges::equal(bytes.first(magic.size()), magic))
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
const auto format = get(bytes, 8, 4);
|
||||
if (format > cellular_batch_inheritance_format ||
|
||||
!known_format(static_cast<std::uint32_t>(format)) || get(bytes, 12, 4) != 4)
|
||||
if (format > cellular_batch_admin_format || !known_format(static_cast<std::uint32_t>(format)) ||
|
||||
get(bytes, 12, 4) != 4)
|
||||
return std::unexpected{CellularBatchError::version};
|
||||
if (get(bytes, 108, 4) != 0)
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
@@ -298,13 +324,16 @@ decode_cellular_batch(std::span<const std::uint8_t> bytes) {
|
||||
birth_count = get(bytes, offset, 4);
|
||||
offset += 4;
|
||||
}
|
||||
std::uint64_t mutation_count{};
|
||||
std::uint64_t mutation_count{}, admin_count{};
|
||||
if (format >= cellular_batch_format) {
|
||||
mutation_count = get(bytes, offset, 4);
|
||||
if (get(bytes, offset + 4, 4) != 0)
|
||||
admin_count = get(bytes, offset + 4, 4);
|
||||
if (format != cellular_batch_admin_format && admin_count != 0)
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
offset += 8;
|
||||
}
|
||||
if (admin_count > max_cellular_tick_admin_commands)
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
if (count > biology::max_cellular_tick_lives ||
|
||||
count > (bytes.size() - offset) / cellular_batch_intent_bytes ||
|
||||
birth_count > biology::max_cellular_tick_lives ||
|
||||
@@ -381,9 +410,29 @@ decode_cellular_batch(std::span<const std::uint8_t> bytes) {
|
||||
step.mutations.push_back(mutation);
|
||||
offset += cellular_batch_mutation_bytes;
|
||||
}
|
||||
if (admin_count > (bytes.size() - offset) / cellular_batch_admin_bytes)
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
for (std::uint64_t i = 0; i < admin_count; ++i) {
|
||||
const auto record = bytes.subspan(offset, cellular_batch_admin_bytes);
|
||||
CellularAdminCommand command;
|
||||
command.id = get(record, 0, 8);
|
||||
const auto kind = get(record, 8, 2);
|
||||
if (kind > 0xFF)
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
command.kind = static_cast<CellularAdminKind>(kind);
|
||||
command.count = static_cast<std::uint16_t>(get(record, 10, 2));
|
||||
command.target = get(record, 16, 8);
|
||||
command.amount.energy.value = get(record, 24, 8);
|
||||
for (std::size_t c = 0; c < command.amount.matter.size(); ++c)
|
||||
command.amount.matter[c].value = get(record, 32 + 8 * c, 8);
|
||||
if (!all_zero(record.subspan(12, 4)))
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
step.admin.push_back(command);
|
||||
offset += cellular_batch_admin_bytes;
|
||||
}
|
||||
out.ticks.push_back(std::move(step));
|
||||
}
|
||||
if (offset != bytes.size() || !valid_ticks(out.ticks))
|
||||
if (offset != bytes.size() || !valid_ticks(out.ticks) || !payload_version_matches(out))
|
||||
return std::unexpected{CellularBatchError::format};
|
||||
return out;
|
||||
}
|
||||
@@ -433,7 +482,16 @@ decode_cellular_mutation_input(const std::array<std::uint8_t, 16>& account, std:
|
||||
std::expected<std::unique_ptr<CellularLives>, CellularBatchError>
|
||||
replay_cellular_batch(const CellularLives& base, const CellularBatch& batch,
|
||||
std::vector<CellularMutationOutcome>& mutation_outcomes) {
|
||||
std::vector<CellularAdminResult> ignored;
|
||||
return replay_cellular_batch(base, batch, mutation_outcomes, ignored);
|
||||
}
|
||||
|
||||
std::expected<std::unique_ptr<CellularLives>, CellularBatchError>
|
||||
replay_cellular_batch(const CellularLives& base, const CellularBatch& batch,
|
||||
std::vector<CellularMutationOutcome>& mutation_outcomes,
|
||||
std::vector<CellularAdminResult>& admin_results) {
|
||||
mutation_outcomes.clear();
|
||||
admin_results.clear();
|
||||
if (!owner_version_matches(base, batch))
|
||||
return std::unexpected{CellularBatchError::version};
|
||||
const auto& h = batch.header;
|
||||
@@ -448,6 +506,7 @@ replay_cellular_batch(const CellularLives& base, const CellularBatch& batch,
|
||||
if (!replay)
|
||||
return std::unexpected{CellularBatchError::state};
|
||||
std::vector<CellularMutationOutcome> complete_outcomes;
|
||||
std::vector<CellularAdminResult> complete_admin;
|
||||
for (const auto& tick : batch.ticks) {
|
||||
const auto executed = (*replay)->advance_tick_with_mutations(tick.lives, tick.mutations);
|
||||
if (!executed)
|
||||
@@ -467,8 +526,17 @@ replay_cellular_batch(const CellularLives& base, const CellularBatch& batch,
|
||||
return std::unexpected{CellularBatchError::state};
|
||||
*replay = std::move(*born);
|
||||
}
|
||||
if (!tick.admin.empty()) {
|
||||
std::vector<CellularAdminResult> results;
|
||||
auto applied = (*replay)->admin_candidate(tick.admin, &results);
|
||||
if (!applied)
|
||||
return std::unexpected{CellularBatchError::state};
|
||||
*replay = std::move(*applied);
|
||||
complete_admin.insert(complete_admin.end(), results.begin(), results.end());
|
||||
}
|
||||
}
|
||||
mutation_outcomes = std::move(complete_outcomes);
|
||||
admin_results = std::move(complete_admin);
|
||||
return std::move(*replay);
|
||||
}
|
||||
|
||||
|
||||
@@ -1344,103 +1344,268 @@ CellularLives::revamp_upgrade_candidate(const CellularRevampRules& rules, std::u
|
||||
next.archive.archived() != 0 || count >= rules.organism_cap || count > 255 || first == 0 ||
|
||||
first > cellular_bud_namespace - count)
|
||||
return std::unexpected{CellularLivesError::invalid_config};
|
||||
for (std::uint32_t index = 0; index < count; ++index) {
|
||||
const auto id = first + index;
|
||||
const auto founder = biology::primitive_founder(id, id, biology::primitive_founder_v6);
|
||||
if (!founder)
|
||||
return std::unexpected{CellularLivesError::biology};
|
||||
biology::GenomeDraft draft{
|
||||
.id = id,
|
||||
.origin_event = id,
|
||||
.development_version = 7,
|
||||
.parents = {},
|
||||
.capabilities = {founder->capabilities().begin(), founder->capabilities().end()},
|
||||
.schema_version = biology::genome_schema_v7,
|
||||
.movement_arrangement = biology::founder_movement_arrangement,
|
||||
.cellular_traits = biology::founder_cellular_traits};
|
||||
Random random{mutation_seed(world(), region(), id, 0x57494C44U)};
|
||||
const auto points = [&] { return static_cast<std::uint16_t>(75 + random.next() % 51); };
|
||||
auto& traits = *draft.cellular_traits;
|
||||
traits.density = points();
|
||||
traits.upkeep_efficiency = points();
|
||||
traits.growth_speed = points();
|
||||
for (auto& channel : traits.collection)
|
||||
channel = points();
|
||||
for (auto& channel : traits.burn)
|
||||
channel = points();
|
||||
traits.engulf_capacity = points();
|
||||
traits.kill_absorption = points();
|
||||
auto& movement = *draft.movement_arrangement;
|
||||
movement.output = points();
|
||||
movement.efficiency = points();
|
||||
movement.steering = points();
|
||||
movement.streamlining = points();
|
||||
movement.braking = points();
|
||||
movement.coasting = points();
|
||||
const auto genome = biology::Genome::create(draft);
|
||||
const auto budget =
|
||||
genome ? biology::metabolic_budget(*genome, {1000, 0},
|
||||
{next.config.ambient_temperature_millikelvin, {}},
|
||||
1000, rules.body)
|
||||
: std::unexpected{biology::DevelopmentError::overflow};
|
||||
if (!budget)
|
||||
return std::unexpected{CellularLivesError::biology};
|
||||
// A normal founder's starting provision, evaluated for its randomized genome.
|
||||
const accounting::Inventory reserve{
|
||||
{budget->demand.value * biology::founder_reserve_seconds}, {}};
|
||||
auto empty_body = accounting::Inventory{};
|
||||
auto nursery = next.nursery;
|
||||
auto heat = next.heat;
|
||||
const auto development = biology::rules_for(genome->development_version());
|
||||
if (!development || !subtract_inventory(nursery, reserve) ||
|
||||
!rebody(empty_body, nursery, heat, budget->body,
|
||||
development->construction_per_kilogram))
|
||||
return std::unexpected{CellularLivesError::insufficient_funding};
|
||||
const auto extent = budget->phenotype.extent;
|
||||
if (next.config.area.width_um <= extent + 2000 ||
|
||||
next.config.area.height_um <= extent + 2000)
|
||||
return std::unexpected{CellularLivesError::no_placement};
|
||||
std::optional<biology::CellularPosition> position;
|
||||
for (int attempt = 0; attempt < 1024 && !position; ++attempt) {
|
||||
const biology::CellularPosition spot{
|
||||
1000 + random.next() % (next.config.area.width_um - extent - 2000),
|
||||
1000 + random.next() % (next.config.area.height_um - extent - 2000)};
|
||||
bool occupied = false;
|
||||
for (const auto& other : next.lives) {
|
||||
const auto body = budget_for(
|
||||
next.archive, other, next.config.ambient_temperature_millikelvin, rules.body);
|
||||
if (!body)
|
||||
return std::unexpected{CellularLivesError::biology};
|
||||
const auto side = body->phenotype.extent;
|
||||
occupied = occupied || (spot.x_um < other.position.x_um + side &&
|
||||
other.position.x_um < spot.x_um + extent &&
|
||||
spot.y_um < other.position.y_um + side &&
|
||||
other.position.y_um < spot.y_um + extent);
|
||||
}
|
||||
if (!occupied)
|
||||
position = spot;
|
||||
}
|
||||
if (!position)
|
||||
return std::unexpected{CellularLivesError::no_placement};
|
||||
if (!next.archive.admit(*genome) || !next.archive.record_birth(id, id, {tick()}))
|
||||
return std::unexpected{CellularLivesError::archive};
|
||||
CellularOwnedLife life{};
|
||||
life.identity = {id, id, id, id, {tick()}};
|
||||
life.source = next.nursery_config.source;
|
||||
life.growth = {1000, 0};
|
||||
life.position = *position;
|
||||
life.body = budget->body;
|
||||
life.reserve = reserve;
|
||||
life.offspring_genome = id;
|
||||
next.lives.push_back(life);
|
||||
next.nursery = nursery;
|
||||
next.nursery_config.funding = nursery;
|
||||
next.heat = heat;
|
||||
}
|
||||
for (std::uint32_t index = 0; index < count; ++index)
|
||||
if (const auto error =
|
||||
seed_wildlife_root(next, world(), region(), tick(), first + index, nullptr))
|
||||
return std::unexpected{*error};
|
||||
// Restore validates bodies, identities, history and channel-by-channel closure.
|
||||
return restore((*candidate)->snapshot(), world(), region(), frame(), tick());
|
||||
}
|
||||
|
||||
std::optional<CellularLivesError>
|
||||
CellularLives::seed_wildlife_root(State& next, std::uint64_t world, std::uint64_t region,
|
||||
std::uint64_t tick, std::uint64_t id,
|
||||
accounting::Inventory* imported) {
|
||||
const auto& rules = next.revamp;
|
||||
const auto founder = biology::primitive_founder(id, id, biology::primitive_founder_v6);
|
||||
if (!founder)
|
||||
return CellularLivesError::biology;
|
||||
biology::GenomeDraft draft{
|
||||
.id = id,
|
||||
.origin_event = id,
|
||||
.development_version = 7,
|
||||
.parents = {},
|
||||
.capabilities = {founder->capabilities().begin(), founder->capabilities().end()},
|
||||
.schema_version = biology::genome_schema_v7,
|
||||
.movement_arrangement = biology::founder_movement_arrangement,
|
||||
.cellular_traits = biology::founder_cellular_traits};
|
||||
Random random{mutation_seed(world, region, id, 0x57494C44U)};
|
||||
const auto points = [&] { return static_cast<std::uint16_t>(75 + random.next() % 51); };
|
||||
auto& traits = *draft.cellular_traits;
|
||||
traits.density = points();
|
||||
traits.upkeep_efficiency = points();
|
||||
traits.growth_speed = points();
|
||||
for (auto& channel : traits.collection)
|
||||
channel = points();
|
||||
for (auto& channel : traits.burn)
|
||||
channel = points();
|
||||
traits.engulf_capacity = points();
|
||||
traits.kill_absorption = points();
|
||||
auto& movement = *draft.movement_arrangement;
|
||||
movement.output = points();
|
||||
movement.efficiency = points();
|
||||
movement.steering = points();
|
||||
movement.streamlining = points();
|
||||
movement.braking = points();
|
||||
movement.coasting = points();
|
||||
const auto genome = biology::Genome::create(draft);
|
||||
const auto budget =
|
||||
genome ? biology::metabolic_budget(*genome, {1000, 0},
|
||||
{next.config.ambient_temperature_millikelvin, {}}, 1000,
|
||||
rules.body)
|
||||
: std::unexpected{biology::DevelopmentError::overflow};
|
||||
if (!budget)
|
||||
return CellularLivesError::biology;
|
||||
// A normal founder's starting provision, evaluated for its randomized genome.
|
||||
const accounting::Inventory reserve{{budget->demand.value * biology::founder_reserve_seconds},
|
||||
{}};
|
||||
auto empty_body = accounting::Inventory{};
|
||||
const auto development = biology::rules_for(genome->development_version());
|
||||
if (!development)
|
||||
return CellularLivesError::insufficient_funding;
|
||||
// ADR-0182: an import pays exactly the reserve, the body's matter and its construction.
|
||||
auto funding = next.nursery;
|
||||
if (imported) {
|
||||
std::uint64_t added{};
|
||||
funding = reserve;
|
||||
for (std::size_t c = 0; c < funding.matter.size(); ++c) {
|
||||
funding.matter[c] = budget->body.matter[c];
|
||||
added += budget->body.matter[c].value;
|
||||
}
|
||||
const auto price = development->construction_per_kilogram;
|
||||
funding.energy.value += added / 1'000 * price + added % 1'000 * price / 1'000;
|
||||
}
|
||||
const auto paid = funding;
|
||||
auto heat = next.heat;
|
||||
if (!subtract_inventory(funding, reserve) ||
|
||||
!rebody(empty_body, funding, heat, budget->body, development->construction_per_kilogram))
|
||||
return CellularLivesError::insufficient_funding;
|
||||
const auto extent = budget->phenotype.extent;
|
||||
if (next.config.area.width_um <= extent + 2000 || next.config.area.height_um <= extent + 2000)
|
||||
return CellularLivesError::no_placement;
|
||||
std::optional<biology::CellularPosition> position;
|
||||
for (int attempt = 0; attempt < 1024 && !position; ++attempt) {
|
||||
const biology::CellularPosition spot{
|
||||
1000 + random.next() % (next.config.area.width_um - extent - 2000),
|
||||
1000 + random.next() % (next.config.area.height_um - extent - 2000)};
|
||||
bool occupied = false;
|
||||
for (const auto& other : next.lives) {
|
||||
const auto body = budget_for(next.archive, other,
|
||||
next.config.ambient_temperature_millikelvin, rules.body);
|
||||
if (!body)
|
||||
return CellularLivesError::biology;
|
||||
const auto side = body->phenotype.extent;
|
||||
occupied = occupied || (spot.x_um < other.position.x_um + side &&
|
||||
other.position.x_um < spot.x_um + extent &&
|
||||
spot.y_um < other.position.y_um + side &&
|
||||
other.position.y_um < spot.y_um + extent);
|
||||
}
|
||||
if (!occupied)
|
||||
position = spot;
|
||||
}
|
||||
if (!position)
|
||||
return CellularLivesError::no_placement;
|
||||
if (!next.archive.admit(*genome) || !next.archive.record_birth(id, id, {tick}))
|
||||
return CellularLivesError::archive;
|
||||
CellularOwnedLife life{};
|
||||
life.identity = {id, id, id, id, {tick}};
|
||||
life.source = next.nursery_config.source;
|
||||
life.growth = {1000, 0};
|
||||
life.position = *position;
|
||||
life.body = budget->body;
|
||||
life.reserve = reserve;
|
||||
life.offspring_genome = id;
|
||||
const auto at = std::ranges::lower_bound(next.lives, id, {},
|
||||
[](const auto& value) { return value.identity.life; });
|
||||
next.lives.insert(at, life);
|
||||
if (imported) {
|
||||
if (funding != accounting::Inventory{} || !add_inventory(*imported, paid))
|
||||
return CellularLivesError::conservation;
|
||||
} else {
|
||||
next.nursery = funding;
|
||||
next.nursery_config.funding = funding;
|
||||
}
|
||||
next.heat = heat;
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
bool cellular_admin_command_valid(const CellularAdminCommand& c) noexcept {
|
||||
const bool some = c.amount != accounting::Inventory{};
|
||||
switch (c.kind) {
|
||||
case CellularAdminKind::remove_cell:
|
||||
return c.id != 0 && c.target != 0 && c.count == 0 && !some;
|
||||
case CellularAdminKind::grant_reserve:
|
||||
return c.id != 0 && c.target != 0 && c.count == 0 && some;
|
||||
case CellularAdminKind::add_bubbles:
|
||||
case CellularAdminKind::release_pool:
|
||||
return c.id != 0 && c.target == 0 && c.count >= 1 && c.count <= 256 && some;
|
||||
case CellularAdminKind::add_pool:
|
||||
return c.id != 0 && c.target == 0 && c.count == 0 && some;
|
||||
case CellularAdminKind::spawn_wildlife:
|
||||
return c.id != 0 && c.count >= 1 && c.count <= 64 && !some && c.target != 0 &&
|
||||
c.target <= cellular_bud_namespace - c.count;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
|
||||
CellularLives::admin_candidate(std::span<const CellularAdminCommand> commands,
|
||||
std::vector<CellularAdminResult>* results) const {
|
||||
if (state_->format_version != cellular_lives_revamp_format ||
|
||||
state_->rules_version < cellular_lives_revamp_rules)
|
||||
return std::unexpected{CellularLivesError::version};
|
||||
for (std::size_t i = 0; i < commands.size(); ++i)
|
||||
if (!cellular_admin_command_valid(commands[i]) ||
|
||||
(i != 0 && commands[i - 1].id >= commands[i].id))
|
||||
return std::unexpected{CellularLivesError::invalid_config};
|
||||
auto candidate = restore(snapshot(), world(), region(), frame(), tick());
|
||||
if (!candidate)
|
||||
return std::unexpected(candidate.error());
|
||||
std::vector<CellularAdminResult> report;
|
||||
for (const auto& command : commands) {
|
||||
// Each command works on a copy, kept only when it applies and still closes.
|
||||
auto attempt = restore((*candidate)->snapshot(), world(), region(), frame(), tick());
|
||||
if (!attempt)
|
||||
return std::unexpected(attempt.error());
|
||||
auto& next = *(*attempt)->state_;
|
||||
bool applied = false;
|
||||
const auto life = std::ranges::lower_bound(next.lives, command.target, {},
|
||||
[](const auto& v) { return v.identity.life; });
|
||||
const bool found = life != next.lives.end() && life->identity.life == command.target;
|
||||
switch (command.kind) {
|
||||
case CellularAdminKind::remove_cell:
|
||||
if (found && next.archive.record_death(life->identity.organism, {tick()})) {
|
||||
auto single = *life;
|
||||
single.revamp.members = 1; // A corpse records the single-cell extent.
|
||||
const auto extent =
|
||||
budget_for(next.archive, single, next.config.ambient_temperature_millikelvin,
|
||||
next.revamp.body);
|
||||
if (extent && add_inventory(next.spent, life->body) &&
|
||||
add_inventory(next.spent, life->reserve)) {
|
||||
CellularOwnedCorpse corpse{life->identity.life,
|
||||
life->identity.organism,
|
||||
life->source,
|
||||
tick(),
|
||||
life->position,
|
||||
life->growth,
|
||||
extent->phenotype.extent,
|
||||
{},
|
||||
biology::CellularDeathCause::removed,
|
||||
0,
|
||||
life->parent_life,
|
||||
life->offspring_genome};
|
||||
const auto at = std::ranges::lower_bound(next.corpses, corpse.organism, {},
|
||||
&CellularOwnedCorpse::organism);
|
||||
next.corpses.insert(at, corpse);
|
||||
next.lives.erase(life);
|
||||
applied = true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CellularAdminKind::grant_reserve:
|
||||
applied = found && add_inventory(life->reserve, command.amount) &&
|
||||
add_inventory(next.boundary.incoming, command.amount);
|
||||
break;
|
||||
case CellularAdminKind::add_pool:
|
||||
applied = add_inventory(next.spent, command.amount) &&
|
||||
add_inventory(next.boundary.incoming, command.amount);
|
||||
break;
|
||||
case CellularAdminKind::add_bubbles:
|
||||
case CellularAdminKind::release_pool: {
|
||||
const bool release = command.kind == CellularAdminKind::release_pool;
|
||||
auto amount = command.amount;
|
||||
if (release) // Never more than the pool holds.
|
||||
for (std::size_t c = 0; c < 5; ++c) {
|
||||
auto& want = c == 0 ? amount.energy.value : amount.matter[c - 1].value;
|
||||
const auto have =
|
||||
c == 0 ? next.spent.energy.value : next.spent.matter[c - 1].value;
|
||||
want = std::min(want, have);
|
||||
}
|
||||
auto config = next.habitat->config();
|
||||
if (amount != accounting::Inventory{} &&
|
||||
(release ? subtract_inventory(next.spent, amount)
|
||||
: add_inventory(next.boundary.incoming, amount)) &&
|
||||
cellular_scatter_bubbles(config, amount, command.count,
|
||||
mutation_seed(world(), region(), command.id, tick()),
|
||||
next.nursery_config.source)) {
|
||||
if (auto habitat = biology::CellularHabitat::create(std::move(config))) {
|
||||
next.habitat = std::move(*habitat);
|
||||
applied = true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case CellularAdminKind::spawn_wildlife: {
|
||||
if (next.lives.size() + command.count >= next.revamp.organism_cap)
|
||||
break;
|
||||
accounting::Inventory imported{};
|
||||
bool ok = true;
|
||||
for (std::uint16_t i = 0; ok && i < command.count; ++i) {
|
||||
const auto id = command.target + i;
|
||||
ok = !std::ranges::binary_search(next.lives, id, {},
|
||||
[](const auto& v) { return v.identity.life; }) &&
|
||||
!next.archive.find(id) &&
|
||||
!seed_wildlife_root(next, world(), region(), tick(), id, &imported);
|
||||
}
|
||||
applied = ok && add_inventory(next.boundary.incoming, imported);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (applied) {
|
||||
// Restore checks bodies, identities, history and channel-by-channel closure.
|
||||
auto checked = restore((*attempt)->snapshot(), world(), region(), frame(), tick());
|
||||
if (checked)
|
||||
candidate = std::move(checked);
|
||||
else
|
||||
applied = false;
|
||||
}
|
||||
report.push_back({command.id, applied});
|
||||
}
|
||||
if (results)
|
||||
*results = std::move(report);
|
||||
return std::move(*candidate);
|
||||
}
|
||||
|
||||
std::optional<accounting::Inventory> CellularLives::budding_cost(std::uint64_t id) const {
|
||||
const auto life =
|
||||
std::ranges::find(state_->lives, id, [](const auto& value) { return value.identity.life; });
|
||||
@@ -2354,7 +2519,8 @@ CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
|
||||
const bool engulfed = corpse.cause == biology::CellularDeathCause::engulfed;
|
||||
const bool revamp_cause =
|
||||
revamp_version && (corpse.cause == biology::CellularDeathCause::merged ||
|
||||
corpse.cause == biology::CellularDeathCause::emerged);
|
||||
corpse.cause == biology::CellularDeathCause::emerged ||
|
||||
corpse.cause == biology::CellularDeathCause::removed);
|
||||
if (padding != 0 ||
|
||||
(corpse.cause != biology::CellularDeathCause::starved && !engulfed &&
|
||||
!revamp_cause) ||
|
||||
|
||||
@@ -48,6 +48,7 @@ summarize_cellular_play(const CellularLives& state) {
|
||||
++summary.engulfed;
|
||||
break;
|
||||
case biology::CellularDeathCause::unrecorded:
|
||||
case biology::CellularDeathCause::removed: // ADR-0182: an operator's, not biology's.
|
||||
++summary.unrecorded;
|
||||
break;
|
||||
case biology::CellularDeathCause::merged:
|
||||
|
||||
@@ -59,8 +59,9 @@ bool cellular_revamp_valid(const CellularRevampRules& rules) noexcept {
|
||||
rules.split_share_per_thousand < 1'000 && rules.split_min_growth != 0 &&
|
||||
rules.split_min_growth <= 1'000 && rules.bud_fee_scale_percent <= 100 &&
|
||||
rules.bud_fee.energy.value <= most &&
|
||||
std::ranges::all_of(rules.bud_fee.matter,
|
||||
[](const accounting::Femtograms& f) { return f.value <= most; }) &&
|
||||
std::ranges::all_of(
|
||||
rules.bud_fee.matter,
|
||||
[](const accounting::Femtograms& f) { return f.value <= most; }) &&
|
||||
rules.organism_cap != 0 && rules.organism_cap <= biology::max_cellular_tick_lives &&
|
||||
rules.organism_load_per_thousand <= 10'000 && rules.emerge_members >= 2 &&
|
||||
rules.emerge_members <= 10'000 && rules.emerge_mass_fg <= most &&
|
||||
@@ -133,6 +134,44 @@ bool cellular_drip_spent(biology::CellularHabitatConfig& config, accounting::Inv
|
||||
return true;
|
||||
}
|
||||
|
||||
bool cellular_scatter_bubbles(biology::CellularHabitatConfig& config,
|
||||
const accounting::Inventory& amount, std::uint16_t count,
|
||||
std::uint64_t seed, std::uint64_t source) {
|
||||
if (count == 0 || config.patches.size() + count > biology::max_cellular_liquid_deposits ||
|
||||
config.next_deposit > std::numeric_limits<std::uint32_t>::max() - count ||
|
||||
config.width_um == 0 || config.height_um == 0)
|
||||
return false;
|
||||
Random random{seed};
|
||||
const auto by_address = [](const biology::CellularPatch& patch) { return patch.address; };
|
||||
for (std::uint16_t i = 0; i < count; ++i) {
|
||||
biology::CellularPatchAddress address{
|
||||
static_cast<std::uint32_t>(random.next() % config.width_um),
|
||||
static_cast<std::uint32_t>(random.next() % config.height_um)};
|
||||
auto at = std::ranges::lower_bound(config.patches, address, {}, by_address);
|
||||
while (at != config.patches.end() && at->address == address) {
|
||||
address.x_um = address.x_um + 1 < config.width_um ? address.x_um + 1 : 0;
|
||||
at = std::ranges::lower_bound(config.patches, address, {}, by_address);
|
||||
}
|
||||
const bool last = i + 1 == count;
|
||||
const auto share = [&](std::uint64_t total) {
|
||||
return total / count + (last ? total % count : 0);
|
||||
};
|
||||
biology::CellularPatch bubble{address,
|
||||
source,
|
||||
{},
|
||||
config.next_deposit++,
|
||||
biology::cellular_mote_radius_um,
|
||||
biology::CellularDepositKind::mote};
|
||||
bubble.merged = 1;
|
||||
bubble.stock.energy.value = share(amount.energy.value);
|
||||
for (std::size_t c = 0; c < amount.matter.size(); ++c)
|
||||
bubble.stock.matter[c].value = share(amount.matter[c].value);
|
||||
if (bubble.stock != accounting::Inventory{})
|
||||
config.patches.insert(at, bubble);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
std::optional<CellularRevampOffer> cellular_draw_offer(const biology::Genome& plan,
|
||||
const CellularRevampLife& life,
|
||||
const CellularRevampRules& rules,
|
||||
|
||||
@@ -201,24 +201,33 @@ std::expected<void, CellularSessionBatchError> CellularSessionBatchBuilder::appe
|
||||
std::uint64_t tick, std::span<const CellularLifeIntent> baseline,
|
||||
std::span<const network::CarriedAction> actions,
|
||||
std::span<const CellularTickIntents::Birth> births,
|
||||
std::span<const persistence::CellularMutationReservation> mutations) {
|
||||
return append_impl(tick, baseline, actions, births, mutations, false);
|
||||
std::span<const persistence::CellularMutationReservation> mutations,
|
||||
std::span<const CellularAdminCommand> admin) {
|
||||
return append_impl(tick, baseline, actions, births, mutations, admin, false);
|
||||
}
|
||||
std::expected<void, CellularSessionBatchError>
|
||||
CellularSessionBatchBuilder::append_with_birth_refusals(
|
||||
std::uint64_t tick, std::span<const CellularLifeIntent> baseline,
|
||||
std::span<const network::CarriedAction> actions,
|
||||
std::span<const CellularTickIntents::Birth> births,
|
||||
std::span<const persistence::CellularMutationReservation> mutations) {
|
||||
return append_impl(tick, baseline, actions, births, mutations, true);
|
||||
std::span<const persistence::CellularMutationReservation> mutations,
|
||||
std::span<const CellularAdminCommand> admin) {
|
||||
return append_impl(tick, baseline, actions, births, mutations, admin, true);
|
||||
}
|
||||
std::expected<void, CellularSessionBatchError> CellularSessionBatchBuilder::append_impl(
|
||||
std::uint64_t tick, std::span<const CellularLifeIntent> baseline,
|
||||
std::span<const network::CarriedAction> actions,
|
||||
std::span<const CellularTickIntents::Birth> births,
|
||||
std::span<const persistence::CellularMutationReservation> mutations, bool allow_refusals) {
|
||||
std::span<const persistence::CellularMutationReservation> mutations,
|
||||
std::span<const CellularAdminCommand> admin, bool allow_refusals) {
|
||||
if (batch_.ticks.size() >= max_cellular_batch_ticks)
|
||||
return std::unexpected{CellularSessionBatchError::batch_full};
|
||||
// ADR-0182: a command appears once in a publication.
|
||||
for (const auto& command : admin)
|
||||
for (const auto& previous_tick : batch_.ticks)
|
||||
if (std::ranges::find(previous_tick.admin, command.id, &CellularAdminCommand::id) !=
|
||||
previous_tick.admin.end())
|
||||
return std::unexpected{CellularSessionBatchError::duplicate_action};
|
||||
if (actions_.size() + actions.size() > max_cellular_action_records)
|
||||
return std::unexpected{CellularSessionBatchError::action_limit};
|
||||
if (mutation_actions_.size() + mutations.size() > max_cellular_action_records)
|
||||
@@ -267,7 +276,7 @@ std::expected<void, CellularSessionBatchError> CellularSessionBatchBuilder::appe
|
||||
// it byte-for-byte unchanged: check the encodings first, then advance in place. A full
|
||||
// copy per tick costs a restore of the whole region (rules-12 regions hold thousands of
|
||||
// deposits).
|
||||
if (prepared->intents.births.empty()) {
|
||||
if (prepared->intents.births.empty() && admin.empty()) {
|
||||
auto next_batch = batch_;
|
||||
next_batch.ticks.push_back(prepared->intents);
|
||||
next_batch.header.end_tick = tick;
|
||||
@@ -325,8 +334,20 @@ std::expected<void, CellularSessionBatchError> CellularSessionBatchBuilder::appe
|
||||
accepted_births.push_back(birth);
|
||||
}
|
||||
prepared->intents.births = std::move(accepted_births);
|
||||
std::vector<CellularAdminResult> admin_results;
|
||||
if (!admin.empty()) {
|
||||
auto applied = (*next)->admin_candidate(admin, &admin_results);
|
||||
if (!applied) {
|
||||
last_lives_error_ = applied.error();
|
||||
return std::unexpected{CellularSessionBatchError::biology};
|
||||
}
|
||||
*next = std::move(*applied);
|
||||
prepared->intents.admin.assign(admin.begin(), admin.end());
|
||||
}
|
||||
|
||||
auto next_batch = batch_;
|
||||
if (!admin.empty())
|
||||
next_batch.format_version = cellular_batch_admin_format;
|
||||
next_batch.ticks.push_back(std::move(prepared->intents));
|
||||
next_batch.header.end_tick = tick;
|
||||
if (!encode_cellular_batch(next_batch))
|
||||
@@ -345,6 +366,7 @@ std::expected<void, CellularSessionBatchError> CellularSessionBatchBuilder::appe
|
||||
actions_.insert(actions_.end(), prepared->actions.begin(), prepared->actions.end());
|
||||
mutation_actions_ = next_mutation_actions;
|
||||
refused_births_.insert(refused_births_.end(), refused_births.begin(), refused_births.end());
|
||||
admin_results_.insert(admin_results_.end(), admin_results.begin(), admin_results.end());
|
||||
return {};
|
||||
}
|
||||
} // namespace evo::server
|
||||
|
||||
@@ -209,7 +209,9 @@ void version_checks(const CellularLives& base, const CellularBatch& batch) {
|
||||
"action matcher admitted new trace on old owner");
|
||||
empty.format_version = cellular_batch_format;
|
||||
require(replay_cellular_batch(*old, empty).has_value(), "old replay control failed");
|
||||
empty.format_version = 5;
|
||||
empty.format_version = 5; // ADR-0182 trace 5 needs a rules-13 owner.
|
||||
refuse(*old, empty, CellularBatchError::version);
|
||||
empty.format_version = 6;
|
||||
refuse(*old, empty, CellularBatchError::version);
|
||||
require(!encode_cellular_batch(empty), "unknown trace encoded");
|
||||
auto scope = batch;
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
#endif
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
@@ -1492,9 +1493,100 @@ void run_starting_wildlife_publication_tests() {
|
||||
auto tick = publish_cellular_batch(*runtime, **objects, *lease, head, batch, *recovered->state,
|
||||
identity(8), build, 5s);
|
||||
CHECK(tick);
|
||||
head = tick->committed;
|
||||
recovered = recover_cellular_checkpoint(*runtime, **objects, key, *lease, builds, 5s);
|
||||
CHECK(recovered && recovered->state->snapshot() == tick_bytes &&
|
||||
recovered->state->lives().size() == 32);
|
||||
|
||||
// ADR-0182 (schema 63): queued admin commands publish in trace 5 and bind once.
|
||||
CHECK(owner->query("INSERT INTO evolution.life_allocators(world_id, next_identity) "
|
||||
"VALUES ($1, 5000000) ON CONFLICT DO NOTHING",
|
||||
std::array{std::to_string(key.world)}, 5s));
|
||||
const auto enqueue = [&](int kind, int count, std::uint64_t target, std::uint64_t energy) {
|
||||
const auto rows = owner->query(
|
||||
"SELECT command_id, target FROM evolution.admin_enqueue_command_v1($1, $2, $3, $4, "
|
||||
"$5, $6, 0, 0, 0, 0, 'ops', 'test')",
|
||||
std::array{std::to_string(key.world), std::to_string(key.region), std::to_string(kind),
|
||||
std::to_string(count), std::to_string(target), std::to_string(energy)},
|
||||
5s);
|
||||
CHECK(rows && rows->size() == 1);
|
||||
return std::pair{std::stoull(*(*rows)[0][0]), std::stoull(*(*rows)[0][1])};
|
||||
};
|
||||
CHECK(!owner->query("SELECT * FROM evolution.admin_enqueue_command_v1($1, $2, 4, 0, 0, 0, 0, "
|
||||
"0, 0, 0, 'ops', '')",
|
||||
std::array{std::to_string(key.world), std::to_string(key.region)}, 5s));
|
||||
owner = connect_as(env("PGUSER"));
|
||||
const auto victim = recovered->state->lives().front().identity.life;
|
||||
const auto [pool_id, pool_target] = enqueue(4, 0, 0, 1'000'000'000);
|
||||
const auto [spawn_id, first_wild] = enqueue(6, 2, 0, 0);
|
||||
const auto [remove_id, remove_target] = enqueue(1, 0, victim, 0);
|
||||
CHECK(pool_target == 0 && first_wild == 5'000'000 && remove_target == victim);
|
||||
using Kind = evo::server::CellularAdminKind;
|
||||
const std::vector<evo::server::CellularAdminCommand> commands{
|
||||
{static_cast<std::uint64_t>(pool_id), Kind::add_pool, 0, 0, {{1'000'000'000}, {}}},
|
||||
{static_cast<std::uint64_t>(spawn_id), Kind::spawn_wildlife, 2, first_wild, {}},
|
||||
{static_cast<std::uint64_t>(remove_id), Kind::remove_cell, 0, victim, {}}};
|
||||
const auto pending = [&] {
|
||||
const auto rows =
|
||||
runtime->query("SELECT count(*) FROM evolution.load_pending_admin_commands_v1($1, $2)",
|
||||
std::array{std::to_string(key.world), std::to_string(key.region)}, 5s);
|
||||
CHECK(rows && rows->size() == 1);
|
||||
return std::stoull(*(*rows)[0][0]);
|
||||
};
|
||||
CHECK(pending() == 3);
|
||||
const auto admin_batch = [&](std::vector<evo::server::CellularAdminCommand> recorded) {
|
||||
CellularBatch made{{key.world, key.region, 1, head.head.commit, head.head.digest, 2, 3},
|
||||
{{}}};
|
||||
made.format_version = evo::server::cellular_batch_admin_format;
|
||||
made.ticks.front().lives = checked_value(wildlife_intents(*recovered->state, 3));
|
||||
made.ticks.front().admin = std::move(recorded);
|
||||
return made;
|
||||
};
|
||||
// A command that differs from its queue row is refused and the head stays.
|
||||
auto tampered = commands;
|
||||
tampered.front().amount.energy.value = 2'000'000'000;
|
||||
auto wrong = admin_batch(tampered);
|
||||
auto wrong_base = evo::fixture::restore(*recovered->state);
|
||||
CHECK(wrong_base->advance_tick(wrong.ticks.front().lives));
|
||||
auto wrong_state = wrong_base->admin_candidate(tampered);
|
||||
CHECK(wrong_state);
|
||||
CHECK(!publish_cellular_batch(*runtime, **objects, *lease, head, wrong, **wrong_state,
|
||||
identity(9), build, 5s));
|
||||
runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
|
||||
CHECK(pending() == 3);
|
||||
// The exact commands publish, bind and recover.
|
||||
auto admin = admin_batch(commands);
|
||||
CHECK(recovered->state->advance_tick(admin.ticks.front().lives));
|
||||
std::vector<evo::server::CellularAdminResult> results;
|
||||
auto applied = recovered->state->admin_candidate(commands, &results);
|
||||
CHECK(applied && results.size() == 3 &&
|
||||
std::ranges::all_of(results, [](auto r) { return r.applied; }));
|
||||
const auto applied_bytes = (*applied)->snapshot();
|
||||
auto published = publish_cellular_batch(*runtime, **objects, *lease, head, admin, **applied,
|
||||
identity(10), build, 5s);
|
||||
CHECK(published);
|
||||
head = published->committed;
|
||||
CHECK(pending() == 0);
|
||||
const auto bound = owner->query(
|
||||
"SELECT count(*), min(tick), max(tick) FROM evolution.admin_command_applications "
|
||||
"WHERE command_id IN ($1, $2, $3)",
|
||||
std::array{std::to_string(pool_id), std::to_string(spawn_id), std::to_string(remove_id)},
|
||||
5s);
|
||||
CHECK(bound && (*bound)[0][0] == "3" && (*bound)[0][1] == "3" && (*bound)[0][2] == "3");
|
||||
recovered = recover_cellular_checkpoint(*runtime, **objects, key, *lease, builds, 5s);
|
||||
CHECK(recovered && recovered->state->snapshot() == applied_bytes &&
|
||||
recovered->state->lives().size() == 33);
|
||||
// The same commands cannot bind to another commit.
|
||||
auto again = admin_batch(commands);
|
||||
again.header = {key.world, key.region, 1, head.head.commit, head.head.digest, 3, 4};
|
||||
again.ticks.front().lives = checked_value(wildlife_intents(*recovered->state, 4));
|
||||
auto again_base = evo::fixture::restore(*recovered->state);
|
||||
CHECK(again_base->advance_tick(again.ticks.front().lives));
|
||||
auto again_state = again_base->admin_candidate(commands);
|
||||
CHECK(again_state);
|
||||
CHECK(!publish_cellular_batch(*runtime, **objects, *lease, head, again, **again_state,
|
||||
identity(11), build, 5s));
|
||||
runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
|
||||
CHECK(release_region_lease(*runtime, key, *lease, 5s));
|
||||
std::puts("starting wildlife publication and replacement-owner replay passed");
|
||||
}
|
||||
|
||||
@@ -874,6 +874,100 @@ void trace_replays() {
|
||||
"Emerge did not survive the trace");
|
||||
}
|
||||
|
||||
// ADR-0182: operator commands import through the boundary ledger, remove into the spent pool,
|
||||
// spawn funded wildlife, refuse what does not apply, and replay exactly from trace 5.
|
||||
void admin_commands_apply_and_replay() {
|
||||
using Kind = CellularAdminKind;
|
||||
auto live = revamp_region();
|
||||
const auto base = restore(*live);
|
||||
accounting::Inventory pool{{5'000'000'000}, {}};
|
||||
accounting::Inventory bubbles{{400'000'000}, {}};
|
||||
bubbles.matter[0].value = 4'000;
|
||||
const std::vector<CellularAdminCommand> commands{
|
||||
{1, Kind::add_pool, 0, 0, pool},
|
||||
{2, Kind::add_bubbles, 4, 0, bubbles},
|
||||
{3, Kind::grant_reserve, 0, 100, {{1'000'000}, {}}},
|
||||
{4, Kind::spawn_wildlife, 3, 900'000, {}},
|
||||
{5, Kind::remove_cell, 0, 101, {}},
|
||||
{6, Kind::release_pool, 2, 0, {{1'000'000'000}, {}}},
|
||||
{7, Kind::remove_cell, 0, 424'242, {}}, // No such life: refused, nothing changes.
|
||||
};
|
||||
for (const auto& bad : {CellularAdminCommand{8, Kind::add_pool, 0, 0, {}},
|
||||
CellularAdminCommand{8, Kind::spawn_wildlife, 65, 900'000, {}},
|
||||
CellularAdminCommand{8, Kind::add_bubbles, 0, 0, pool},
|
||||
CellularAdminCommand{0, Kind::add_pool, 0, 0, pool}})
|
||||
require(!cellular_admin_command_valid(bad), "an invalid command shape was accepted");
|
||||
require(!live->admin_candidate(std::vector{commands[1], commands[0]}),
|
||||
"commands out of order were accepted");
|
||||
|
||||
// The live run: one tick, then the commands after it.
|
||||
const auto intents = swim(*live, {});
|
||||
checked(live->advance_tick(intents), "tick before the commands");
|
||||
const auto spent_before = live->spent();
|
||||
const auto deposits_before = live->habitat().patches().size();
|
||||
const auto removed_body = life_of(*live, 101).body;
|
||||
const auto removed_reserve = life_of(*live, 101).reserve;
|
||||
std::vector<CellularAdminResult> results;
|
||||
auto after = checked(live->admin_candidate(commands, &results), "commands apply");
|
||||
require(results.size() == 7 &&
|
||||
std::ranges::all_of(results.begin(), results.begin() + 6,
|
||||
[](const auto& r) { return r.applied; }) &&
|
||||
!results.back().applied,
|
||||
"unexpected command results");
|
||||
closed(*after);
|
||||
require(after->lives().size() == live->lives().size() - 1 + 3, "wrong cell count");
|
||||
std::size_t wildlife = 0;
|
||||
for (const auto& life : after->lives())
|
||||
if (life.account == LifeAccount{} && life.identity.life >= 900'000 &&
|
||||
life.identity.life < 900'003)
|
||||
++wildlife;
|
||||
require(wildlife == 3, "spawned wildlife missing");
|
||||
require(life_of(*after, 100).reserve.energy.value ==
|
||||
life_of(*live, 100).reserve.energy.value + 1'000'000,
|
||||
"the grant did not reach the reserve");
|
||||
const auto corpse = std::ranges::find(after->corpses(), 101ULL, &CellularOwnedCorpse::life_id);
|
||||
require(corpse != after->corpses().end() &&
|
||||
corpse->cause == biology::CellularDeathCause::removed,
|
||||
"the removed cell left no removed corpse");
|
||||
auto expected_spent = spent_before;
|
||||
expected_spent.energy.value += pool.energy.value - 1'000'000'000;
|
||||
for (const auto& part : {removed_body, removed_reserve}) {
|
||||
expected_spent.energy.value += part.energy.value;
|
||||
for (std::size_t c = 0; c < 4; ++c)
|
||||
expected_spent.matter[c].value += part.matter[c].value;
|
||||
}
|
||||
require(after->spent() == expected_spent, "the spent pool is off");
|
||||
require(after->habitat().patches().size() == deposits_before + 4 + 2, "bubbles were not added");
|
||||
require(restore(*after)->snapshot() == after->snapshot(), "commands do not restore");
|
||||
auto again = checked(live->admin_candidate(commands), "commands apply again");
|
||||
require(again->snapshot() == after->snapshot(), "commands are not deterministic");
|
||||
|
||||
// The same tick and commands from trace 5 replay to the same state.
|
||||
CellularBatch batch;
|
||||
batch.format_version = cellular_batch_admin_format;
|
||||
batch.header = {base->world(), base->region(), base->frame(), {}, {}, base->tick(), 0};
|
||||
batch.header.predecessor.fill(1);
|
||||
batch.header.predecessor_digest.fill(2);
|
||||
batch.ticks.push_back({intents, {}, {}, commands});
|
||||
batch.header.end_tick = base->tick() + 1;
|
||||
const auto bytes = checked(encode_cellular_batch(batch), "trace 5 encodes");
|
||||
const auto decoded = checked(decode_cellular_batch(bytes), "trace 5 decodes");
|
||||
require(decoded == batch, "trace 5 did not round-trip");
|
||||
std::vector<CellularMutationOutcome> outcomes;
|
||||
std::vector<CellularAdminResult> replayed_results;
|
||||
const auto replayed = checked(replay_cellular_batch(*base, decoded, outcomes, replayed_results),
|
||||
"trace 5 replays");
|
||||
require(replayed->snapshot() == after->snapshot() && replayed_results == results,
|
||||
"trace 5 replay diverged");
|
||||
// Trace 4 cannot carry commands, and older owners cannot replay trace 5.
|
||||
auto old_format = batch;
|
||||
old_format.format_version = cellular_batch_inheritance_format;
|
||||
require(!encode_cellular_batch(old_format), "trace 4 carried commands");
|
||||
auto mangled = bytes;
|
||||
mangled[8] = 4; // The version byte: a trace-4 header with nonzero command counts.
|
||||
require(!decode_cellular_batch(mangled), "a trace 4 with commands decoded");
|
||||
}
|
||||
|
||||
// The safety revision preserves all five channels, follows both control choices,
|
||||
// separates eligible predator/prey siblings and replays their actual motion exactly.
|
||||
void safety_split(bool become) {
|
||||
@@ -1032,6 +1126,7 @@ void safe_bud_provision(bool become) {
|
||||
} // namespace
|
||||
|
||||
int main() try {
|
||||
admin_commands_apply_and_replay();
|
||||
safety_split(false);
|
||||
safety_split(true);
|
||||
safe_bud_provision(false);
|
||||
|
||||
@@ -550,6 +550,43 @@ void admin_api_tests(const Realm& realm) {
|
||||
CHECK(!owner->query(
|
||||
"SELECT * FROM evolution.admin_set_session_window_v1(9831, 1, 14401, 'x', '')", {}, 5s));
|
||||
|
||||
// Admin commands (schema 63): queued with the admin's identity, shape-checked, listed.
|
||||
for (const std::string_view bad :
|
||||
{"/api/regions/1/commands", "/api/regions/1/commands?kind=explode",
|
||||
"/api/regions/1/commands?kind=add_pool", "/api/regions/1/commands?kind=add_pool&energy=x",
|
||||
"/api/regions/1/commands?kind=remove_cell&target=7&energy=5",
|
||||
"/api/regions/1/commands?kind=spawn_wildlife&count=65"})
|
||||
CHECK(post(bad).status == 400);
|
||||
const auto queued =
|
||||
must(JsonValue::parse(post("/api/regions/1/commands?kind=add_pool&energy=1000&carbon=7"
|
||||
"&reason=top+up")
|
||||
.body));
|
||||
CHECK(queued.member("id") && queued.member("target")->string() == "0");
|
||||
CHECK(post("/api/regions/1/commands?kind=remove_cell&target=424242").status == 200);
|
||||
CHECK(post("/api/regions/2/commands?kind=add_pool&energy=1").status == 400);
|
||||
const auto listed_commands = must(JsonValue::parse(get("/api/regions/1/commands", admin).body));
|
||||
const auto& newest = listed_commands.member("commands")->array()->at(0);
|
||||
const auto& older = listed_commands.member("commands")->array()->at(1);
|
||||
CHECK(newest.member("kind")->string() == "remove_cell" &&
|
||||
newest.member("target")->string() == "424242" &&
|
||||
newest.member("applied_tick")->kind() == JsonValue::Kind::null &&
|
||||
older.member("kind")->string() == "add_pool" &&
|
||||
older.member("amount")->array()->at(0).string() == "1000" &&
|
||||
older.member("amount")->array()->at(1).string() == "7" &&
|
||||
older.member("reason")->string() == "top up" &&
|
||||
older.member("author")->string() == "ops@example.test (ops)");
|
||||
{
|
||||
auto reader = connect_as(env("EVO_PG_RUNTIME_USER"));
|
||||
const auto pending = reader->query(
|
||||
"SELECT count(*) FROM evolution.load_pending_admin_commands_v1(9831, 1)", {}, 5s);
|
||||
CHECK(pending && (*pending)[0][0] == "2");
|
||||
CHECK(!reader->query("SELECT * FROM evolution.admin_enqueue_command_v1(9831, 1, 4, 0, 0, "
|
||||
"1, 0, 0, 0, 0, 'x', '')",
|
||||
{}, 5s));
|
||||
reader = connect_as(env("PGUSER"));
|
||||
CHECK(!reader->query("DELETE FROM evolution.admin_commands", {}, 5s));
|
||||
}
|
||||
|
||||
// The read views are the only way in: the runtime role still cannot read the tables.
|
||||
runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
|
||||
CHECK(!runtime->query("SELECT count(*) FROM evolution.life_reservations", {}, 5s));
|
||||
|
||||
@@ -228,6 +228,7 @@ void upgrade_across_migration_and_barrier() {
|
||||
" -v migration_sha_60=$(s 0060_cellular_revamp_bundle.sql)"
|
||||
" -v migration_sha_61=$(s 0061_admin_read_views.sql)"
|
||||
" -v migration_sha_62=$(s 0062_session_windows.sql)"
|
||||
" -v migration_sha_63=$(s 0063_admin_commands.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");
|
||||
@@ -245,7 +246,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,61,62");
|
||||
"47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63");
|
||||
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,25 @@ 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.publish_cellular_mutation_checkpoint(bytea,bytea,bytea,bytea,bytea,bytea);
|
||||
ALTER FUNCTION evolution.publish_cellular_mutation_checkpoint_v62(bytea,bytea,bytea,bytea,bytea,bytea) RENAME TO publish_cellular_mutation_checkpoint;
|
||||
GRANT EXECUTE ON FUNCTION evolution.publish_cellular_mutation_checkpoint(bytea,bytea,bytea,bytea,bytea,bytea) TO :"runtime_role";
|
||||
DROP FUNCTION evolution.publish_cellular_checkpoint(bytea,bytea,bytea,bytea);
|
||||
ALTER FUNCTION evolution.publish_cellular_checkpoint_v62(bytea,bytea,bytea,bytea) RENAME TO publish_cellular_checkpoint;
|
||||
GRANT EXECUTE ON FUNCTION evolution.publish_cellular_checkpoint(bytea,bytea,bytea,bytea) TO :"runtime_role";
|
||||
DROP FUNCTION evolution.bind_cellular_admin_commands(bytea,bytea);
|
||||
DROP FUNCTION evolution.admin_commands_v1(evolution.u64,evolution.u64);
|
||||
DROP FUNCTION evolution.load_pending_admin_commands_v1(evolution.u64,evolution.u64);
|
||||
DROP FUNCTION evolution.admin_enqueue_command_v1(evolution.u64,evolution.u64,integer,integer,evolution.u64,evolution.u64,evolution.u64,evolution.u64,evolution.u64,evolution.u64,text,text);
|
||||
DROP TABLE evolution.admin_command_applications, evolution.admin_commands;
|
||||
DROP FUNCTION evolution.cellular_mutation_selections(bytea,bytea);
|
||||
ALTER FUNCTION evolution.cellular_mutation_selections_v62(bytea,bytea) RENAME TO cellular_mutation_selections;
|
||||
DROP FUNCTION evolution.cellular_births(bytea,bytea);
|
||||
ALTER FUNCTION evolution.cellular_births_v62(bytea,bytea) RENAME TO cellular_births;
|
||||
DROP FUNCTION evolution.cellular_trace_normal(bytea,bytea);
|
||||
DROP FUNCTION evolution.cellular_trace_admin(bytea,bytea);
|
||||
DROP FUNCTION evolution.cellular_trace_without_admin(bytea);
|
||||
DROP FUNCTION evolution.le_bytes(numeric,integer);
|
||||
DROP FUNCTION evolution.admin_session_windows_v1(evolution.u64,evolution.u64);
|
||||
DROP FUNCTION evolution.admin_set_session_window_v1(evolution.u64,evolution.u64,integer,text,text);
|
||||
DROP FUNCTION evolution.load_session_window_v1(evolution.u64,evolution.u64);
|
||||
|
||||
@@ -172,7 +172,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,61,62
|
||||
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,62,63
|
||||
# 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%% *}"
|
||||
@@ -193,7 +193,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")" = 62: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,62
|
||||
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) || ':' || string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 63: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,62,63
|
||||
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.
|
||||
@@ -247,7 +247,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,61,62
|
||||
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,62,63
|
||||
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
|
||||
@@ -305,9 +305,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=63 WHERE version=62'
|
||||
psql -X -v ON_ERROR_STOP=1 -c 'UPDATE evolution.schema_migrations SET version=64 WHERE version=63'
|
||||
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=62 WHERE version=63"
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET version=63 WHERE version=64"
|
||||
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"
|
||||
|
||||
@@ -140,6 +140,8 @@ digest_61="$(sha256sum "$root/migrations/0061_admin_read_views.sql")"
|
||||
digest_61="${digest_61%% *}"
|
||||
digest_62="$(sha256sum "$root/migrations/0062_session_windows.sql")"
|
||||
digest_62="${digest_62%% *}"
|
||||
digest_63="$(sha256sum "$root/migrations/0063_admin_commands.sql")"
|
||||
digest_63="${digest_63%% *}"
|
||||
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" \
|
||||
@@ -189,6 +191,6 @@ psql -X --no-password --set=ON_ERROR_STOP=1 --set="migration_sha=$digest" \
|
||||
--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_61=$digest_61" \
|
||||
--set="migration_sha_62=$digest_62" "${admin[@]}" \
|
||||
--set="migration_sha_62=$digest_62" --set="migration_sha_63=$digest_63" "${admin[@]}" \
|
||||
--set="runtime_role=$runtime_role" \
|
||||
--file="$root/migrations/apply.sql"
|
||||
|
||||
Reference in New Issue
Block a user