M12.3: publish and recover durable exact populations
Foundation / checks (ecs) (push) Successful in 2m41s
Foundation / checks (tsan) (push) Failing after 18m12s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (network) (push) Canceled after 20m41s
Foundation / checks (postgres) (push) Canceled after 20m43s
Foundation / checks (checks) (push) Canceled after 20m49s
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (client) (push) Failing after 17m4s
Foundation / postgres-tools (push) Canceled after 0s

This commit is contained in:
dingo
2026-10-17 17:10:17 -04:00
parent d5d10a0cc7
commit 627411983f
35 changed files with 2637 additions and 102 deletions
+10 -3
View File
@@ -90,7 +90,7 @@ add_library(evo_lifecycle STATIC src/server/lifecycle/primitive_lives.cpp
src/server/lifecycle/cellular_batch.cpp src/server/lifecycle/wildlife_controller.cpp
src/server/lifecycle/cellular_play_summary.cpp src/server/lifecycle/cellular_population.cpp
src/server/lifecycle/cellular_population_codec.cpp src/server/lifecycle/cellular_population_policy.cpp
src/server/lifecycle/cellular_schedule.cpp)
src/server/lifecycle/cellular_schedule.cpp src/server/lifecycle/cellular_population_batch.cpp)
add_library(evo::lifecycle ALIAS evo_lifecycle)
target_link_libraries(evo_lifecycle PUBLIC evo::biology)
evo_owned_target(evo_lifecycle)
@@ -124,7 +124,8 @@ target_include_directories(evo_ops PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
target_compile_features(evo_ops PUBLIC cxx_std_23)
evo_owned_target(evo_ops)
# Portable checkpoint manifest codec and environmental-v1 payload validation.
add_library(evo_region_checkpoint STATIC src/persistence/region_checkpoint.cpp src/persistence/region_batch.cpp)
add_library(evo_region_checkpoint STATIC src/persistence/region_checkpoint.cpp src/persistence/region_batch.cpp
src/persistence/population_checkpoint.cpp)
add_library(evo::region_checkpoint ALIAS evo_region_checkpoint)
target_link_libraries(evo_region_checkpoint PUBLIC evo::region_lease evo::processes evo::lifecycle)
evo_owned_target(evo_region_checkpoint)
@@ -250,7 +251,7 @@ if(EVO_BUILD_POSTGRES)
find_package(OpenSSL 3 REQUIRED COMPONENTS Crypto)
add_library(evo_region_store STATIC src/persistence/sha256.cpp src/persistence/object_store.cpp
src/persistence/checkpoint_store.cpp src/persistence/primitive_checkpoint_store.cpp
src/persistence/cellular_checkpoint_store.cpp
src/persistence/cellular_checkpoint_store.cpp src/persistence/population_checkpoint_store.cpp
src/persistence/region_clone.cpp)
add_library(evo::region_store ALIAS evo_region_store)
target_link_libraries(evo_region_store PUBLIC evo::postgres evo::region_checkpoint
@@ -302,6 +303,7 @@ if(EVO_BUILD_POSTGRES)
# Contention tests use one thread and one connection per contender.
add_executable(evo-postgres-tests tests/postgres_tests.cpp tests/region_lease_store_tests.cpp
tests/cellular_publication_tests.cpp
tests/population_publication_tests.cpp
tests/account_control_store_tests.cpp tests/probe_handoff_store_tests.cpp
tests/life_reservation_store_tests.cpp
tests/primitive_publication_tests.cpp
@@ -677,6 +679,11 @@ if(BUILD_TESTING)
target_link_libraries(evo-cellular-schedule-tests PRIVATE evo::lifecycle)
evo_owned_target(evo-cellular-schedule-tests)
add_test(NAME cellular-unattended-schedule COMMAND evo-cellular-schedule-tests)
add_executable(evo-population-checkpoint-tests tests/population_checkpoint_tests.cpp)
target_link_libraries(evo-population-checkpoint-tests PRIVATE evo::region_checkpoint)
evo_owned_target(evo-population-checkpoint-tests)
add_test(NAME population-checkpoint-contract COMMAND evo-population-checkpoint-tests)
set_tests_properties(population-checkpoint-contract PROPERTIES TIMEOUT 180)
endif()
add_executable(evo-chunk-layout experiments/world/chunk_layout.cpp)
+6 -4
View File
@@ -132,10 +132,12 @@ process fixtures remain separate from organism biology.
and reporting. `tests` holds contract,
fuzz and measurement programs. `src/server/lifecycle` owns funded primitive
founder creation and an in-memory cellular tick owner over the finite habitat.
The cellular owner now has durable profile-4 recovery/publication and an
adapter for reliable v7 session actions. `evo-server` still lacks the cellular
scheduler, player-life entry operation, and cellular view replication, so this
is not yet a playable client path. `evo::simulation` remains
The cellular owner has durable profile-4 recovery/publication and the cellular
worker/session path. Opt-in exact population profile 5 is described in
[M12 durable populations](docs/engineering/M12_DURABLE_POPULATIONS.md);
`--cellular-populations on|off` defaults to off. Durable interval admission,
environmental coupling and population qualification remain in progress. The
microscope client is the current M11 playtest path. `evo::simulation` remains
graphics-, network- and database-independent.
World0 is persistent state. No normal configure, build, test or CI job may create,
+44 -4
View File
@@ -113,6 +113,7 @@ struct Options {
std::uint64_t objects_reserve_mib{1024};
server_app::SessionOptions session;
server_app::M10Options m10;
bool cellular_populations{};
struct PrimitiveSessionOptions {
std::string listen, certificate, key, issuer, environment;
[[nodiscard]] bool any() const noexcept {
@@ -273,6 +274,8 @@ std::optional<Options> parse(int argc, char** argv) {
o.m10.life_routes.emplace_back(value);
else if (flag == "--m10-load-governor" && (value == "on" || value == "off"))
o.m10.load_governor = value == "on";
else if (flag == "--cellular-populations" && (value == "on" || value == "off"))
o.cellular_populations = value == "on";
else if (flag == "--primitive-listen")
o.primitive_session.listen = value;
else if (flag == "--primitive-cert")
@@ -304,6 +307,8 @@ std::optional<Options> parse(int argc, char** argv) {
o.pg.port.empty() || o.pg.database.empty() || o.pg.user.empty() || o.objects.empty() ||
o.host.build == persistence::Sha256Digest{})
return std::nullopt;
if (o.cellular_populations && o.profile != "cellular")
return std::nullopt;
// Rehearsal controls exist only for the synthetic driver (clones, drills).
if ((o.synthetic_until != 0 || o.accelerate != 1) && !o.synthetic)
return std::nullopt;
@@ -898,7 +903,7 @@ int serve_primitive(Options& o) {
#ifdef EVO_SERVER_M10
int serve_cellular(Options& o) {
auto objects = persistence::FilesystemObjectStore::open(
o.objects, o.host.key, server::max_cellular_lives_bytes, nullptr,
o.objects, o.host.key, server::max_cellular_population_bytes, nullptr,
o.objects_reserve_mib * 1024 * 1024);
if (!objects) {
std::puts("error objects");
@@ -906,7 +911,9 @@ int serve_cellular(Options& o) {
}
const auto pg = o.pg;
auto made = server::CellularRegionHost::create(
{o.host.key, o.host.frame, o.host.lease, o.host.build, o.host.retained_builds},
{o.host.key, o.host.frame, o.host.lease, o.host.build, o.host.retained_builds,
o.cellular_populations ? std::optional{server::CellularTierPolicy{true, 1200, 1800}}
: std::nullopt},
[pg] { return persistence::Postgres::connect(pg, 2s); }, std::move(*objects));
if (!made) {
std::puts("error config");
@@ -1060,6 +1067,17 @@ int serve_cellular(Options& o) {
held_births.push_back(birth);
}
const bool birth_waiting = !held_births.empty();
const bool want_population =
o.cellular_populations && state &&
state->rules_version() == server::cellular_lives_foraging_rules && !player_present &&
!birth_waiting && host.queued_mutations().empty() &&
std::ranges::any_of(state->lives(), [](const auto& life) {
return life.account == server::LifeAccount{};
});
if (status.ready && state && want_population != host.population_mode()) {
[[maybe_unused]] const auto changed = host.set_population_mode(want_population);
state = host.state();
}
const bool needed = state && (player_present || birth_waiting ||
server::cellular_unattended_tick_needed(*state));
const auto monotonic_us = [] {
@@ -1076,7 +1094,29 @@ int serve_cellular(Options& o) {
return finish(4);
}
if (status.ready && state && needed) {
if (paced->due && state->tick() != UINT64_MAX) {
if (host.population_mode()) {
// Collect one second of due time before an unattended publication.
// Overload services at most 64 fixed steps per bounded batch. Debt
// remains visible and is consumed only by a confirmed head.
if (paced->due && paced->debt >= 20) {
const auto& head = host.committed()->head;
const server::CellularBatchHeader header{
o.host.key.world,
o.host.key.region,
o.host.frame,
head.commit,
head.digest,
head.end_tick,
head.end_tick + std::min<std::uint64_t>(paced->debt, 64)};
const auto inputs = server::unattended_population_inputs(*state, header);
const auto end = header.end_tick;
if (inputs) {
[[maybe_unused]] const auto published = host.publish(*inputs);
}
if (!host.state() || host.state()->tick() < end)
schedule.defer(monotonic_us());
}
} else if (paced->due && state->tick() != UINT64_MAX) {
const auto tick = state->tick() + 1;
std::vector<server::CellularLifeIntent> baseline;
baseline.reserve(state->lives().size());
@@ -1201,7 +1241,7 @@ int main(int argc, char** argv) {
"[--m10-handoff-key F [--m10-neighbour "
"REGION=X0,Y0,X1,Y1=HOST:PORT=NAME=PUBFILE]...] "
"[--life-route REGION=HOST:PORT=TLS_NAME ...] "
"[--m10-load-governor on|off]]\\n",
"[--m10-load-governor on|off]] [--cellular-populations on|off]\\n",
stderr);
return 2;
}
+15
View File
@@ -1,5 +1,20 @@
# Project status and next steps
## M12.3b durable exact populations - 2026-10-17
ADR-0142 and schema 44 add dedicated population profile 5, trace 1, immutable
publication/transition evidence and exact source/target recovery. The owning
cellular host recovers either representation, materializes before player
operations and serializes mutation reservations against profile entry. The
optional `--cellular-populations on` path batches unattended work; entry is off
by default. No biological version, golden, deployment or live region changed.
[Scope and evidence](engineering/M12_DURABLE_POPULATIONS.md) distinguish portable
contracts, real PostgreSQL ambiguity/process-loss tests and host recreation from
remaining executable/network fault drills and target-host qualification. Durable
interval admission/backlog is the next M12.4 segment. The dependent ecological,
multi-day and returning-player gates remain open; M11.9 stays closed for now.
## M12.4a current-worker unattended scheduling - 2026-10-17
The cellular worker now keeps ticking for funded wildlife after players suspend,
@@ -0,0 +1,86 @@
# ADR-0142: Durable exact population profile and publication
## Status
Accepted for M12's opt-in engineering implementation, 2026-10-17. Extends
ADR-0139/0140 with a dedicated durable profile. Production enabling and target-host
qualification remain separate; no deployment or World0 operation is authorized.
## Context
The exact cohort envelope carries membership and policy beyond raw cellular
bytes. Reusing profile 4 would make retained manifests ambiguous. Portable
restoration alone cannot prove atomic publication, current authority or recovery
after a lost database reply.
## Decision
Checkpoint profile 5 contains population envelope 1 and nested cellular bundle 9,
with history profile 5 identifying exact retained membership. Profile 4 retains
its raw cellular bytes and meaning. No biological version or golden is replaced.
Use explicit fenced, no-tick profile transitions: rules-8 profile 4 to population
5 wraps the same biology with empty membership, sequence zero and a persisted
policy; population 5 to profile 4 materializes the retained individuals by
unwrapping the identical biology. Both require the exact current predecessor,
current region fence, retained build and immutable transition evidence. Recovery
checks the complete source/target pair, not just their aggregate inventory.
Conversion sequence starts at zero for each entry generation; the region commit
sequence remains monotonic and the transition records identify every generation.
Initially profile 5 admits unattended ecological batches only: controlled cells
receive frozen intentions; player births, mutation selections and session action
receipts remain profile-4 operations. A host must finish the reverse transition
before processing those operations. This restriction avoids bypassing their
existing account-control/reservation transactions. It does not freeze wildlife
or erase controlled/suspended stock. An explicit profile selector is opt-in.
The cellular worker accepts `--cellular-populations on|off` (default off). It may
enter only for unattended rules-8 wildlife, with no waiting player birth or
mutation. Session demand or a player operation completes the reverse transition
first. SQL serializes profile entry and mutation reservation under the same
region lease: entry refuses outstanding choices, and new choices require profile
4 in the current host. Historical reservation contracts remain unchanged outside
profile 5. An existing profile-5 head remains recoverable with entry disabled.
The worker collects at least 20 due ticks (one second) and services at most 64
per unattended publication, consuming local debt only on confirmation. This is
bounded publication batching; durable interval admission/restart backlog is the
next M12.4 segment, not supplied by a wall-clock inference on recovery.
Population batch format 1 records the unchanged canonical cellular intentions
and an exact membership/sequence boundary for each tick. Biological replay reads
the recorded intentions, never reruns the wildlife controller. It verifies each
recorded boundary against the persisted deterministic policy. Manual conversion
records operate on an entire wildlife genome group at the same biological tick.
No random materialization sample exists in this exact model. Restoration installs
the recorded checkpoint; validation cannot resample a different member set.
Store immutable payload and trace objects with SHA-256/read-back verification,
then commit the manifest and publication evidence in one database transaction
under the existing serialized lease/head guard. Unknown replies retain the exact
prepared request; read-only resolution never grants a stale writer permission to
continue. Dedicated evidence triggers prohibit generic publication bypasses.
Retain all old formats, histories and source checkpoints. Do not prune objects.
## Validation and limits
Require malformed/profile-confusion rejection, whole-state source/target equality,
conversion oscillation, trace/payload mismatch refusal, frozen controlled biology,
duplicate/conflicting retries, expired writers and missing/corrupt objects. Exercise
real PostgreSQL and process death before publication and after commit/receipt.
Portable codec success alone does not close the durable gate.
This profile supplies a place for bounded unattended intervals and later escrow;
it does not itself implement biological migration or environmental coupling.
Existing player actions, NPC heredity and fixed 50 ms biology retain their rules.
## Alternatives, costs and consequences
Relabeling the raw profile breaks retained recovery; persisting only aggregate
stock loses exact members. Reconstructing policy on restart can choose a different
representation. Keep explicit profiles and recorded boundaries instead.
This retains every member and full trace, so it adds durable bytes and replay
work and makes no compression claim. SQL parsers, grants and source/target
verification must evolve together. Target-host cost and executable/network fault
qualification remain risks before production enablement. All old objects and
histories remain retained; no garbage collection or compatibility reset follows.
+9
View File
@@ -31,6 +31,15 @@ the narrower environmental profile. M7.1 completes the audit, not those codecs.
## Identity, authority and watermarks
ADR-0142 adds opt-in exact population profile 5 (envelope 1, nested cellular
bundle 9, history profile 5). Raw cellular profile 4 is unchanged. Fenced no-tick
transitions retain complete biology and source/target digests; normal population
publication binds recorded intentions and exact membership boundaries. Generic
publishers cannot bypass dedicated immutable evidence. The host has one owning
state, materializes before player operations and never treats read-only commit
resolution as current authority. See [the contract](../../schemas/cellular-population-batch.md)
and [qualification limits](../engineering/M12_DURABLE_POPULATIONS.md).
World/region/frame are nonzero durable IDs. No ID is a Pod name. The host records
its unique holder ID and monotonically increasing nonzero lease epoch. Exhaustion
of IDs, epochs, commit sequences or ticks fails closed; never wrap/reuse them.
+1 -1
View File
@@ -10,7 +10,7 @@ Commit and push each validated scoped segment separately.
|---|---|---|
| 12.1 | Engineering evidence policy and explicit deferrals documented | ADR-0133, identity/time contract and worked histories; no new game rules or runtime versions. |
| 12.2 | Exact local model selected and paired qualification implemented (12.2d); production cost gate open | ADR-0139, exact canonical equality across 196,608 paired ticks per platform. Regional approximation disabled; no compression claim. Deployment-host capacity and fuller interaction coverage remain open. |
| 12.3 | Portable exact conversion closure, automatic policy and process recovery implemented | ADR-0140, population envelope 1. Dedicated PostgreSQL profile/trace/publication adapter and fault injection remain required before enabling the live selector. |
| 12.3 | Exact population profile/trace/store and opt-in host integration implemented (12.3b) | ADR-0142, schema 44; exact publication/recovery, mutation race guards, ambiguous replies and process kills. Executable/network population fault drills and target-host qualification remain open. |
| 12.4 | Current-worker unattended demand and confirmed-head pacing implemented (12.4a) | ADR-0141. Population durable intervals and biological migration escrow remain unimplemented. |
| 12.5 | Blocked on 12.2-12.4 | Finite M6 process fixtures do not qualify coupled persistent cellular/cohort atmosphere/water budgets. |
| 12.6 | Existing local archive retained; integrated population history open | World-level durable event/query/client path remains required. |
@@ -0,0 +1,68 @@
# M12.3b durable exact populations
ADR-0142 implements the persistence boundary identified in the remaining-gate
audit. This is an opt-in engineering path; no live region was migrated or enabled.
The optional cellular worker accepts `--cellular-populations on|off`, default off.
When unattended rules-8 wildlife is present, entry can wrap its exact biological
state as profile 5. A returning player, queued birth or mutation requires the
durable reverse transition before processing player operations.
## State and publication
There is exactly one owning biological store in the host. Profile 4 owns raw
CellularLives; profile 5 owns a CellularPopulation containing that store and its
exact membership tags. Common callers receive only a const biological view.
Entering, leaving and oscillating cannot heal, move, reproduce or fund a life.
Every profile-5 generation starts membership sequence zero, while the immutable
region publication sequence and source/target evidence preserve its identity.
Migration 44 retains all old parsers, histories and raw cellular formats. It adds
dedicated immutable population publication and profile-transition records, fenced
publish/resolve/load functions and generic-publication bypass guards. Entry and
new mutation reservations serialize on the same region lease. Entry refuses
outstanding player choices; profile 5 refuses new choices. Existing unrelated
reservation contracts retain their original behavior.
Payloads and traces are immutable content-addressed objects. The publisher checks
their SHA-256 and complete read-back before the atomic SQL head/evidence update.
Recovery verifies the exact predecessor and full source/target bytes. Biological
traces record intentions and exact membership boundaries; replay does not rerun
the wildlife controller. Unknown replies stop publication until exact-byte
resolution/retry succeeds under current authority.
## Evidence and qualification limits
The portable contract covers canonical codec/manifest/profile confusion, sampled
truncations, appended bytes, membership/sequence tampering, controlled-input
refusal, manual conversions and full biological replay equality. Native Release
tests run under NDEBUG; sanitizer and static-analysis evidence is recorded in
[VALIDATION](VALIDATION.md).
The private PostgreSQL fixture creates real reserved founders and waits for a
funded player-derived descendant. It exercises durable membership oscillation,
fresh-connection recovery, reverse materialization, generic bypass rejection,
mutation/profile race guards, duplicates/conflicts and stale authority. Missing
and corrupt payloads refuse recovery. Lease-row contention creates real adapter
timeouts: one backend commits after its client disconnects; another is terminated
before commit. Both resolve/retry the retained exact request.
SIGKILL tests use forked publisher processes at the pre-transaction boundary
(after immutable uploads), after SQL commit and after a pipe acknowledgement.
The parent restores through a new database connection and compares every retained
byte. These are real process kills, but the pipe acknowledgement is a fixture
signal, not an actual network client acknowledgement or an independently exec'd
worker restart. The actual CellularRegionHost is separately drained/recreated
and restores a profile-5 head with entry disabled, then materializes before a
returning-player operation. Previous raw worker process drills remain regression
coverage, not additional population-specific fault evidence.
The worker collects one second of due unattended time before publication and
services at most 64 fixed steps per batch. The portable input builder matches an
independent per-tick fixture. This removes per-tick SQL publication from the new
population path; it does not yet make local pacing debt a durable admission queue.
Still open: profile-5 executable/network fault drills, deployment-host tail costs,
durable ecological interval admission and biological migration escrow, jointly
owned environmental budgets, world-level history/extinction reconciliation and
actual multi-day/returning-player evidence. This work changes neither biological
versions nor goldens, and does not establish useful compression or M13 readiness.
+14 -21
View File
@@ -5,31 +5,24 @@ all of M12. M11.9 remains closed for now. M12.2 decisions are delegated and reco
in ADR-0139; no additional product approval is inferred as a coding prerequisite.
Completed scoped commits do not mean their entire roadmap gates have passed.
## Persistence boundary before expansion
## Persistence boundary resolved by 12.3b
The new exact population envelope cannot be labeled as the existing profile-4
CellularLives payload. The live publisher/recovery path, immutable manifest,
database validators and trace currently agree on that raw cellular format. A
population checkpoint containing ownership tags and policy needs a dedicated
profile and versioned transition/publication adapter. Reinterpreting profile 4
would violate REGION_DURABILITY and break retained recovery evidence.
Resolution: add an opt-in population profile and an explicit no-tick migration
from the accepted rules-8 cellular state, retaining identities, archive, funding
and balances. Publish its complete immutable payload, bound trace and permanent
events under the current region fence. Replay must retain recorded intentions
and exact membership samples, rather than rerunning a decision after an uncertain
commit. Verify lost replies and pre-upload/pre-transaction/post-commit/post-ACK
process death against a private PostgreSQL fixture. Keep production disabled until
these and target-host budgets pass. A portable codec is not a substitute for this
adapter. This is remaining M12.3 implementation, not a user-permission hold.
ADR-0142 adds dedicated profile 5, population trace 1 and schema 44; raw profile 4
retains its meaning. Explicit no-tick migrations preserve the complete biology.
The publisher, replay verifier, immutable SQL evidence, recovery and owning host
now support exact population membership with entry disabled by default. Private
PostgreSQL tests cover ambiguity, fencing, profile races and publisher process
kills. [Scope and limits](M12_DURABLE_POPULATIONS.md) distinguish those tests from
executable/network fault drills and deployment-host qualification still required.
This resolves the architectural profile conflict and permits the next durable
interval work. It does not close all of M12.3 or authorize production enablement.
## Dependent ecological integration
| Gate | Existing useful basis | Work/evidence still required |
|---|---|---|
| 12.2 | Exact cellular model and paired matrix; local samples through 256 lives | Deployment-host tail costs including publication; larger wildlife cohorts, predation/twins and contention coverage; useful compression remains unimplemented. |
| 12.3 | Complete population codec, exact conversion candidates, automatic policy and fresh-process continuation | Dedicated durable profile/trace/store/host integration and fault-injected atomic publication described above. |
| 12.3 | Dedicated population profile/trace/store/owning host; exact recovery and private PostgreSQL fault tests | Population-specific executable/network fault drills and target-host publication/capacity qualification. |
| 12.4 | Current worker advances unattended wildlife and preserves running scheduling debt | Durable ecological interval admission/backlog recovery; exact biological source/destination escrow, partition/duplicate settlement and stock-in-transit audits. |
| 12.5 | Finite cellular contact feeding/decay and separate M6 producer/consumer resource owner | One jointly owned cellular/environment budget, explicit effective depth and source entitlements, versioned water/atmosphere species mapping and producer coefficients, plus closed/open and nutrient-exhaustion comparisons. |
| 12.6 | Retained genome/organism archive with ancestry and common-ancestor queries | Append-only population census/history events in the same durable commit, bounded world history queries/indexing and client presentation; no account power or invented precise statistical ancestry. |
@@ -46,9 +39,9 @@ and photosynthesis steps B/C do not silently become accepted M12 mechanics.
The engineering constitution requires stopping expansion at this architectural
boundary and documenting the resolution. That does not prevent the independent
worker scheduling correction, which uses the existing raw cellular publication
path. The outstanding population integration is the next substantive coding
segment; none of the rows above is closed by adding a placeholder service.
worker scheduling correction or the dedicated exact population adapter above.
Durable ecological intervals are the next substantive coding segment; none of
the rows above is closed by adding a placeholder service.
Current expansion readiness: **no-go for M13 integration or World0 promotion**
while these M12 integration/evidence gates remain open. This records the present
+46
View File
@@ -1,5 +1,51 @@
# Validation report
## 2026-10-17 - M12.3b durable exact population publication
ADR-0142 affects portable lifecycle batches/checkpoint manifests, optional
PostgreSQL adapters/schema 44, the owning cellular host and opt-in worker batching.
No biological version or golden changes; no deployment or World0 operation.
Executed:
- MSVC 19.44 Release configure/build and **76/76 CTests** (final run 9.53 s).
- GCC 14.2 actual QUIC/PostgreSQL worker and integration-test build. Final private
`postgres-check.sh --population-only` **passed, exit 0, 5 s** after checked-access
refinements. Real reserved founders fund the wildlife fixture; tests exercise
exact membership oscillation, duplicate/conflicting requests, mutation/profile
race guards, missing/corrupt payloads, stale authority, host recreation and
materialization before player operations.
- Real PostgreSQL lease-row contention makes the adapter time out. One queued
request later commits and another backend is terminated before commit; both
resolve/retry the retained bytes. Forked publisher SIGKILLs occur before the
transaction, after commit and after a pipe ACK, with fresh-connection recovery.
This does not claim a population-specific network ACK or exec'd worker kill.
- Clang 19 actual server build; explicit clang-tidy 19 on changed optional store,
SQL adapter, cellular recovery, host, population integration tests and worker.
Final refinements use separately checked stable optional values; those follow-up
tidy runs pass. Analysis-preset portable checks and repository format check pass.
- Portable analysis CTests pass **7/7** (29.70 s); final batch-builder/checkpoint
checks pass **2/2** (3.73 s). ASan/UBSan population checkpoint/replay checks pass
(final 12.50 s), with no reports. Tests use explicit checks under NDEBUG.
The broad regression first exposed an over-broad mutation guard and the schema-44
upgrade expectation; both were corrected. The historical failed-migration drill
now supplies all required checksums, so it reaches its intended bad-v8-checksum
failure rather than an unrelated missing psql variable. The C++ suite, backup and
DR passed in the next run, but a concurrent local relink interrupted the upgrade
drill with `Text file busy`; this is not counted as a passing full run. Final
qualification uses a frozen copy of the executables to avoid that interference.
Final frozen-binary `postgres-check.sh --full` **passed, exit 0, 496 s**: complete
C++ suite (421 s), independent reservation connections, backup/restore, host-loss
DR, upgrade, migration history, permissions and checksum drift. The final optional
checked-access refinements additionally passed the targeted private population
suite above; all populations remain opt-in and no live region was changed.
Remaining scope: [M12_DURABLE_POPULATIONS](M12_DURABLE_POPULATIONS.md) and
[M12_REMAINING_GATES](M12_REMAINING_GATES.md). No compression, deployment-host
capacity, durable interval admission or multi-day ecological acceptance is inferred.
## 2026-10-17 - M12.4a unattended demand and confirmed-head pacing
ADR-0141 changes the existing cellular worker's demand/pacing and metrics, with
@@ -0,0 +1,54 @@
#pragma once
#include "evo/persistence/checkpoint_store.hpp"
namespace evo::persistence {
struct PopulationPreparedCommit {
RegionKey key{};
Uuid commit{};
std::vector<std::uint8_t> manifest, trace; // Empty trace means a profile transition.
};
struct PopulationPublicationFailure {
PublicationError kind{};
LeaseStoreFailure store{};
ObjectError object{};
PopulationPreparedCommit prepared;
};
struct RecoveredPopulationCheckpoint {
CommittedCheckpoint committed;
CheckpointManifest manifest;
std::unique_ptr<server::CellularPopulation> state;
};
// Explicit no-tick transitions, under the same lease/head fence as publication.
[[nodiscard]] std::expected<CommittedCheckpoint, PopulationPublicationFailure>
migrate_cellular_to_population(Postgres&, const FilesystemObjectStore&, const LeaseGrant&,
const CommittedCheckpoint&, Uuid commit, const Sha256Digest& build,
server::CellularTierPolicy, std::chrono::milliseconds timeout,
const PublishHooks& hooks = {});
[[nodiscard]] std::expected<CommittedCheckpoint, PopulationPublicationFailure>
materialize_population_profile(Postgres&, const FilesystemObjectStore&, const LeaseGrant&,
const CommittedCheckpoint&, Uuid commit, const Sha256Digest& build,
std::chrono::milliseconds timeout, const PublishHooks& hooks = {});
[[nodiscard]] std::expected<CommittedCheckpoint, PopulationPublicationFailure>
publish_population_batch(Postgres&, const FilesystemObjectStore&, const LeaseGrant&,
const CommittedCheckpoint&, const server::CellularPopulationBatch&,
const server::CellularPopulation& candidate, Uuid commit,
const Sha256Digest& build, std::chrono::milliseconds timeout,
const PublishHooks& hooks = {});
[[nodiscard]] std::expected<CommittedCheckpoint, PopulationPublicationFailure>
retry_population_prepared(Postgres&, const PopulationPreparedCommit&,
std::chrono::milliseconds timeout);
[[nodiscard]] std::expected<ResolvedCommit, LeaseStoreFailure>
resolve_population_prepared(Postgres&, const PopulationPreparedCommit&,
std::chrono::milliseconds timeout);
[[nodiscard]] std::expected<RecoveredPopulationCheckpoint, RecoveryFailure>
recover_population_checkpoint(Postgres&, const FilesystemObjectStore&, RegionKey, const LeaseGrant&,
std::span<const Sha256Digest> retained_builds,
std::chrono::milliseconds timeout);
// Used by raw cellular recovery after a population -> individual profile transition.
[[nodiscard]] std::expected<void, RecoveryFailure>
verify_population_profile_transition(Postgres&, const FilesystemObjectStore&, const LeaseGrant&,
const CommittedCheckpoint&, const CheckpointManifest&,
std::span<const std::uint8_t> payload,
std::chrono::milliseconds timeout);
} // namespace evo::persistence
+21 -1
View File
@@ -5,6 +5,7 @@
#include "evo/processes/lineage_region.hpp"
#include "evo/server/lifecycle/cellular_batch.hpp"
#include "evo/server/lifecycle/cellular_lives.hpp"
#include "evo/server/lifecycle/cellular_population_batch.hpp"
#include "evo/server/lifecycle/primitive_batch.hpp"
#include <cstddef>
#include <cstdint>
@@ -25,12 +26,14 @@ enum class CheckpointProfile : std::uint8_t {
environmental_lineage_v1 = 2, // LineageRegion container; history_profile 1.
primitive_lives_v1 = 3, // Funded creation state; history_profile 2.
cellular_lives_v1 = 4, // Complete cellular state; history_profile 3.
cellular_population_v1 = 5, // Population envelope 1; nested cellular bundle 9.
};
// history_profile 1: lineage archive format 1 with genome schema 1.
inline constexpr std::uint32_t lineage_history_profile = 1;
// Archive format 1, genome schema 2, development 2, founder-life rules 1.
inline constexpr std::uint32_t primitive_history_profile = 2;
inline constexpr std::uint32_t cellular_history_profile = 3;
inline constexpr std::uint32_t population_history_profile = 5;
inline constexpr std::uint32_t cellular_revision_history_profile = 4;
// Declared durability, verified at deployment. Development: one volume, no host-loss claim.
enum class DurabilityPolicy : std::uint8_t { unknown = 0, single_volume_development = 1 };
@@ -119,7 +122,9 @@ inline constexpr std::size_t max_lineage_payload_bytes = processes::max_lineage_
: profile == CheckpointProfile::environmental_lineage_v1 ? max_lineage_payload_bytes
: profile == CheckpointProfile::primitive_lives_v1 ? server::max_primitive_lives_bytes
: profile == CheckpointProfile::cellular_lives_v1 ? server::max_cellular_lives_bytes
: 0;
: profile == CheckpointProfile::cellular_population_v1
? server::max_cellular_population_bytes
: 0;
}
inline constexpr std::uint64_t max_checkpoint_ticks = 64;
@@ -189,4 +194,19 @@ restore_primitive_payload(std::span<const std::uint8_t> payload,
const CheckpointManifest& manifest);
[[nodiscard]] std::expected<std::unique_ptr<server::CellularLives>, CheckpointError>
restore_cellular_payload(std::span<const std::uint8_t> payload, const CheckpointManifest& manifest);
[[nodiscard]] std::expected<std::unique_ptr<server::CellularPopulation>, CheckpointError>
restore_population_payload(std::span<const std::uint8_t> payload,
const CheckpointManifest& manifest);
// Dedicated profile 4/bundle 9 <-> profile 5 transition, no biological tick.
[[nodiscard]] std::expected<CheckpointManifest, CheckpointError>
population_profile_transition_manifest(const CheckpointManifest& predecessor,
const Sha256Digest& predecessor_digest, Uuid commit,
const LeaseGrant& lease, const Sha256Digest& build,
std::uint64_t payload_bytes,
const Sha256Digest& payload_sha256);
// Population manual conversion may publish at the same tick with a nonempty trace.
[[nodiscard]] std::expected<CheckpointManifest, CheckpointError> population_successor_manifest(
const CheckpointManifest& predecessor, const Sha256Digest& predecessor_digest, Uuid commit,
const LeaseGrant& lease, std::uint64_t end_tick, const Sha256Digest& build,
std::uint64_t payload_bytes, const Sha256Digest& payload_sha256, const BatchDigests& batch);
} // namespace evo::persistence
@@ -217,4 +217,23 @@ pending_region_outbox(Postgres& db, RegionKey key, std::uint32_t limit,
[[nodiscard]] std::expected<bool, LeaseStoreFailure>
acknowledge_region_outbox(Postgres& db, RegionKey key, const BatchDecision& decision,
std::chrono::milliseconds timeout);
struct PopulationEvidence {
std::vector<std::uint8_t> trace;
std::optional<Uuid> source_commit;
Sha256Digest source_manifest_sha256{}, source_payload_sha256{};
};
[[nodiscard]] std::expected<RegionHead, LeaseStoreFailure>
publish_population_checkpoint(Postgres&, std::span<const std::uint8_t> manifest,
std::span<const std::uint8_t> trace,
std::chrono::milliseconds timeout);
[[nodiscard]] std::expected<RegionHead, LeaseStoreFailure>
publish_population_profile_transition(Postgres&, std::span<const std::uint8_t> manifest,
std::chrono::milliseconds timeout);
[[nodiscard]] std::expected<ResolvedCommit, LeaseStoreFailure>
resolve_population_commit(Postgres&, RegionKey, const Uuid& commit,
std::span<const std::uint8_t> manifest,
std::span<const std::uint8_t> trace, std::chrono::milliseconds timeout);
[[nodiscard]] std::expected<std::optional<PopulationEvidence>, LeaseStoreFailure>
load_population_evidence(Postgres&, RegionKey, const LeaseGrant&, const Uuid& commit,
std::chrono::milliseconds timeout);
} // namespace evo::persistence
+50 -2
View File
@@ -3,6 +3,7 @@
#include "evo/network/session_protocol.hpp"
#include "evo/persistence/checkpoint_store.hpp"
#include "evo/persistence/life_reservation_store.hpp"
#include "evo/persistence/population_checkpoint_store.hpp"
#include "evo/server/lifecycle/cellular_batch.hpp"
#include "evo/server/ops.hpp"
@@ -13,6 +14,7 @@
#include <memory>
#include <optional>
#include <span>
#include <utility>
#include <vector>
namespace evo::server {
@@ -24,6 +26,7 @@ struct CellularHostConfig {
persistence::LeasePolicy lease{};
persistence::Sha256Digest build{};
std::vector<persistence::Sha256Digest> retained_builds;
std::optional<CellularTierPolicy> population_policy{}; // Opt-in profile-5 entry.
};
enum class CellularHostError : std::uint8_t {
configuration,
@@ -74,7 +77,7 @@ struct CellularMutationReply {
[[nodiscard]] network::CellularMutationOffer
offer_view(const CellularLives& state, const CellularOwnedLife& life, std::uint64_t tick);
// Single-writer profile-4 authority. The caller supplies a complete bounded trace;
// Single-writer profile-4/5 authority. The caller supplies a complete bounded trace;
// the host replays it from its recovered state and advances only on a confirmed head.
class CellularRegionHost {
public:
@@ -87,6 +90,9 @@ class CellularRegionHost {
// Acquires/renews authority, recovers fully, or resolves the exact pending commit.
const HostStatus& step();
// Explicit no-tick fenced transition. Uncertain publication pauses the host.
[[nodiscard]] std::expected<void, CellularPublishFailure> set_population_mode(bool enabled);
[[nodiscard]] bool population_mode() const noexcept;
[[nodiscard]] std::expected<persistence::PublishedCellularBatch, CellularPublishFailure>
publish(const CellularBatch& batch, std::span<const CellularActionRecord> actions = {},
std::span<const CellularMutationActionRecord> mutation_actions = {});
@@ -140,6 +146,9 @@ class CellularRegionHost {
void upkeep();
void resolve();
void refresh();
bool recover_state(const persistence::LeaseGrant&);
[[nodiscard]] std::expected<persistence::PublishedCellularBatch, CellularPublishFailure>
publish_population(const CellularBatch&);
void finalize_births(std::span<const CellularTickIntents::Birth> births);
void queue_birth(const CellularTickIntents::Birth& birth);
void reload_mutations();
@@ -158,7 +167,46 @@ class CellularRegionHost {
std::unique_ptr<persistence::FilesystemObjectStore> objects_;
std::unique_ptr<persistence::Postgres> db_;
persistence::LeaseAuthority authority_;
std::unique_ptr<CellularLives> state_;
// Exactly one owner. The common interface is a const biological view, never
// a second independently spendable cellular copy alongside a population.
struct OwnedState {
std::unique_ptr<CellularLives> individual;
std::unique_ptr<CellularPopulation> population;
OwnedState() = default;
OwnedState(std::unique_ptr<CellularLives> state) : individual(std::move(state)) {}
OwnedState(std::unique_ptr<CellularPopulation> state) : population(std::move(state)) {}
OwnedState& operator=(std::unique_ptr<CellularLives> state) {
population.reset();
individual = std::move(state);
return *this;
}
OwnedState& operator=(std::unique_ptr<CellularPopulation> state) {
individual.reset();
population = std::move(state);
return *this;
}
void reset() {
individual.reset();
population.reset();
}
const CellularLives* get() const {
return population ? &population->state() : individual.get();
}
const CellularLives* operator->() const {
return get();
}
const CellularLives& operator*() const {
return *get();
}
explicit operator bool() const {
return get() != nullptr;
}
};
[[nodiscard]] std::expected<persistence::CommittedCheckpoint, CellularPublishFailure>
accept_population_publication(
std::expected<persistence::CommittedCheckpoint, persistence::PopulationPublicationFailure>,
OwnedState candidate);
OwnedState state_;
std::optional<persistence::CommittedCheckpoint> committed_;
std::unique_ptr<Pending> pending_;
std::vector<FinalCellularAction> finalized_actions_;
@@ -10,6 +10,7 @@
#include <vector>
namespace evo::server {
struct CellularPopulationBatch;
// ADR-0139: exact local cohorts retain individuals, never mean reserves or samples.
// The single owned CellularLives store backs BOTH representations, exactly once.
struct CellularCohortMember {
@@ -72,6 +73,8 @@ class CellularPopulation {
std::span<const CellularMutationSelection> selections = {});
private:
friend std::expected<std::unique_ptr<CellularPopulation>, CellularPopulationError>
execute_population_batch(const CellularPopulation&, CellularPopulationBatch&, bool);
explicit CellularPopulation(std::unique_ptr<CellularLives> state, CellularTierPolicy policy);
void apply_policy();
std::unique_ptr<CellularLives> state_;
@@ -0,0 +1,49 @@
#pragma once
#include "evo/server/lifecycle/cellular_batch.hpp"
#include "evo/server/lifecycle/cellular_population.hpp"
namespace evo::server {
struct CellularPopulationBoundary {
std::uint64_t sequence{};
std::vector<CellularCohortMember> members;
bool operator==(const CellularPopulationBoundary&) const = default;
};
struct CellularPopulationConversion {
std::uint64_t genome{};
bool to_cohort{};
bool operator==(const CellularPopulationConversion&) const = default;
};
struct CellularPopulationBatch {
CellularBatchHeader header;
// Exactly one: 1..64 unattended biological ticks, or a no-tick whole-group conversion.
CellularBatch biology;
std::optional<CellularPopulationConversion> conversion;
std::vector<CellularPopulationBoundary> boundaries;
bool operator==(const CellularPopulationBatch&) const = default;
};
inline constexpr std::size_t population_batch_header_bytes = 136;
inline constexpr std::size_t max_population_batch_bytes =
population_batch_header_bytes + max_cellular_batch_bytes +
max_cellular_batch_ticks * (16 + 16 * biology::max_cellular_tick_lives);
struct CellularPopulationExecution {
CellularPopulationBatch batch;
std::unique_ptr<CellularPopulation> state;
};
// Build an unattended interval from a detached biological copy. Controlled cells
// receive frozen-only intentions; the unchanged wildlife controller supplies the
// rest. The returned recorded intentions replay without rerunning that controller.
[[nodiscard]] std::expected<CellularBatch, CellularPopulationError>
unattended_population_inputs(const CellularLives&, const CellularBatchHeader&);
[[nodiscard]] std::expected<CellularPopulationExecution, CellularPopulationError>
prepare_population_batch(const CellularPopulation& base, CellularBatch biology);
[[nodiscard]] std::expected<CellularPopulationExecution, CellularPopulationError>
prepare_population_conversion(const CellularPopulation& base, CellularBatchHeader header,
CellularPopulationConversion conversion);
[[nodiscard]] std::expected<std::unique_ptr<CellularPopulation>, CellularPopulationError>
replay_population_batch(const CellularPopulation& base, const CellularPopulationBatch& batch);
[[nodiscard]] std::expected<std::vector<std::uint8_t>, CellularPopulationError>
encode_population_batch(const CellularPopulationBatch& batch);
[[nodiscard]] std::expected<CellularPopulationBatch, CellularPopulationError>
decode_population_batch(std::span<const std::uint8_t> bytes);
} // namespace evo::server
@@ -0,0 +1,338 @@
-- ADR-0142: exact population profile 5, immutable evidence and fenced publishers.
-- All historical profile-4 bytes and parsers retain their original meanings.
ALTER FUNCTION evolution.parse_checkpoint_manifest(bytea) RENAME TO parse_checkpoint_manifest_v43;
CREATE FUNCTION evolution.parse_checkpoint_manifest(m bytea)
RETURNS evolution.checkpoint_manifest LANGUAGE plpgsql IMMUTABLE
SET search_path = pg_catalog, pg_temp AS $$
DECLARE
r evolution.checkpoint_manifest;
n bytea;
tick_begin numeric;
tick_end numeric;
payload_size numeric;
trace_size numeric;
trace_digest bytea;
zero32 constant bytea := decode(repeat('00',32),'hex');
bundle9 constant bytea := '\x080000000600000002000000010000000100000004000000030000000200000001000000';
BEGIN
IF m IS NULL OR octet_length(m) <> 360 OR evolution.manifest_uint(m,12,4) <> 5 THEN
RETURN evolution.parse_checkpoint_manifest_v43(m);
END IF;
tick_begin := evolution.manifest_uint(m,112,8);
tick_end := evolution.manifest_uint(m,120,8);
payload_size := evolution.manifest_uint(m,240,8);
trace_size := evolution.manifest_uint(m,280,8);
trace_digest := substring(m FROM 289 FOR 32);
IF substring(m FROM 161 FOR 36) <> bundle9 OR evolution.manifest_uint(m,232,4) <> 5
OR evolution.manifest_uint(m,228,4) <> 0 OR evolution.manifest_uint(m,236,4) <> 1
OR evolution.manifest_uint(m,56,8) = 0 OR tick_end < tick_begin OR tick_end - tick_begin > 64
OR payload_size = 0 OR payload_size > 16781400 OR evolution.manifest_uint(m,320,4) <> 0
OR substring(m FROM 329 FOR 32) <> zero32
OR (trace_size = 0 AND (trace_digest <> zero32 OR tick_begin <> tick_end OR tick_end = 0))
OR (trace_size > 0 AND (trace_size < 152 OR trace_size > 1968376 OR trace_size % 8 <> 0
OR trace_digest = zero32)) THEN
RAISE EXCEPTION 'unsupported or malformed population manifest' USING ERRCODE = '22023';
END IF;
-- Reuse historical common-field validation, with only parser-local normalized
-- profile/history/size/trace declarations. Stored and returned bytes stay profile 5.
n := overlay(m PLACING '\x04000000'::bytea FROM 13 FOR 4);
n := overlay(n PLACING '\x04000000'::bytea FROM 233 FOR 4);
n := overlay(n PLACING evolution.manifest_u64le(least(payload_size,16777216)) FROM 241 FOR 8);
n := overlay(n PLACING evolution.manifest_u64le(CASE WHEN tick_end = tick_begin THEN 0
ELSE 112 + 16 * (tick_end - tick_begin) END) FROM 281 FOR 8);
IF tick_end = tick_begin THEN
n := overlay(n PLACING zero32 FROM 289 FOR 32);
END IF;
r := evolution.parse_checkpoint_manifest_v43(n);
r.profile := 5;
r.payload_bytes := payload_size;
r.trace_bytes := trace_size;
r.trace_sha256 := trace_digest;
RETURN r;
END $$;
REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest(bytea) FROM PUBLIC;
CREATE TABLE evolution.population_publications (
commit_id uuid PRIMARY KEY REFERENCES evolution.region_commits(commit_id) DEFERRABLE INITIALLY DEFERRED,
trace bytea NOT NULL CHECK (octet_length(trace) BETWEEN 152 AND 1968376)
);
CREATE TABLE evolution.population_profile_transitions (
target_commit uuid PRIMARY KEY REFERENCES evolution.region_commits(commit_id) DEFERRABLE INITIALLY DEFERRED,
source_commit uuid NOT NULL REFERENCES evolution.region_commits(commit_id),
source_manifest_sha256 bytea NOT NULL CHECK (octet_length(source_manifest_sha256) = 32),
source_payload_sha256 bytea NOT NULL CHECK (octet_length(source_payload_sha256) = 32),
source_profile integer NOT NULL CHECK (source_profile IN (4,5)),
target_profile integer NOT NULL CHECK (target_profile IN (4,5)),
CHECK (source_profile <> target_profile AND source_commit <> target_commit)
);
REVOKE ALL ON evolution.population_publications, evolution.population_profile_transitions FROM PUBLIC;
CREATE TRIGGER population_publications_immutable BEFORE UPDATE OR DELETE ON evolution.population_publications
FOR EACH ROW EXECUTE FUNCTION evolution.refuse_history_rewrite();
CREATE TRIGGER population_publications_no_truncate BEFORE TRUNCATE ON evolution.population_publications
FOR EACH STATEMENT EXECUTE FUNCTION evolution.refuse_history_rewrite();
CREATE TRIGGER population_transitions_immutable BEFORE UPDATE OR DELETE ON evolution.population_profile_transitions
FOR EACH ROW EXECUTE FUNCTION evolution.refuse_history_rewrite();
CREATE TRIGGER population_transitions_no_truncate BEFORE TRUNCATE ON evolution.population_profile_transitions
FOR EACH STATEMENT EXECUTE FUNCTION evolution.refuse_history_rewrite();
CREATE OR REPLACE FUNCTION evolution.refuse_unpublished_cellular() RETURNS trigger
LANGUAGE plpgsql SECURITY INVOKER SET search_path = pg_catalog, pg_temp AS $$
BEGIN
IF evolution.manifest_uint(NEW.manifest,12,4) = 4 AND NEW.commit_sequence > 0
AND NOT EXISTS (SELECT 1 FROM evolution.cellular_publications p WHERE p.commit_id = NEW.commit_id)
AND NOT EXISTS (SELECT 1 FROM evolution.cellular_profile_migrations p WHERE p.target_commit = NEW.commit_id)
AND NOT EXISTS (SELECT 1 FROM evolution.population_profile_transitions p
WHERE p.target_commit = NEW.commit_id AND p.target_profile = 4) THEN
RAISE EXCEPTION 'cellular commit requires fenced publisher' USING ERRCODE = 'EVL06';
END IF;
RETURN NEW;
END $$;
CREATE FUNCTION evolution.refuse_unpublished_population() RETURNS trigger
LANGUAGE plpgsql SECURITY INVOKER SET search_path = pg_catalog, pg_temp AS $$
BEGIN
IF evolution.manifest_uint(NEW.manifest,12,4) = 5 AND
(NEW.commit_sequence = 0 OR
(NOT EXISTS (SELECT 1 FROM evolution.population_publications p WHERE p.commit_id = NEW.commit_id)
AND NOT EXISTS (SELECT 1 FROM evolution.population_profile_transitions p
WHERE p.target_commit = NEW.commit_id AND p.target_profile = 5))) THEN
RAISE EXCEPTION 'population commit requires fenced publisher' USING ERRCODE = 'EVL06';
END IF;
RETURN NEW;
END $$;
REVOKE ALL ON FUNCTION evolution.refuse_unpublished_population() FROM PUBLIC;
CREATE TRIGGER region_population_evidence BEFORE INSERT ON evolution.region_commits
FOR EACH ROW EXECUTE FUNCTION evolution.refuse_unpublished_population();
CREATE OR REPLACE FUNCTION evolution.publish_region_checkpoint(p_manifest bytea,p_decisions 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 c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(p_manifest);
BEGIN
IF c.profile IN (4,5) THEN
RAISE EXCEPTION 'cellular/population requires dedicated publisher' USING ERRCODE = 'EVL06';
END IF;
RETURN QUERY SELECT * FROM evolution.publish_region_checkpoint_core(p_manifest,p_decisions);
END $$;
-- Structural validation only. C++ additionally replays all biology and verifies
-- the exact policy/sample, including controlled presence and source state closure.
CREATE FUNCTION evolution.check_population_trace(m bytea,t bytea) RETURNS void
LANGUAGE plpgsql IMMUTABLE SET search_path = pg_catalog, pg_temp AS $$
DECLARE
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
kind numeric; n numeric; biological numeric; genome numeric; to_cohort numeric;
off integer; bio_end integer; intents numeric; members numeric; previous numeric;
sequence numeric; last_sequence numeric := -1; life numeric;
BEGIN
IF c.profile <> 5 OR t IS NULL OR octet_length(t) <> c.trace_bytes OR sha256(t) <> c.trace_sha256
OR octet_length(t) < 152 OR substring(t FROM 1 FOR 8) <> '\x4145564f50425431'
OR evolution.manifest_uint(t,8,4) <> 1 OR evolution.manifest_uint(t,12,4) > 1
OR substring(t FROM 17 FOR 88) <> (substring(m FROM 17 FOR 24) ||
substring(m FROM 65 FOR 48) || substring(m FROM 113 FOR 16))
OR evolution.manifest_uint(t,108,4) <> 0 THEN
RAISE EXCEPTION 'invalid population trace binding' USING ERRCODE = '22023';
END IF;
kind := evolution.manifest_uint(t,12,4); n := evolution.manifest_uint(t,104,4);
biological := evolution.manifest_uint(t,112,8); genome := evolution.manifest_uint(t,120,8);
to_cohort := evolution.manifest_uint(t,128,8);
IF n < 1 OR n > 64 OR biological > 1705072 OR biological > octet_length(t) - 136
OR to_cohort > 1 OR (kind = 1 AND (biological <> 0 OR genome = 0 OR n <> 1
OR c.begin_tick <> c.end_tick OR c.end_tick = 0))
OR (kind = 0 AND (genome <> 0 OR to_cohort <> 0 OR biological < 112
OR c.end_tick - c.begin_tick <> n)) THEN
RAISE EXCEPTION 'invalid population trace shape' USING ERRCODE = '22023';
END IF;
off := 136;
IF kind = 0 THEN
IF substring(t FROM 137 FOR 8) <> '\x45564c4342543031'
OR evolution.manifest_uint(t,144,4) <> 3 OR evolution.manifest_uint(t,148,4) <> 4
OR substring(t FROM 153 FOR 88) <> substring(t FROM 17 FOR 88)
OR evolution.manifest_uint(t,240,4) <> n OR evolution.manifest_uint(t,244,4) <> 0 THEN
RAISE EXCEPTION 'invalid population biological binding' USING ERRCODE = '22023';
END IF;
off := 248; bio_end := (136 + biological)::integer;
FOR i IN 1..n::integer LOOP
IF off + 16 > bio_end THEN RAISE EXCEPTION 'truncated population tick' USING ERRCODE = '22023'; END IF;
intents := evolution.manifest_uint(t,off,4);
IF intents > 256 OR evolution.manifest_uint(t,off+4,4) <> 0
OR evolution.manifest_uint(t,off+8,4) <> 0 OR evolution.manifest_uint(t,off+12,4) <> 0
OR off + 16 + intents * 24 > bio_end THEN
RAISE EXCEPTION 'unsupported population player operation' USING ERRCODE = '22023';
END IF;
off := off + 16; previous := 0;
FOR j IN 1..intents::integer LOOP
life := evolution.manifest_uint(t,off,8);
IF life <= previous THEN RAISE EXCEPTION 'unordered population inputs' USING ERRCODE = '22023'; END IF;
previous := life; off := off + 24;
END LOOP;
END LOOP;
IF off <> bio_end THEN RAISE EXCEPTION 'population biological length differs' USING ERRCODE = '22023'; END IF;
END IF;
FOR i IN 1..n::integer LOOP
IF off + 16 > octet_length(t) THEN RAISE EXCEPTION 'truncated population sample' USING ERRCODE = '22023'; END IF;
sequence := evolution.manifest_uint(t,off,8); members := evolution.manifest_uint(t,off+8,8);
IF members > 256 OR off + 16 + members * 16 > octet_length(t)
OR (last_sequence >= 0 AND (sequence < last_sequence OR sequence > last_sequence + 1)) THEN
RAISE EXCEPTION 'invalid population sample' USING ERRCODE = '22023';
END IF;
last_sequence := sequence; off := off + 16; previous := 0;
FOR j IN 1..members::integer LOOP
life := evolution.manifest_uint(t,off,8);
IF life <= previous OR evolution.manifest_uint(t,off+8,8) = 0 THEN
RAISE EXCEPTION 'invalid population member' USING ERRCODE = '22023';
END IF;
previous := life; off := off + 16;
END LOOP;
END LOOP;
IF off <> octet_length(t) THEN RAISE EXCEPTION 'trailing population bytes' USING ERRCODE = '22023'; END IF;
END $$;
REVOKE ALL ON FUNCTION evolution.check_population_trace(bytea,bytea) FROM PUBLIC;
CREATE FUNCTION evolution.publish_population_checkpoint(m bytea,t 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 c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m); existing bytea;
BEGIN
PERFORM evolution.check_population_trace(m,t);
-- Lease then head lock follows the common writer's order. Trace evidence is in
-- this same transaction; any core rejection rolls the insertion back.
PERFORM evolution.check_region_lease(c.world_id,c.region_id,c.holder,c.epoch);
SELECT p.trace INTO existing FROM evolution.population_publications p WHERE p.commit_id = c.commit_id;
IF FOUND THEN
IF existing <> t THEN RAISE EXCEPTION 'population identity reused' USING ERRCODE = 'EVL07'; END IF;
ELSE
INSERT INTO evolution.population_publications VALUES(c.commit_id,t);
END IF;
RETURN QUERY SELECT * FROM evolution.publish_region_checkpoint_core(m,''::bytea);
END $$;
REVOKE ALL ON FUNCTION evolution.publish_population_checkpoint(bytea,bytea) FROM PUBLIC;
GRANT EXECUTE ON FUNCTION evolution.publish_population_checkpoint(bytea,bytea) TO :"runtime_role";
CREATE FUNCTION evolution.publish_population_profile_transition(m 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
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
s evolution.checkpoint_manifest; p evolution.region_commits%ROWTYPE;
h evolution.region_heads%ROWTYPE; old evolution.region_commits%ROWTYPE;
d bytea := sha256(m); frame evolution.u64;
bundle9 constant bytea := '\x080000000600000002000000010000000100000004000000030000000200000001000000';
BEGIN
IF c.profile NOT IN (4,5) OR c.versions <> bundle9 OR c.commit_sequence = 0
OR c.begin_tick <> c.end_tick OR c.end_tick = 0 OR c.trace_bytes <> 0 THEN
RAISE EXCEPTION 'invalid population profile transition' USING ERRCODE = '22023';
END IF;
PERFORM evolution.check_region_lease(c.world_id,c.region_id,c.holder,c.epoch);
SELECT * INTO old FROM evolution.region_commits r WHERE r.commit_id = c.commit_id;
IF FOUND THEN
IF old.manifest <> m OR NOT EXISTS (SELECT 1 FROM evolution.population_profile_transitions x
WHERE x.target_commit = c.commit_id AND x.source_commit = c.predecessor_commit
AND x.source_manifest_sha256 = c.predecessor_digest AND x.target_profile = c.profile) THEN
RAISE EXCEPTION 'population transition identity reused' USING ERRCODE = 'EVL07';
END IF;
SELECT l.frame_id INTO frame FROM evolution.region_leases l WHERE l.world_id = c.world_id AND l.region_id = c.region_id;
RETURN QUERY SELECT frame,old.commit_sequence,old.commit_id,encode(old.commit_digest,'hex'),old.end_tick;
RETURN;
END IF;
SELECT * INTO h FROM evolution.region_heads r WHERE r.world_id = c.world_id AND r.region_id = c.region_id FOR UPDATE;
IF NOT FOUND OR h.commit_sequence = 18446744073709551615 OR c.commit_sequence <> h.commit_sequence + 1
OR c.predecessor_commit <> h.commit_id OR c.predecessor_digest <> h.digest OR c.begin_tick <> h.end_tick THEN
RAISE EXCEPTION 'population transition head moved' USING ERRCODE = 'EVL03';
END IF;
SELECT * INTO p FROM evolution.region_commits r WHERE r.commit_id = h.commit_id;
IF NOT FOUND THEN RAISE EXCEPTION 'missing population source' USING ERRCODE = 'XX000'; END IF;
s := evolution.parse_checkpoint_manifest(p.manifest);
IF c.profile = 5 AND EXISTS (SELECT 1 FROM evolution.cellular_mutation_reservations x
WHERE x.world_id = c.world_id AND x.region_id = c.region_id AND NOT EXISTS
(SELECT 1 FROM evolution.cellular_mutation_action_publications a
WHERE a.world_id = x.world_id AND a.account_id = x.account_id AND a.action_id = x.action_id)) THEN
RAISE EXCEPTION 'pending player mutation blocks population transition' USING ERRCODE = 'EVL18';
END IF;
IF s.profile NOT IN (4,5) OR s.profile = c.profile OR s.versions <> bundle9
OR s.frame_id <> c.frame_id OR s.tick_microseconds <> c.tick_microseconds
OR s.end_tick <> c.end_tick OR NOT EXISTS (SELECT 1 FROM evolution.retained_builds b WHERE b.build_identity = c.build_identity) THEN
RAISE EXCEPTION 'unsupported population source' USING ERRCODE = 'EVL06';
END IF;
INSERT INTO evolution.population_profile_transitions VALUES(c.commit_id,p.commit_id,p.commit_digest,p.payload_sha256,s.profile,c.profile);
INSERT INTO evolution.region_commits(world_id,region_id,commit_sequence,commit_id,commit_digest,manifest,
begin_tick,end_tick,published_epoch,tick_microseconds,versions,build_identity,payload_bytes,payload_sha256)
VALUES(c.world_id,c.region_id,c.commit_sequence,c.commit_id,d,m,c.begin_tick,c.end_tick,c.epoch,
c.tick_microseconds,c.versions,c.build_identity,c.payload_bytes,c.payload_sha256);
UPDATE evolution.region_heads r SET commit_sequence = c.commit_sequence,commit_id = c.commit_id,
digest = d,end_tick = c.end_tick,published_epoch = c.epoch WHERE r.world_id = c.world_id AND r.region_id = c.region_id;
RETURN QUERY SELECT c.frame_id,c.commit_sequence,c.commit_id,encode(d,'hex'),c.end_tick;
END $$;
REVOKE ALL ON FUNCTION evolution.publish_population_profile_transition(bytea) FROM PUBLIC;
GRANT EXECUTE ON FUNCTION evolution.publish_population_profile_transition(bytea) TO :"runtime_role";
CREATE FUNCTION evolution.resolve_population_commit(w evolution.u64,r evolution.u64,id uuid,m bytea,t bytea)
RETURNS TABLE(status text,region_frame evolution.u64,head_sequence evolution.u64,head_commit uuid,
head_digest text,head_tick evolution.u64)
LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
DECLARE c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m); result record;
BEGIN
IF c.world_id <> w OR c.region_id <> r OR c.commit_id <> id OR t IS NULL
OR c.profile NOT IN (4,5) THEN RAISE EXCEPTION 'invalid population resolution' USING ERRCODE = '22023'; END IF;
IF octet_length(t) > 0 THEN PERFORM evolution.check_population_trace(m,t);
ELSIF c.trace_bytes <> 0 OR c.begin_tick <> c.end_tick THEN
RAISE EXCEPTION 'invalid transition resolution' USING ERRCODE = '22023';
END IF;
SELECT * INTO result FROM evolution.resolve_region_commit(w,r,id,m,''::bytea);
IF result.status = 'committed' AND
((octet_length(t) = 0 AND NOT EXISTS (SELECT 1 FROM evolution.population_profile_transitions x WHERE x.target_commit = id))
OR (octet_length(t) > 0 AND NOT EXISTS (SELECT 1 FROM evolution.population_publications x WHERE x.commit_id = id AND x.trace = t))) THEN
RETURN QUERY SELECT 'conflict'::text,NULL::evolution.u64,NULL::evolution.u64,NULL::uuid,NULL::text,NULL::evolution.u64;
ELSE
RETURN QUERY SELECT result.status,result.region_frame,result.head_sequence,result.head_commit,result.head_digest,result.head_tick;
END IF;
END $$;
REVOKE ALL ON FUNCTION evolution.resolve_population_commit(evolution.u64,evolution.u64,uuid,bytea,bytea) FROM PUBLIC;
GRANT EXECUTE ON FUNCTION evolution.resolve_population_commit(evolution.u64,evolution.u64,uuid,bytea,bytea) TO :"runtime_role";
CREATE FUNCTION evolution.load_population_evidence(w evolution.u64,r evolution.u64,holder uuid,epoch evolution.u64,id uuid)
RETURNS TABLE(trace bytea,source_commit uuid,source_manifest_sha256 bytea,source_payload_sha256 bytea)
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
BEGIN
PERFORM evolution.check_region_lease(w,r,holder,epoch);
RETURN QUERY SELECT p.trace,NULL::uuid,NULL::bytea,NULL::bytea FROM evolution.population_publications p
JOIN evolution.region_commits c ON c.commit_id = p.commit_id WHERE c.world_id = w AND c.region_id = r AND c.commit_id = id
UNION ALL SELECT ''::bytea,p.source_commit,p.source_manifest_sha256,p.source_payload_sha256 FROM evolution.population_profile_transitions p
JOIN evolution.region_commits c ON c.commit_id = p.target_commit WHERE c.world_id = w AND c.region_id = r AND c.commit_id = id;
END $$;
REVOKE ALL ON FUNCTION evolution.load_population_evidence(evolution.u64,evolution.u64,uuid,evolution.u64,uuid) FROM PUBLIC;
GRANT EXECUTE ON FUNCTION evolution.load_population_evidence(evolution.u64,evolution.u64,uuid,evolution.u64,uuid) TO :"runtime_role";
-- Region lease serialization prevents a new player choice from racing entry into
-- the unattended profile. Exact old action retries retain their original result.
ALTER FUNCTION evolution.reserve_cellular_mutation(evolution.u64,evolution.u64,uuid,evolution.u64,
uuid,evolution.u64,evolution.u64,evolution.u64,bytea) RENAME TO reserve_cellular_mutation_v43;
REVOKE ALL ON FUNCTION evolution.reserve_cellular_mutation_v43(evolution.u64,evolution.u64,uuid,evolution.u64,
uuid,evolution.u64,evolution.u64,evolution.u64,bytea) FROM PUBLIC, :"runtime_role";
CREATE FUNCTION evolution.reserve_cellular_mutation(p_world evolution.u64,p_region evolution.u64,
p_holder uuid,p_epoch evolution.u64,p_account uuid,p_generation evolution.u64,p_action evolution.u64,
p_target_tick evolution.u64,p_input bytea)
RETURNS TABLE(successor_identity evolution.u64,action_region evolution.u64)
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
DECLARE m bytea;
BEGIN
PERFORM evolution.check_region_lease(p_world,p_region,p_holder,p_epoch);
IF NOT EXISTS (SELECT 1 FROM evolution.cellular_mutation_reservations x
WHERE x.world_id = p_world AND x.account_id = p_account AND x.action_id = p_action) THEN
SELECT c.manifest INTO m FROM evolution.region_heads h JOIN evolution.region_commits c
ON c.commit_id = h.commit_id WHERE h.world_id = p_world AND h.region_id = p_region;
IF m IS NOT NULL AND (evolution.parse_checkpoint_manifest(m)).profile = 5 THEN
RAISE EXCEPTION 'population profile refuses player mutation' USING ERRCODE = 'EVL06';
END IF;
END IF;
RETURN QUERY SELECT * FROM evolution.reserve_cellular_mutation_v43(p_world,p_region,p_holder,p_epoch,
p_account,p_generation,p_action,p_target_tick,p_input);
END $$;
REVOKE ALL ON FUNCTION evolution.reserve_cellular_mutation(evolution.u64,evolution.u64,uuid,evolution.u64,
uuid,evolution.u64,evolution.u64,evolution.u64,bytea) FROM PUBLIC;
GRANT EXECUTE ON FUNCTION evolution.reserve_cellular_mutation(evolution.u64,evolution.u64,uuid,evolution.u64,
uuid,evolution.u64,evolution.u64,evolution.u64,bytea) TO :"runtime_role";
INSERT INTO evolution.schema_migrations(version,sha256) VALUES(44,:'migration_sha_44');
+16 -3
View File
@@ -119,6 +119,7 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
SELECT :'history_v40' || ',41:' || :'migration_sha_41' AS history_v41 \gset
SELECT :'history_v41' || ',42:' || :'migration_sha_42' AS history_v42 \gset
SELECT :'history_v42' || ',43:' || :'migration_sha_43' AS history_v43 \gset
SELECT :'history_v43' || ',44:' || :'migration_sha_44' AS history_v44 \gset
SELECT :'history' = :'history_v22' AS at_v22,
:'history' = :'history_v23' AS at_v23,
:'history' = :'history_v24' AS at_v24,
@@ -140,8 +141,10 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
:'history' = :'history_v40' AS at_v40,
:'history' = :'history_v41' AS at_v41,
:'history' = :'history_v42' AS at_v42,
:'history' = :'history_v43' AS at_v43 \gset
\if :at_v43
:'history' = :'history_v43' AS at_v43,
:'history' = :'history_v44' AS at_v44 \gset
\if :at_v44
\elif :at_v43
\elif :at_v42
\elif :at_v41
\elif :at_v40
@@ -521,7 +524,8 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
coalesce(max(version), 0) = 40 AS at_v40,
coalesce(max(version), 0) = 41 AS at_v41,
coalesce(max(version), 0) = 42 AS at_v42,
coalesce(max(version), 0) = 43 AS at_v43
coalesce(max(version), 0) = 43 AS at_v43,
coalesce(max(version), 0) = 44 AS at_v44
FROM evolution.schema_migrations \gset
\if :at_v24
\ir 0025_cellular_v2_bundle.sql
@@ -733,10 +737,15 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
\elif :at_v42
\ir 0043_cellular_v9_foraging_bundle.sql
\elif :at_v43
\elif :at_v44
\else
\echo 'Unknown or changed migration history after v43'
DO $$ BEGIN RAISE EXCEPTION 'unknown or changed migration history'; END $$;
\endif
SELECT coalesce(max(version), 0) = 43 AS needs_v44 FROM evolution.schema_migrations \gset
\if :needs_v44
\ir 0044_exact_population_publication.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
@@ -756,6 +765,10 @@ BEGIN
UNION
SELECT m.member FROM pg_catalog.pg_auth_members m JOIN closure c ON m.roleid = c.oid
), fenced(oid) AS (VALUES
('evolution.publish_population_checkpoint(bytea,bytea)'::regprocedure::oid),
('evolution.publish_population_profile_transition(bytea)'::regprocedure::oid),
('evolution.resolve_population_commit(evolution.u64,evolution.u64,uuid,bytea,bytea)'::regprocedure::oid),
('evolution.load_population_evidence(evolution.u64,evolution.u64,uuid,evolution.u64,uuid)'::regprocedure::oid),
('evolution.publish_primitive_checkpoint(bytea,bytea)'::regprocedure::oid),
('evolution.load_primitive_lives(evolution.u64,evolution.u64)'::regprocedure::oid),
('evolution.query_primitive_life(evolution.u64,evolution.u64,uuid,evolution.u64,uuid,evolution.u64,evolution.u64)'::regprocedure::oid),
+40
View File
@@ -0,0 +1,40 @@
# Exact population batch 1
Authority: ADR-0142. All integers little-endian; no padding. Maximum 1,968,376
bytes. This trace belongs only to checkpoint profile 5, nested cellular bundle 9
and history profile 5. SHA-256 binds the complete immutable trace to its manifest.
| Offset | Bytes | Field |
|---:|---:|---|
| 0 | 8 | Magic `AEVOPBT1` |
| 8 | 4 | Format 1 |
| 12 | 4 | Kind: 0 biological interval, 1 manual conversion |
| 16 | 24 | World, region, frame as u64 |
| 40 | 16 | Predecessor commit UUID |
| 56 | 32 | Predecessor manifest SHA-256 |
| 88 | 16 | Begin and end tick as u64 |
| 104 | 4 | Boundary count, 1..64 |
| 108 | 4 | Reserved, zero |
| 112 | 8 | Nested biological trace length |
| 120 | 8 | Manual conversion genome, zero for kind 0 |
| 128 | 8 | Manual destination: 0 individual, 1 cohort; zero for kind 0 |
| 136 | declared length | Unchanged cellular batch format 3 (kind 0 only) |
| after biology | variable | Ordered boundaries |
Each boundary is conversion sequence u64, member count u64 (0..256), then sorted
unique `(life u64, genome u64)` pairs. Exact end of input and canonical re-encoding
are required. Kind 0 has one boundary per tick and advances 1..64 fixed 50 ms
ticks. Both headers must agree exactly. Birth and mutation arrays are empty;
every controlled cell has exactly its frozen-only intent. Recorded wildlife
intentions replay through the same biological kernel. The persisted policy must
reproduce the exact boundary, including sequence and every member.
Kind 1 contains no biological trace, one boundary and a nonzero genome; begin and
end tick are equal and nonzero. Conversion moves the whole eligible wildlife
genome group. It cannot change biological bytes or select a random sample.
Profile transitions 4 to 5 and 5 to 4 are separate no-tick commits with no trace.
Their immutable SQL evidence binds both source digests and profiles; recovery
loads and verifies both payloads. A biological interval or manual conversion
instead requires full recorded trace evidence, replay and exact payload equality.
Runtime cannot publish either case through the generic region publisher.
+8 -3
View File
@@ -1,6 +1,6 @@
# Exact cellular population envelope 1
Authority: ADR-0139/0140. Little-endian integers, no padding. Size is bounded by
Authority: ADR-0139/0140/0142. Little-endian integers, no padding. Size is bounded by
`max_cellular_population_bytes`. No changes to existing cellular owner envelopes.
| Offset | Bytes | Field |
@@ -30,5 +30,10 @@ conversion. No random seed or residual is missing: the representation is exact.
The checksum detects corruption, not malicious alteration. Production object
publication must also bind SHA-256, predecessor, current fence and immutable
manifest. This format is not yet an accepted PostgreSQL checkpoint profile; it
must never be labeled as the existing cellular profile-4 payload.
manifest. Migration 44 admits this envelope as checkpoint profile 5, nested
cellular bundle 9 and history profile 5. It must never be labeled as the existing
raw cellular profile-4 payload. Entry wraps identical rules-8 biology with empty
membership and sequence zero; reverse entry unwraps the identical biology.
Conversion sequence is local to each profile-5 generation. The immutable region
commit sequence and transition evidence distinguish generations and never reset.
See [population batch format 1](cellular-population-batch.md).
+10 -1
View File
@@ -1,4 +1,5 @@
#include "evo/persistence/checkpoint_store.hpp"
#include "evo/persistence/population_checkpoint_store.hpp"
#include "evo/persistence/sha256.hpp"
#include <algorithm>
@@ -537,7 +538,15 @@ recover_cellular_checkpoint(Postgres& db, const FilesystemObjectStore& objects,
std::vector<server::CellularActionRecord> actions;
std::vector<server::CellularMutationActionRecord> mutation_actions_recovered;
std::vector<server::CellularMutationResult> mutation_results_recovered;
if (manifest->sequence != 0 && manifest->begin_tick == manifest->end_tick) {
if (manifest->sequence != 0 && manifest->begin_tick == manifest->end_tick &&
manifest->cellular_versions == cellular_v9_versions) {
auto verified = verify_population_profile_transition(db, objects, lease, *committed,
*manifest, *payload, timeout);
if (!verified)
return std::unexpected(verified.error());
return RecoveredCellularCheckpoint{
std::move(*committed), *manifest, std::move(*state), {}, {}, {}};
} else if (manifest->sequence != 0 && manifest->begin_tick == manifest->end_tick) {
auto migration = load_cellular_profile_migration(db, key, lease, manifest->commit, timeout);
if (!migration)
return std::unexpected{RecoveryFailure{RecoveryError::store, migration.error()}};
+78
View File
@@ -0,0 +1,78 @@
#include "evo/persistence/region_checkpoint.hpp"
namespace evo::persistence {
namespace {
std::expected<CheckpointManifest, CheckpointError>
next_population(const CheckpointManifest& previous, const Sha256Digest& previous_digest,
Uuid commit, const LeaseGrant& lease, std::uint64_t end_tick,
const Sha256Digest& build, std::uint64_t bytes, const Sha256Digest& digest,
BatchDigests batch, bool transition) {
if (!supported(previous) || !encode_manifest(previous) || previous.sequence == 0 ||
previous.sequence == ~std::uint64_t{0} || previous.end_tick == 0 ||
previous.cellular_versions != cellular_v9_versions || previous_digest == Sha256Digest{} ||
lease.frame != previous.frame || lease.epoch == 0 || lease.holder == Uuid{} ||
commit == Uuid{} || commit == previous.commit || end_tick < previous.end_tick ||
end_tick - previous.end_tick > max_checkpoint_ticks ||
(previous.profile != CheckpointProfile::cellular_lives_v1 &&
previous.profile != CheckpointProfile::cellular_population_v1) ||
(!transition && previous.profile != CheckpointProfile::cellular_population_v1))
return std::unexpected(CheckpointError::chain);
auto next = previous;
if (transition) {
next.profile = previous.profile == CheckpointProfile::cellular_lives_v1
? CheckpointProfile::cellular_population_v1
: CheckpointProfile::cellular_lives_v1;
next.history_profile = next.profile == CheckpointProfile::cellular_population_v1
? population_history_profile
: cellular_revision_history_profile;
}
next.commit = commit;
++next.sequence;
next.predecessor_commit = previous.commit;
next.predecessor_digest = previous_digest;
next.begin_tick = previous.end_tick;
next.end_tick = end_tick;
next.holder = lease.holder;
next.epoch = lease.epoch;
next.build = build;
next.payload_bytes = bytes;
next.payload_sha256 = digest;
next.batch = batch;
if (!encode_manifest(next))
return std::unexpected(CheckpointError::format);
return next;
}
} // namespace
std::expected<CheckpointManifest, CheckpointError>
population_profile_transition_manifest(const CheckpointManifest& previous,
const Sha256Digest& previous_digest, Uuid commit,
const LeaseGrant& lease, const Sha256Digest& build,
std::uint64_t bytes, const Sha256Digest& digest) {
return next_population(previous, previous_digest, commit, lease, previous.end_tick, build,
bytes, digest, {}, true);
}
std::expected<CheckpointManifest, CheckpointError> population_successor_manifest(
const CheckpointManifest& previous, const Sha256Digest& previous_digest, Uuid commit,
const LeaseGrant& lease, std::uint64_t end_tick, const Sha256Digest& build, std::uint64_t bytes,
const Sha256Digest& digest, const BatchDigests& batch) {
if (batch.trace_bytes == 0)
return std::unexpected(CheckpointError::chain);
return next_population(previous, previous_digest, commit, lease, end_tick, build, bytes, digest,
batch, false);
}
std::expected<std::unique_ptr<server::CellularPopulation>, CheckpointError>
restore_population_payload(std::span<const std::uint8_t> payload, const CheckpointManifest& m) {
if (!supported(m) || m.profile != CheckpointProfile::cellular_population_v1)
return std::unexpected(CheckpointError::unsupported);
if (!encode_manifest(m) || payload.size() != m.payload_bytes)
return std::unexpected(CheckpointError::format);
auto state = server::CellularPopulation::restore(payload, m.key.world, m.key.region, m.frame,
m.end_tick);
if (!state)
return std::unexpected(state.error() == server::CellularPopulationError::unsupported
? CheckpointError::unsupported
: CheckpointError::payload);
return std::move(*state);
}
} // namespace evo::persistence
@@ -0,0 +1,315 @@
#include "evo/persistence/population_checkpoint_store.hpp"
#include "evo/persistence/sha256.hpp"
#include <algorithm>
#include <utility>
namespace evo::persistence {
namespace {
using std::chrono::milliseconds;
PopulationPublicationFailure failure(PublicationError kind, ObjectError object = {},
LeaseStoreFailure store = {},
PopulationPreparedCommit prepared = {}) {
return {kind, store, object, std::move(prepared)};
}
bool bound(const CommittedCheckpoint& checkpoint, const CheckpointManifest& m) {
const auto digest = sha256(checkpoint.manifest);
return digest && *digest == checkpoint.head.digest && m.commit == checkpoint.head.commit &&
m.sequence == checkpoint.head.sequence && m.end_tick == checkpoint.head.end_tick &&
m.frame == checkpoint.head.frame;
}
bool canonical(const PopulationPreparedCommit& prepared, const CheckpointManifest& m) {
if (!supported(m) || m.key != prepared.key || m.commit != prepared.commit || m.sequence == 0 ||
m.cellular_versions != cellular_v9_versions || !encode_manifest(m))
return false;
if (prepared.trace.empty())
return (m.profile == CheckpointProfile::cellular_lives_v1 ||
m.profile == CheckpointProfile::cellular_population_v1) &&
m.begin_tick == m.end_tick && m.batch == BatchDigests{};
const auto trace = server::decode_population_batch(prepared.trace);
const auto digest = sha256(prepared.trace);
if (!trace || !digest || m.profile != CheckpointProfile::cellular_population_v1 ||
m.batch != BatchDigests{prepared.trace.size(), *digest, 0, {}})
return false;
const auto& h = trace->header;
return h.world == m.key.world && h.region == m.key.region && h.frame == m.frame &&
h.predecessor == m.predecessor_commit && h.predecessor_digest == m.predecessor_digest &&
h.begin_tick == m.begin_tick && h.end_tick == m.end_tick;
}
std::expected<void, PopulationPublicationFailure> put(const FilesystemObjectStore& objects,
std::span<const std::uint8_t> bytes) {
const auto digest = sha256(bytes);
if (!digest)
return std::unexpected(failure(PublicationError::digest));
auto object = objects.put(bytes);
if (!object)
return std::unexpected(failure(PublicationError::upload, object.error()));
auto readback = objects.get(*object);
if (!readback || object->bytes != bytes.size() || object->sha256 != *digest ||
!std::ranges::equal(*readback, bytes))
return std::unexpected(
failure(PublicationError::verify, readback ? ObjectError::corrupt : readback.error()));
return {};
}
std::expected<CommittedCheckpoint, PopulationPublicationFailure>
transition(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease,
const CommittedCheckpoint& predecessor, Uuid commit, const Sha256Digest& build,
server::CellularTierPolicy policy, bool to_population, milliseconds timeout,
const PublishHooks& hooks) {
auto previous = decode_manifest(predecessor.manifest);
const auto previous_digest = sha256(predecessor.manifest);
if (!previous || !previous_digest || !bound(predecessor, *previous) ||
previous->profile != (to_population ? CheckpointProfile::cellular_lives_v1
: CheckpointProfile::cellular_population_v1) ||
previous->cellular_versions != cellular_v9_versions)
return std::unexpected(failure(PublicationError::predecessor));
auto source = objects.get({previous->payload_sha256, previous->payload_bytes});
if (!source)
return std::unexpected(failure(PublicationError::predecessor, source.error()));
std::vector<std::uint8_t> payload;
if (to_population) {
auto state = restore_cellular_payload(*source, *previous);
if (!state)
return std::unexpected(failure(PublicationError::predecessor));
auto population = server::CellularPopulation::create(std::move(*state), policy);
if (!population || (*population)->state().snapshot() != *source)
return std::unexpected(failure(PublicationError::candidate));
payload = (*population)->snapshot();
} else {
auto state = restore_population_payload(*source, *previous);
if (!state)
return std::unexpected(failure(PublicationError::predecessor));
payload = (*state)->state().snapshot();
}
const auto digest = sha256(payload);
if (!digest)
return std::unexpected(failure(PublicationError::digest));
auto manifest = population_profile_transition_manifest(*previous, *previous_digest, commit,
lease, build, payload.size(), *digest);
if (!manifest)
return std::unexpected(failure(PublicationError::candidate));
auto encoded = encode_manifest(*manifest);
if (!encoded)
return std::unexpected(failure(PublicationError::candidate));
if (auto uploaded = put(objects, payload); !uploaded)
return std::unexpected(uploaded.error());
if (hooks.before_transaction)
hooks.before_transaction();
return retry_population_prepared(db, {previous->key, commit, std::move(*encoded), {}}, timeout);
}
} // namespace
std::expected<CommittedCheckpoint, PopulationPublicationFailure> migrate_cellular_to_population(
Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease,
const CommittedCheckpoint& predecessor, Uuid commit, const Sha256Digest& build,
server::CellularTierPolicy policy, milliseconds timeout, const PublishHooks& hooks) {
return transition(db, objects, lease, predecessor, commit, build, policy, true, timeout, hooks);
}
std::expected<CommittedCheckpoint, PopulationPublicationFailure>
materialize_population_profile(Postgres& db, const FilesystemObjectStore& objects,
const LeaseGrant& lease, const CommittedCheckpoint& predecessor,
Uuid commit, const Sha256Digest& build, milliseconds timeout,
const PublishHooks& hooks) {
return transition(db, objects, lease, predecessor, commit, build, {}, false, timeout, hooks);
}
std::expected<CommittedCheckpoint, PopulationPublicationFailure>
retry_population_prepared(Postgres& db, const PopulationPreparedCommit& prepared,
milliseconds timeout) {
const auto m = decode_manifest(prepared.manifest);
if (!m || !canonical(prepared, *m))
return std::unexpected(failure(PublicationError::candidate));
auto result =
prepared.trace.empty()
? publish_population_profile_transition(db, prepared.manifest, timeout)
: publish_population_checkpoint(db, prepared.manifest, prepared.trace, timeout);
if (!result)
return std::unexpected(failure(result.error().kind == LeaseStoreError::unknown
? PublicationError::unknown
: PublicationError::rejected,
{}, result.error(), prepared));
const auto digest = sha256(prepared.manifest);
if (!digest || result->digest != *digest || result->commit != m->commit ||
result->sequence != m->sequence || result->end_tick != m->end_tick ||
result->frame != m->frame)
return std::unexpected(failure(PublicationError::receipt));
return CommittedCheckpoint{*result, prepared.manifest};
}
std::expected<ResolvedCommit, LeaseStoreFailure>
resolve_population_prepared(Postgres& db, const PopulationPreparedCommit& prepared,
milliseconds timeout) {
const auto manifest = decode_manifest(prepared.manifest);
if (!manifest || !canonical(prepared, *manifest))
return std::unexpected(LeaseStoreFailure{LeaseStoreError::invalid, {}});
return resolve_population_commit(db, prepared.key, prepared.commit, prepared.manifest,
prepared.trace, timeout);
}
std::expected<CommittedCheckpoint, PopulationPublicationFailure> publish_population_batch(
Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease,
const CommittedCheckpoint& predecessor, const server::CellularPopulationBatch& batch,
const server::CellularPopulation& candidate, Uuid commit, const Sha256Digest& build,
milliseconds timeout, const PublishHooks& hooks) {
const auto previous = decode_manifest(predecessor.manifest);
const auto previous_digest = sha256(predecessor.manifest);
const auto trace = server::encode_population_batch(batch);
if (!previous || !previous_digest || !trace || !bound(predecessor, *previous) ||
previous->profile != CheckpointProfile::cellular_population_v1)
return std::unexpected(failure(PublicationError::predecessor));
auto source = objects.get({previous->payload_sha256, previous->payload_bytes});
if (!source)
return std::unexpected(failure(PublicationError::predecessor, source.error()));
auto base = restore_population_payload(*source, *previous);
if (!base)
return std::unexpected(failure(PublicationError::predecessor));
auto replay = server::replay_population_batch(**base, batch);
const auto payload = candidate.snapshot();
if (!replay || (*replay)->snapshot() != payload)
return std::unexpected(failure(PublicationError::candidate));
const auto payload_digest = sha256(payload), trace_digest = sha256(*trace);
if (!payload_digest || !trace_digest)
return std::unexpected(failure(PublicationError::digest));
auto m = population_successor_manifest(*previous, *previous_digest, commit, lease,
batch.header.end_tick, build, payload.size(),
*payload_digest, {trace->size(), *trace_digest, 0, {}});
if (!m)
return std::unexpected(failure(PublicationError::candidate));
auto encoded = encode_manifest(*m);
if (!encoded)
return std::unexpected(failure(PublicationError::candidate));
PopulationPreparedCommit prepared{previous->key, commit, std::move(*encoded), *trace};
if (!canonical(prepared, *m))
return std::unexpected(failure(PublicationError::candidate));
if (auto uploaded = put(objects, payload); !uploaded)
return std::unexpected(uploaded.error());
if (auto uploaded = put(objects, *trace); !uploaded)
return std::unexpected(uploaded.error());
if (hooks.before_transaction)
hooks.before_transaction();
return retry_population_prepared(db, prepared, timeout);
}
std::expected<void, RecoveryFailure>
verify_population_profile_transition(Postgres& db, const FilesystemObjectStore& objects,
const LeaseGrant& lease, const CommittedCheckpoint& committed,
const CheckpointManifest& m,
std::span<const std::uint8_t> payload, milliseconds timeout) {
const auto fail = [](RecoveryError kind) { return std::unexpected(RecoveryFailure{kind, {}}); };
if (!bound(committed, m) || m.sequence == 0 || m.begin_tick != m.end_tick ||
m.batch != BatchDigests{})
return fail(RecoveryError::manifest);
auto evidence = load_population_evidence(db, m.key, lease, m.commit, timeout);
if (!evidence)
return std::unexpected(RecoveryFailure{RecoveryError::store, evidence.error()});
const auto record_optional = std::move(*evidence);
if (!record_optional.has_value())
return fail(RecoveryError::history);
const auto& record = *record_optional;
if (!record.trace.empty() || !record.source_commit.has_value())
return fail(RecoveryError::history);
auto predecessor = load_region_commit(db, m.key, m.sequence - 1, timeout);
if (!predecessor)
return std::unexpected(RecoveryFailure{RecoveryError::tail, predecessor.error()});
auto source = decode_manifest(predecessor->manifest);
if (!source || !bound(*predecessor, *source) || !supported(*source) ||
source->commit != m.predecessor_commit ||
predecessor->head.digest != m.predecessor_digest || source->key != m.key ||
source->frame != m.frame || source->end_tick != m.end_tick ||
source->cellular_versions != cellular_v9_versions ||
m.cellular_versions != cellular_v9_versions || record.source_commit != source->commit ||
record.source_manifest_sha256 != predecessor->head.digest ||
record.source_payload_sha256 != source->payload_sha256)
return fail(RecoveryError::tail);
auto bytes = objects.get({source->payload_sha256, source->payload_bytes});
if (!bytes)
return fail(RecoveryError::tail);
if (m.profile == CheckpointProfile::cellular_population_v1 &&
source->profile == CheckpointProfile::cellular_lives_v1) {
auto raw = restore_cellular_payload(*bytes, *source);
auto population = restore_population_payload(payload, m);
if (!raw || !population)
return fail(RecoveryError::payload);
auto expected =
server::CellularPopulation::create(std::move(*raw), (*population)->policy());
if (!expected || !std::ranges::equal((*expected)->snapshot(), payload))
return fail(RecoveryError::history);
} else if (m.profile == CheckpointProfile::cellular_lives_v1 &&
source->profile == CheckpointProfile::cellular_population_v1) {
auto population = restore_population_payload(*bytes, *source);
if (!population || !restore_cellular_payload(payload, m) ||
!std::ranges::equal((*population)->state().snapshot(), payload))
return fail(RecoveryError::history);
} else
return fail(RecoveryError::unsupported);
return {};
}
std::expected<RecoveredPopulationCheckpoint, RecoveryFailure>
recover_population_checkpoint(Postgres& db, const FilesystemObjectStore& objects, RegionKey key,
const LeaseGrant& lease,
std::span<const Sha256Digest> retained_builds, milliseconds timeout) {
const auto fail = [](RecoveryError kind) { return std::unexpected(RecoveryFailure{kind, {}}); };
auto committed = load_region_checkpoint(db, key, timeout);
if (!committed)
return std::unexpected(
RecoveryFailure{committed.error().kind == LeaseStoreError::not_provisioned
? RecoveryError::not_provisioned
: RecoveryError::store,
committed.error()});
auto m = decode_manifest(committed->manifest);
if (!m || !bound(*committed, *m) || m->key != key)
return fail(RecoveryError::manifest);
if (!supported(*m) || m->profile != CheckpointProfile::cellular_population_v1 ||
lease.frame != m->frame ||
std::ranges::find(retained_builds, m->build) == retained_builds.end())
return fail(RecoveryError::unsupported);
auto bytes = objects.get({m->payload_sha256, m->payload_bytes});
if (!bytes)
return fail(bytes.error() == ObjectError::io ? RecoveryError::store
: bytes.error() == ObjectError::missing ? RecoveryError::missing_payload
: RecoveryError::corrupt_payload);
auto population = restore_population_payload(*bytes, *m);
if (!population)
return fail(RecoveryError::payload);
if (m->batch == BatchDigests{}) {
if (auto verified = verify_population_profile_transition(db, objects, lease, *committed, *m,
*bytes, timeout);
!verified)
return std::unexpected(verified.error());
} else {
auto evidence = load_population_evidence(db, key, lease, m->commit, timeout);
if (!evidence)
return std::unexpected(RecoveryFailure{RecoveryError::store, evidence.error()});
const auto record_optional = std::move(*evidence);
if (!record_optional.has_value())
return fail(RecoveryError::history);
const auto& record = *record_optional;
if (record.source_commit.has_value())
return fail(RecoveryError::history);
auto trace_bytes = objects.get({m->batch.trace_sha256, m->batch.trace_bytes});
if (!trace_bytes || *trace_bytes != record.trace)
return fail(RecoveryError::tail);
PopulationPreparedCommit prepared{key, m->commit, committed->manifest, *trace_bytes};
if (!canonical(prepared, *m))
return fail(RecoveryError::tail);
auto predecessor = load_region_commit(db, key, m->sequence - 1, timeout);
if (!predecessor)
return std::unexpected(RecoveryFailure{RecoveryError::tail, predecessor.error()});
auto previous = decode_manifest(predecessor->manifest);
if (!previous || !bound(*predecessor, *previous) ||
previous->commit != m->predecessor_commit ||
predecessor->head.digest != m->predecessor_digest || previous->key != key ||
previous->frame != m->frame || previous->sequence + 1 != m->sequence ||
previous->end_tick != m->begin_tick)
return fail(RecoveryError::tail);
auto source_bytes = objects.get({previous->payload_sha256, previous->payload_bytes});
if (!source_bytes)
return fail(RecoveryError::tail);
auto base = restore_population_payload(*source_bytes, *previous);
auto trace = server::decode_population_batch(*trace_bytes);
if (!base || !trace)
return fail(RecoveryError::tail);
auto replay = server::replay_population_batch(**base, *trace);
if (!replay || (*replay)->snapshot() != *bytes)
return fail(RecoveryError::tail);
}
return RecoveredPopulationCheckpoint{std::move(*committed), *m, std::move(*population)};
}
} // namespace evo::persistence
+25 -6
View File
@@ -60,12 +60,20 @@ bool structural(const CheckpointManifest& m) noexcept {
return false;
const auto& b = m.batch;
const bool primitive = m.profile == CheckpointProfile::primitive_lives_v1;
const bool cellular = m.profile == CheckpointProfile::cellular_lives_v1;
const bool population = m.profile == CheckpointProfile::cellular_population_v1;
const bool cellular = m.profile == CheckpointProfile::cellular_lives_v1 || population;
const bool cellular_migration = cellular && m.sequence > 0 &&
(m.cellular_versions == cellular_v2_versions ||
m.cellular_versions == cellular_v3_versions) &&
m.cellular_versions == cellular_v3_versions ||
m.cellular_versions == cellular_v9_versions) &&
m.begin_tick == m.end_tick && m.end_tick > 0 &&
b == BatchDigests{};
const bool population_conversion = population && m.begin_tick == m.end_tick && m.end_tick > 0 &&
b.trace_bytes >= server::population_batch_header_bytes + 16;
if (population && (m.sequence == 0 || m.cellular_versions != cellular_v9_versions ||
m.history_profile != population_history_profile || b.decision_count != 0 ||
!zero(b.decisions_sha256)))
return false;
if ((!cellular && m.cellular_versions != cellular_v1_versions) ||
(cellular && m.cellular_versions != cellular_v1_versions &&
m.cellular_versions != cellular_v2_versions &&
@@ -103,7 +111,7 @@ bool structural(const CheckpointManifest& m) noexcept {
}
const bool link = !zero(m.predecessor_commit) && m.predecessor_commit != m.commit &&
!zero(m.predecessor_digest) && !zero(m.holder) && m.epoch != 0 &&
(m.end_tick > m.begin_tick || cellular_migration) &&
(m.end_tick > m.begin_tick || cellular_migration || population_conversion) &&
m.end_tick - m.begin_tick <= max_checkpoint_ticks;
if (m.manifest_version == 1)
return link && no_batch;
@@ -146,6 +154,9 @@ bool structural(const CheckpointManifest& m) noexcept {
(b.trace_bytes - server::primitive_batch_header_bytes) %
server::primitive_birth_bytes ==
0
: population
? b.trace_bytes >= server::population_batch_header_bytes + 16 &&
b.trace_bytes <= server::max_population_batch_bytes && b.trace_bytes % 8 == 0
: cellular ? (cellular_current_trace || cellular_v2_trace || cellular_legacy_trace)
: b.trace_bytes == trace_bytes_for(ticks);
return link && trace_shape && !zero(b.trace_sha256) &&
@@ -155,6 +166,11 @@ bool structural(const CheckpointManifest& m) noexcept {
} // namespace
bool supported(const CheckpointManifest& m) noexcept {
if (m.profile == CheckpointProfile::cellular_population_v1)
return m.manifest_version == 2 && m.history_profile == population_history_profile &&
m.cellular_versions == cellular_v9_versions &&
m.versions == environmental_v1_versions && m.tick_microseconds == 50000 &&
m.rng_streams == 0 && m.durability == DurabilityPolicy::single_volume_development;
if (m.profile == CheckpointProfile::primitive_lives_v1)
return m.manifest_version == 2 && m.history_profile == primitive_history_profile &&
m.versions == primitive_v1_versions && m.tick_microseconds == 50000 &&
@@ -208,7 +224,8 @@ encode_manifest(const CheckpointManifest& m) {
w.u(m.epoch, 8);
w.u(m.tick_microseconds, 8);
const auto versions =
m.profile == CheckpointProfile::cellular_lives_v1
(m.profile == CheckpointProfile::cellular_lives_v1 ||
m.profile == CheckpointProfile::cellular_population_v1)
? std::array{m.cellular_versions.rules, m.cellular_versions.envelope,
m.cellular_versions.habitat, m.cellular_versions.coordinate,
m.cellular_versions.genome, m.cellular_versions.development,
@@ -265,7 +282,8 @@ decode_manifest(std::span<const std::uint8_t> bytes) {
std::array<std::uint32_t, 9> versions{};
for (auto& v : versions)
v = static_cast<std::uint32_t>(r.u(4));
if (m.profile == CheckpointProfile::cellular_lives_v1) {
if (m.profile == CheckpointProfile::cellular_lives_v1 ||
m.profile == CheckpointProfile::cellular_population_v1) {
m.cellular_versions = {versions[0], versions[1], versions[2], versions[3], versions[4],
versions[5], versions[6], versions[7], versions[8]};
} else {
@@ -326,7 +344,8 @@ clone_manifest(const CheckpointManifest& source, const Sha256Digest& source_dige
RegionKey target, Uuid commit, std::uint64_t payload_bytes,
const Sha256Digest& payload_sha256, const BatchDigests& inherited) {
if (!supported(source) || source.profile == CheckpointProfile::primitive_lives_v1 ||
source.profile == CheckpointProfile::cellular_lives_v1)
source.profile == CheckpointProfile::cellular_lives_v1 ||
source.profile == CheckpointProfile::cellular_population_v1)
return std::unexpected{CheckpointError::unsupported};
if (!structural(source) || target.world == source.key.world || commit == source.commit ||
inherited.trace_bytes != 0 || !zero(inherited.trace_sha256))
+98 -2
View File
@@ -463,7 +463,7 @@ std::expected<ResolvedCommit, LeaseStoreFailure> resolve_cellular_region_commit(
p, timeout);
if (!rows)
return std::unexpected{classify(rows.error())};
if (rows->size() != 1 || (*rows)[0].size() != 6 || !(*rows)[0][0])
if (rows->size() != 1 || (*rows)[0].size() != 6 || !(*rows)[0][0].has_value())
return std::unexpected{malformed(false)};
const auto status = (*rows)[0][0].value_or(std::string{});
if (status == "absent")
@@ -1502,4 +1502,100 @@ std::expected<bool, AccountIdentityError> revoke_account_grants(Postgres& db, st
return std::unexpected{AccountIdentityError::unknown};
return *revoked == "true";
}
} // namespace evo::persistence
std::expected<RegionHead, LeaseStoreFailure>
publish_population_checkpoint(Postgres& db, std::span<const std::uint8_t> manifest,
std::span<const std::uint8_t> trace, milliseconds timeout) {
const std::array<std::string, 2> parameters{bytea(manifest), bytea(trace)};
auto rows =
db.query("SELECT * FROM evolution.publish_population_checkpoint($1::bytea,$2::bytea)",
parameters, timeout);
if (!rows)
return std::unexpected(classify(rows.error()));
auto head = parse_head(*rows);
if (!head)
return std::unexpected(malformed(true));
return *head;
}
std::expected<RegionHead, LeaseStoreFailure>
publish_population_profile_transition(Postgres& db, std::span<const std::uint8_t> manifest,
milliseconds timeout) {
const std::array<std::string, 1> parameters{bytea(manifest)};
auto rows = db.query("SELECT * FROM evolution.publish_population_profile_transition($1::bytea)",
parameters, timeout);
if (!rows)
return std::unexpected(classify(rows.error()));
auto head = parse_head(*rows);
if (!head)
return std::unexpected(malformed(true));
return *head;
}
std::expected<ResolvedCommit, LeaseStoreFailure>
resolve_population_commit(Postgres& db, RegionKey key, const Uuid& commit,
std::span<const std::uint8_t> manifest,
std::span<const std::uint8_t> trace, milliseconds timeout) {
const std::array<std::string, 5> parameters{std::to_string(key.world),
std::to_string(key.region), uuid_text(commit),
bytea(manifest), bytea(trace)};
auto rows = db.query("SELECT * FROM evolution.resolve_population_commit($1::evolution.u64,"
"$2::evolution.u64,$3::uuid,$4::bytea,$5::bytea)",
parameters, timeout);
if (!rows)
return std::unexpected(classify(rows.error()));
if (rows->size() != 1 || (*rows)[0].size() != 6 || !(*rows)[0][0])
return std::unexpected(malformed(false));
const auto status_field = (*rows)[0][0];
if (!status_field.has_value())
return std::unexpected(malformed(false));
const auto& status = *status_field;
if (status == "absent")
return ResolvedCommit{Resolution::absent, {}};
if (status == "conflict")
return ResolvedCommit{Resolution::conflict, {}};
PgRows receipt{PgRows::value_type((*rows)[0].begin() + 1, (*rows)[0].end())};
const auto head = status == "committed" ? parse_head(receipt) : std::nullopt;
if (!head)
return std::unexpected(malformed(false));
return ResolvedCommit{Resolution::committed, *head};
}
std::expected<std::optional<PopulationEvidence>, LeaseStoreFailure>
load_population_evidence(Postgres& db, RegionKey key, const LeaseGrant& lease, const Uuid& commit,
milliseconds timeout) {
const std::array<std::string, 5> parameters{std::to_string(key.world),
std::to_string(key.region), uuid_text(lease.holder),
std::to_string(lease.epoch), uuid_text(commit)};
auto rows = db.query(
"SELECT encode(trace,'hex'),source_commit::text,encode(source_manifest_sha256,'hex'),"
"encode(source_payload_sha256,'hex') FROM "
"evolution.load_population_evidence($1::evolution.u64,"
"$2::evolution.u64,$3::uuid,$4::evolution.u64,$5::uuid)",
parameters, timeout);
if (!rows)
return std::unexpected(classify(rows.error()));
if (rows->empty())
return std::optional<PopulationEvidence>{};
if (rows->size() != 1 || (*rows)[0].size() != 4 || !(*rows)[0][0].has_value())
return std::unexpected(malformed(false));
const auto& row = (*rows)[0];
const auto trace_field = row[0];
if (!trace_field.has_value())
return std::unexpected(malformed(false));
auto trace = unhex_bytes(*trace_field);
if (!trace)
return std::unexpected(malformed(false));
PopulationEvidence evidence{std::move(*trace), {}, {}, {}};
if (evidence.trace.empty()) {
const auto source = parse_uuid(row[1]);
const auto manifest_field = row[2], payload_field = row[3];
const auto manifest =
manifest_field.has_value() ? unhex<32>(*manifest_field) : std::nullopt;
const auto payload = payload_field.has_value() ? unhex<32>(*payload_field) : std::nullopt;
if (!source || !manifest || !payload)
return std::unexpected(malformed(false));
evidence.source_commit = *source;
evidence.source_manifest_sha256 = *manifest;
evidence.source_payload_sha256 = *payload;
} else if (row[1] || row[2] || row[3])
return std::unexpected(malformed(false));
return std::optional<PopulationEvidence>{std::move(evidence)};
}
} // namespace evo::persistence
+210 -23
View File
@@ -12,10 +12,11 @@
namespace evo::server {
struct CellularRegionHost::Pending {
persistence::CellularPreparedCommit prepared;
std::unique_ptr<CellularLives> candidate;
OwnedState candidate;
std::vector<CellularActionRecord> actions;
std::vector<CellularTickIntents::Birth> births;
std::vector<CellularMutationActionRecord> mutation_actions;
std::optional<persistence::PopulationPreparedCommit> population_prepared{};
};
namespace {
@@ -196,34 +197,72 @@ void CellularRegionHost::acquire() {
status_.phase = HostPhase::quarantined;
return;
}
auto recovered = persistence::recover_cellular_checkpoint(*db_, *objects_, config_.key, *lease,
config_.retained_builds,
config_.lease.commit_timeout);
if (!recovered) {
if (recovered.error().kind == persistence::RecoveryError::store) {
db_.reset();
++status_.store_failures;
return;
}
authority_.fence();
status_.phase = HostPhase::quarantined;
if (!recover_state(*lease) || !committed_.has_value() || !state_)
return;
}
state_ = std::move(recovered->state);
committed_ = std::move(recovered->committed);
queued_mutations_.clear();
mutations_uncertain_ = true; // Reserved choices are reloaded under the new lease.
// ADR-0127: every founder corpse is an ended life; record any ending a crash lost.
mutations_uncertain_ = true;
pending_endings_.clear();
for (const auto& corpse : state_->corpses())
if (corpse.parent_life == 0)
pending_endings_.push_back({committed_->head.commit, corpse.life_id});
// Controlled cells cannot die in unattended profile 5; their earlier raw
// endings were drained before entry. Do not invent a new death commit.
if (!population_mode())
for (const auto& corpse : state_->corpses())
if (corpse.parent_life == 0)
pending_endings_.push_back({committed_->head.commit, corpse.life_id});
status_.phase = HostPhase::running;
status_.simulated_tick = committed_->head.end_tick;
status_.committed_tick = committed_->head.end_tick;
status_.committed_sequence = committed_->head.sequence;
}
bool CellularRegionHost::recover_state(const persistence::LeaseGrant& lease) {
auto head =
persistence::load_region_checkpoint(*db_, config_.key, config_.lease.commit_timeout);
if (!head) {
db_.reset();
++status_.store_failures;
return false;
}
const auto manifest = persistence::decode_manifest(head->manifest);
if (!manifest) {
authority_.fence();
status_.phase = HostPhase::quarantined;
return false;
}
if (manifest->profile == persistence::CheckpointProfile::cellular_population_v1) {
auto recovered = persistence::recover_population_checkpoint(*db_, *objects_, config_.key,
lease, config_.retained_builds,
config_.lease.commit_timeout);
if (!recovered) {
if (recovered.error().kind == persistence::RecoveryError::store) {
db_.reset();
++status_.store_failures;
} else {
authority_.fence();
status_.phase = HostPhase::quarantined;
}
return false;
}
state_ = std::move(recovered->state);
committed_ = std::move(recovered->committed);
return true;
}
auto recovered = persistence::recover_cellular_checkpoint(
*db_, *objects_, config_.key, lease, config_.retained_builds, config_.lease.commit_timeout);
if (!recovered) {
if (recovered.error().kind == persistence::RecoveryError::store) {
db_.reset();
++status_.store_failures;
return false;
}
authority_.fence();
status_.phase = HostPhase::quarantined;
return false;
}
state_ = std::move(recovered->state);
committed_ = std::move(recovered->committed);
return true;
}
void CellularRegionHost::upkeep() {
if (authority_.state(LeaseClock::now()) == persistence::LeaseState::fenced) {
authority_.fence();
@@ -280,8 +319,12 @@ void CellularRegionHost::resolve() {
++status_.fences;
return;
}
const auto resolved = persistence::resolve_cellular_prepared(*db_, pending_->prepared,
config_.lease.commit_timeout);
const auto& population_prepared = pending_->population_prepared;
const auto resolved = population_prepared.has_value()
? persistence::resolve_population_prepared(
*db_, *population_prepared, config_.lease.commit_timeout)
: persistence::resolve_cellular_prepared(
*db_, pending_->prepared, config_.lease.commit_timeout);
if (!resolved) {
if (resolved.error().kind == LeaseStoreError::fenced) {
authority_.fence();
@@ -309,8 +352,18 @@ void CellularRegionHost::resolve() {
if (resolved->status == persistence::Resolution::absent &&
!authority_.may_begin_commit(LeaseClock::now()))
return;
auto retried = persistence::retry_cellular_prepared(*db_, pending_->prepared,
auto retried = [&]() -> std::expected<persistence::CommittedCheckpoint,
persistence::CellularPublicationFailure> {
if (!pending_->population_prepared)
return persistence::retry_cellular_prepared(*db_, pending_->prepared,
config_.lease.commit_timeout);
auto result = persistence::retry_population_prepared(*db_, *pending_->population_prepared,
config_.lease.commit_timeout);
if (!result)
return std::unexpected(persistence::CellularPublicationFailure{
result.error().kind, result.error().store, result.error().object, {}});
return std::move(*result);
}();
if (!retried) {
if (retried.error().kind == persistence::PublicationError::unknown) {
db_.reset();
@@ -483,6 +536,8 @@ CellularRegionHost::select_mutation(const persistence::Uuid& account, std::uint6
if (!status_.ready || mutations_uncertain_ || pending_ || !state_ || !committed_ ||
!authority_.may_begin_commit(LeaseClock::now()) || !database())
return {not_ready, 0, {}};
if (population_mode() && !set_population_mode(false))
return {not_ready, 0, {}};
const auto tick = committed_->head.end_tick + 1;
const CellularMutationActionRecord record{account, action_id, tick, input};
const auto bytes = encode_cellular_mutation_input(record);
@@ -552,6 +607,12 @@ CellularRegionHost::publish(const CellularBatch& batch,
if (!status_.ready || mutations_uncertain_ || !state_ || !committed_ || !grant ||
!authority_.may_begin_commit(LeaseClock::now()))
return std::unexpected{CellularPublishFailure{CellularHostError::not_ready, {}, {}, {}}};
if (population_mode()) {
if (!actions.empty() || !mutation_actions.empty())
return std::unexpected(
CellularPublishFailure{CellularHostError::invalid_batch, {}, {}, {}});
return publish_population(batch);
}
auto candidate = replay_cellular_batch(*state_, batch);
if (!candidate)
return std::unexpected{
@@ -722,6 +783,8 @@ network::PrimitiveLifeOutcome
CellularRegionHost::create_primitive_life(const persistence::Uuid& account,
std::uint64_t generation, std::uint64_t request) {
using network::PrimitiveLifeResult;
if (population_mode() && !set_population_mode(false))
return {request, PrimitiveLifeResult::unknown, 0, 0};
const auto existing = query_birth(account, generation, request, true);
if (existing.result != PrimitiveLifeResult::unknown)
return existing;
@@ -754,6 +817,8 @@ CellularRegionHost::create_primitive_life(const persistence::Uuid& account,
network::PrimitiveLifeOutcome
CellularRegionHost::query_primitive_life(const persistence::Uuid& account, std::uint64_t generation,
std::uint64_t request) {
if (population_mode() && !set_population_mode(false))
return {request, network::PrimitiveLifeResult::unknown, 0, 0};
return query_birth(account, generation, request, true);
}
@@ -784,4 +849,126 @@ std::optional<persistence::LeaseGrant> CellularRegionHost::authority() const {
return std::nullopt;
return authority_.grant();
}
bool CellularRegionHost::population_mode() const noexcept {
return state_.population != nullptr;
}
std::expected<persistence::CommittedCheckpoint, CellularPublishFailure>
CellularRegionHost::accept_population_publication(
std::expected<persistence::CommittedCheckpoint, persistence::PopulationPublicationFailure>
result,
OwnedState candidate) {
if (!result) {
const auto& error = result.error();
if (error.kind == persistence::PublicationError::unknown) {
pending_ = std::make_unique<Pending>(
Pending{{}, std::move(candidate), {}, {}, {}, error.prepared});
status_.phase = HostPhase::resolving;
status_.ready = false;
++status_.unknown_outcomes;
db_.reset();
} else if (error.store.kind == LeaseStoreError::fenced) {
authority_.fence();
state_.reset();
committed_.reset();
status_.phase = HostPhase::acquiring;
status_.ready = false;
++status_.fences;
} else if (error.kind == persistence::PublicationError::predecessor ||
error.kind == persistence::PublicationError::verify ||
error.kind == persistence::PublicationError::receipt) {
authority_.fence();
state_.reset();
committed_.reset();
status_.phase = HostPhase::quarantined;
status_.ready = false;
} else {
mutations_uncertain_ = true;
}
return std::unexpected(CellularPublishFailure{CellularHostError::publication, error.kind,
error.store, error.object});
}
note_endings(*state_, *candidate, result->head.commit);
state_ = std::move(candidate);
committed_ = *result;
++status_.commits;
status_.committed_sequence = committed_->head.sequence;
status_.committed_tick = status_.simulated_tick = committed_->head.end_tick;
refresh();
return std::move(*result);
}
std::expected<void, CellularPublishFailure> CellularRegionHost::set_population_mode(bool enabled) {
if (!status_.ready || pending_ || mutations_uncertain_ || !state_ || !committed_.has_value() ||
!authority_.may_begin_commit(LeaseClock::now()) || !database())
return std::unexpected(CellularPublishFailure{CellularHostError::not_ready, {}, {}, {}});
if (population_mode() == enabled)
return {};
if (enabled &&
(!config_.population_policy || !queued_mutations_.empty() || !pending_endings_.empty() ||
state_->rules_version() != cellular_lives_foraging_rules))
return std::unexpected(CellularPublishFailure{CellularHostError::not_ready, {}, {}, {}});
const auto policy = config_.population_policy.value_or(CellularTierPolicy{});
std::array<std::uint8_t, 10> marker{};
marker[0] = enabled ? 1 : 0;
marker[1] = policy.automatic ? 1 : 0;
for (unsigned i = 0; i < 4; ++i) {
marker[2 + i] = static_cast<std::uint8_t>(policy.materialize_radius_um >> (i * 8U));
marker[6 + i] = static_cast<std::uint8_t>(policy.collapse_radius_um >> (i * 8U));
}
const auto id = commit_id(*committed_, marker, {});
auto raw = CellularLives::restore(state_->snapshot(), state_->world(), state_->region(),
state_->frame(), state_->tick());
if (!id || !raw)
return std::unexpected(
CellularPublishFailure{CellularHostError::invalid_batch, {}, {}, {}});
OwnedState candidate;
if (enabled) {
auto population = CellularPopulation::create(std::move(*raw), policy);
if (!population)
return std::unexpected(
CellularPublishFailure{CellularHostError::configuration, {}, {}, {}});
candidate = std::move(*population);
} else
candidate = std::move(*raw);
const auto grant = authority_.grant();
if (!grant.has_value())
return std::unexpected(CellularPublishFailure{CellularHostError::not_ready, {}, {}, {}});
auto result =
enabled ? persistence::migrate_cellular_to_population(*db_, *objects_, *grant, *committed_,
*id, config_.build, policy,
config_.lease.commit_timeout)
: persistence::materialize_population_profile(*db_, *objects_, *grant, *committed_,
*id, config_.build,
config_.lease.commit_timeout);
auto accepted = accept_population_publication(std::move(result), std::move(candidate));
if (!accepted)
return std::unexpected(accepted.error());
return {};
}
std::expected<persistence::PublishedCellularBatch, CellularPublishFailure>
CellularRegionHost::publish_population(const CellularBatch& batch) {
const auto grant = authority_.grant();
if (!state_.population || !queued_mutations_.empty() || !committed_.has_value() ||
!grant.has_value() || !database())
return std::unexpected(CellularPublishFailure{CellularHostError::not_ready, {}, {}, {}});
auto execution = prepare_population_batch(*state_.population, batch);
if (!execution)
return std::unexpected(
CellularPublishFailure{CellularHostError::invalid_batch, {}, {}, {}});
const auto trace = encode_population_batch(execution->batch);
const auto id = trace ? commit_id(*committed_, *trace, {}) : std::nullopt;
if (!id)
return std::unexpected(
CellularPublishFailure{CellularHostError::invalid_batch, {}, {}, {}});
auto result = persistence::publish_population_batch(
*db_, *objects_, *grant, *committed_, execution->batch, *execution->state, *id,
config_.build, config_.lease.commit_timeout);
auto accepted =
accept_population_publication(std::move(result), OwnedState(std::move(execution->state)));
if (!accepted)
return std::unexpected(accepted.error());
return persistence::PublishedCellularBatch{std::move(*accepted), {}};
}
} // namespace evo::server
@@ -0,0 +1,296 @@
#include "evo/server/lifecycle/cellular_population_batch.hpp"
#include "evo/server/lifecycle/wildlife_controller.hpp"
#include <algorithm>
#include <utility>
namespace evo::server {
namespace {
constexpr std::uint64_t magic = 0x315442504F564541ULL; // "AEVOPBT1"
bool shape(const CellularPopulationBatch& batch, bool recording) {
const auto& h = batch.header;
const auto zero = [](const auto& bytes) {
return std::ranges::all_of(bytes, [](auto byte) { return byte == 0; });
};
if (h.world == 0 || h.region == 0 || h.frame == 0 || zero(h.predecessor) ||
zero(h.predecessor_digest) || h.end_tick < h.begin_tick)
return false;
const auto count = batch.conversion ? std::size_t{1} : batch.biology.ticks.size();
if (count == 0 || count > max_cellular_batch_ticks ||
(!recording && batch.boundaries.size() != count))
return false;
if (batch.conversion) {
if (h.begin_tick == 0 || h.begin_tick != h.end_tick || batch.conversion->genome == 0 ||
!batch.biology.ticks.empty() || batch.biology.header != CellularBatchHeader{})
return false;
} else {
if (batch.biology.header != h || batch.biology.format_version != cellular_batch_format ||
h.end_tick - h.begin_tick != count || !encode_cellular_batch(batch.biology))
return false;
for (const auto& tick : batch.biology.ticks)
if (!tick.births.empty() || !tick.mutations.empty())
return false;
}
for (const auto& boundary : batch.boundaries) {
if (boundary.members.size() > biology::max_cellular_tick_lives)
return false;
std::uint64_t previous = 0;
for (const auto& member : boundary.members) {
if (member.life <= previous || member.genome == 0)
return false;
previous = member.life;
}
}
return true;
}
void put(std::vector<std::uint8_t>& out, std::uint64_t value, unsigned width = 8) {
for (unsigned i = 0; i < width; ++i) {
out.push_back(static_cast<std::uint8_t>(value & 255U));
value >>= 8U;
}
}
class Reader {
public:
explicit Reader(std::span<const std::uint8_t> bytes) : bytes_(bytes) {}
std::uint64_t get(unsigned width = 8) {
std::uint64_t value = 0;
for (unsigned i = 0; i < width; ++i)
value |= std::uint64_t{bytes_[at_++]} << (8U * i);
return value;
}
template <std::size_t N> std::array<std::uint8_t, N> array() {
std::array<std::uint8_t, N> value{};
for (auto& byte : value)
byte = bytes_[at_++];
return value;
}
std::size_t at() const {
return at_;
}
private:
std::span<const std::uint8_t> bytes_;
std::size_t at_{};
};
} // namespace
std::expected<CellularBatch, CellularPopulationError>
unattended_population_inputs(const CellularLives& base, const CellularBatchHeader& header) {
if (header.world != base.world() || header.region != base.region() ||
header.frame != base.frame() || header.begin_tick != base.tick() ||
header.end_tick <= header.begin_tick ||
header.end_tick - header.begin_tick > max_cellular_batch_ticks)
return std::unexpected(CellularPopulationError::identity);
auto working = CellularLives::restore(base.snapshot(), base.world(), base.region(),
base.frame(), base.tick());
if (!working)
return std::unexpected(CellularPopulationError::format);
CellularBatch batch{header, {}};
while ((*working)->tick() < header.end_tick) {
auto intents = wildlife_intents(**working, (*working)->tick() + 1);
if (!intents)
return std::unexpected(CellularPopulationError::ineligible);
for (const auto& life : (*working)->lives()) {
if (life.account == LifeAccount{})
continue;
CellularLifeIntent frozen{life.identity.life, {}};
frozen.intent.frozen = true;
intents->push_back(frozen);
}
std::ranges::sort(*intents, {}, &CellularLifeIntent::life_id);
if (!(*working)->advance_tick(*intents))
return std::unexpected(CellularPopulationError::ineligible);
batch.ticks.push_back({std::move(*intents), {}, {}});
}
if (!encode_cellular_batch(batch))
return std::unexpected(CellularPopulationError::format);
return batch;
}
std::expected<std::unique_ptr<CellularPopulation>, CellularPopulationError>
execute_population_batch(const CellularPopulation& base, CellularPopulationBatch& batch,
bool record) {
if (!shape(batch, record) || batch.header.world != base.state().world() ||
batch.header.region != base.state().region() ||
batch.header.frame != base.state().frame() ||
batch.header.begin_tick != base.state().tick())
return std::unexpected(CellularPopulationError::identity);
auto candidate =
CellularPopulation::restore(base.snapshot(), base.state().world(), base.state().region(),
base.state().frame(), base.state().tick());
if (!candidate)
return std::unexpected(candidate.error());
if (record)
batch.boundaries.clear();
const auto check_boundary = [&](std::size_t index) {
CellularPopulationBoundary actual{(*candidate)->conversion_sequence_,
(*candidate)->members_};
if (record) {
batch.boundaries.push_back(std::move(actual));
return true;
}
return batch.boundaries[index] == actual;
};
if (batch.conversion) {
const auto converted = batch.conversion->to_cohort
? (*candidate)->collapse(batch.conversion->genome)
: (*candidate)->materialize(batch.conversion->genome);
if (!converted || !check_boundary(0))
return std::unexpected(CellularPopulationError::ineligible);
} else {
for (std::size_t index = 0; index < batch.biology.ticks.size(); ++index) {
const auto& input = batch.biology.ticks[index];
for (const auto& life : (*candidate)->state().lives()) {
if (life.account == LifeAccount{})
continue;
const auto intent = std::ranges::find(input.lives, life.identity.life,
&CellularLifeIntent::life_id);
biology::CellularStepIntent frozen;
frozen.frozen = true;
if (intent == input.lives.end() || intent->intent != frozen)
return std::unexpected(CellularPopulationError::ineligible);
}
CellularBatch one{batch.biology.header, {input}, cellular_batch_format};
one.header.begin_tick = (*candidate)->state().tick();
one.header.end_tick = one.header.begin_tick + 1;
auto biology = replay_cellular_batch((*candidate)->state(), one);
if (!biology)
return std::unexpected(CellularPopulationError::ineligible);
(*candidate)->state_ = std::move(*biology);
std::erase_if((*candidate)->members_, [&](const auto& member) {
return std::ranges::find((*candidate)->state().lives(), member.life,
[](const auto& life) { return life.identity.life; }) ==
(*candidate)->state().lives().end();
});
// Verify the persisted policy's exact result against the recorded sample;
// no controller or random materialization is run during replay.
if ((*candidate)->policy_.automatic) {
if ((*candidate)->conversion_sequence_ == ~std::uint64_t{0})
return std::unexpected(CellularPopulationError::overflow);
(*candidate)->apply_policy();
}
if (!check_boundary(index))
return std::unexpected(CellularPopulationError::ineligible);
}
}
return candidate;
}
std::expected<CellularPopulationExecution, CellularPopulationError>
prepare_population_batch(const CellularPopulation& base, CellularBatch biology) {
CellularPopulationBatch batch{biology.header, std::move(biology), {}, {}};
auto state = execute_population_batch(base, batch, true);
if (!state)
return std::unexpected(state.error());
return CellularPopulationExecution{std::move(batch), std::move(*state)};
}
std::expected<CellularPopulationExecution, CellularPopulationError>
prepare_population_conversion(const CellularPopulation& base, CellularBatchHeader header,
CellularPopulationConversion conversion) {
CellularPopulationBatch batch{header, {}, conversion, {}};
auto state = execute_population_batch(base, batch, true);
if (!state)
return std::unexpected(state.error());
return CellularPopulationExecution{std::move(batch), std::move(*state)};
}
std::expected<std::unique_ptr<CellularPopulation>, CellularPopulationError>
replay_population_batch(const CellularPopulation& base, const CellularPopulationBatch& batch) {
auto copy = batch;
return execute_population_batch(base, copy, false);
}
std::expected<std::vector<std::uint8_t>, CellularPopulationError>
encode_population_batch(const CellularPopulationBatch& batch) {
if (!shape(batch, false))
return std::unexpected(CellularPopulationError::format);
std::vector<std::uint8_t> biological;
if (!batch.conversion) {
auto encoded = encode_cellular_batch(batch.biology);
if (!encoded)
return std::unexpected(CellularPopulationError::format);
biological = std::move(*encoded);
}
std::vector<std::uint8_t> out;
put(out, magic);
put(out, 1, 4);
put(out, batch.conversion ? 1 : 0, 4);
const auto& h = batch.header;
for (const auto value : {h.world, h.region, h.frame})
put(out, value);
out.insert(out.end(), h.predecessor.begin(), h.predecessor.end());
out.insert(out.end(), h.predecessor_digest.begin(), h.predecessor_digest.end());
put(out, h.begin_tick);
put(out, h.end_tick);
put(out, batch.boundaries.size(), 4);
put(out, 0, 4);
put(out, biological.size());
put(out, batch.conversion ? batch.conversion->genome : 0);
put(out, batch.conversion && batch.conversion->to_cohort ? 1 : 0);
out.insert(out.end(), biological.begin(), biological.end());
for (const auto& boundary : batch.boundaries) {
put(out, boundary.sequence);
put(out, boundary.members.size());
for (const auto& member : boundary.members) {
put(out, member.life);
put(out, member.genome);
}
}
return out;
}
std::expected<CellularPopulationBatch, CellularPopulationError>
decode_population_batch(std::span<const std::uint8_t> bytes) {
if (bytes.size() < population_batch_header_bytes || bytes.size() > max_population_batch_bytes)
return std::unexpected(CellularPopulationError::format);
Reader in(bytes);
if (in.get() != magic || in.get(4) != 1)
return std::unexpected(CellularPopulationError::unsupported);
const auto kind = in.get(4);
CellularPopulationBatch batch;
auto& h = batch.header;
h.world = in.get();
h.region = in.get();
h.frame = in.get();
h.predecessor = in.array<16>();
h.predecessor_digest = in.array<32>();
h.begin_tick = in.get();
h.end_tick = in.get();
const auto count = in.get(4);
if (in.get(4) != 0 || kind > 1 || count == 0 || count > max_cellular_batch_ticks)
return std::unexpected(CellularPopulationError::format);
const auto size = in.get(), genome = in.get(), to_cohort = in.get();
if (size > max_cellular_batch_bytes || size > bytes.size() - population_batch_header_bytes ||
to_cohort > 1 || (kind == 0 && (genome != 0 || to_cohort != 0)) || (kind == 1 && size != 0))
return std::unexpected(CellularPopulationError::format);
if (kind == 1)
batch.conversion = {genome, to_cohort == 1};
else {
auto biological = decode_cellular_batch(
bytes.subspan(population_batch_header_bytes, static_cast<std::size_t>(size)));
if (!biological)
return std::unexpected(CellularPopulationError::format);
batch.biology = std::move(*biological);
}
std::size_t at = population_batch_header_bytes + static_cast<std::size_t>(size);
for (std::uint64_t index = 0; index < count; ++index) {
if (bytes.size() - at < 16)
return std::unexpected(CellularPopulationError::format);
Reader boundary_reader(bytes.subspan(at));
CellularPopulationBoundary boundary;
boundary.sequence = boundary_reader.get();
const auto members = boundary_reader.get();
if (members > biology::max_cellular_tick_lives || members * 16 > bytes.size() - at - 16)
return std::unexpected(CellularPopulationError::format);
for (std::uint64_t member = 0; member < members; ++member)
boundary.members.push_back({boundary_reader.get(), boundary_reader.get()});
at += boundary_reader.at();
batch.boundaries.push_back(std::move(boundary));
}
if (at != bytes.size() || !shape(batch, false))
return std::unexpected(CellularPopulationError::format);
const auto encoded = encode_population_batch(batch);
if (!encoded || !std::ranges::equal(*encoded, bytes))
return std::unexpected(CellularPopulationError::format);
return batch;
}
} // namespace evo::server
+6 -21
View File
@@ -12,23 +12,6 @@ using namespace evo::server;
using namespace evo::fixture;
using Population = std::unique_ptr<CellularPopulation>;
Owner descendants() {
auto state = opening(1, true);
std::set<std::uint64_t> mutated;
for (unsigned step = 0; step < 8192; ++step) {
const auto input = inputs(*state, 1, mutated);
const auto executed =
checked(state->advance_tick_with_mutations(input.lives, input.mutations),
"descendant fixture tick");
for (const auto& mutation : executed.mutations)
if (mutation.result == CellularMutationResult::applied)
mutated.insert(mutation.life_id);
}
require(std::ranges::any_of(state->lives(),
[](const auto& life) { return life.account == LifeAccount{}; }),
"fixture has no funded descendant");
return state;
}
Population restored(std::span<const std::uint8_t> bytes, const CellularLives& state) {
return checked(CellularPopulation::restore(bytes, state.world(), state.region(), state.frame(),
state.tick()),
@@ -64,7 +47,8 @@ void refresh(std::vector<std::uint8_t>& bytes) {
put(bytes, bytes.size() - 8, hash);
}
void conversions_and_codec() {
auto population = checked(CellularPopulation::create(descendants()), "population create");
auto population =
checked(CellularPopulation::create(cellular_descendants()), "population create");
const auto genome = wildlife_genome(*population);
const auto before = population->snapshot();
const auto biology = population->state().snapshot();
@@ -129,7 +113,7 @@ void conversions_and_codec() {
}
void automatic_and_restart() {
auto initial = descendants();
auto initial = cellular_descendants();
auto policy = checked(CellularPopulation::create(restore(*initial), {true, 1200, 1800}),
"automatic owner");
auto exact = checked(CellularPopulation::create(restore(*initial)), "individual control");
@@ -170,8 +154,9 @@ void write(const char* path, const CellularPopulation& population) {
require(!stream.fail(), "test checkpoint write failed");
}
void checkpoint(const char* path, const char* expected) {
auto population = checked(CellularPopulation::create(descendants(), {true, 1200, 1800}),
"process checkpoint owner");
auto population =
checked(CellularPopulation::create(cellular_descendants(), {true, 1200, 1800}),
"process checkpoint owner");
for (unsigned tick = 0; tick < 250; ++tick)
frozen_tick(*population);
require(!population->members().empty(), "process checkpoint has no cohort");
+21 -1
View File
@@ -44,7 +44,8 @@ inline Owner restore(const CellularLives& state) {
"reference restore");
}
inline Owner opening(std::uint64_t seed, bool rich, std::uint32_t count = 4) {
inline Owner opening(std::uint64_t seed, bool rich, std::uint32_t count = 4,
bool populated = true) {
require(count > 0 && count <= biology::max_cellular_tick_lives, "fixture population bound");
const std::uint32_t side = count == 4 ? 6'000 : 48'000;
const auto world = 200 + seed;
@@ -106,6 +107,8 @@ inline Owner opening(std::uint64_t seed, bool rich, std::uint32_t count = 4) {
checked(CellularLives::create(*primitive, std::move(habitat), {{side, side}, 0, 293'150},
CellularLivesProfile::foraging),
"reference cellular owner");
if (!populated)
return state;
require(state->advance_tick(std::span<const CellularLifeIntent>{}).has_value(),
"reference genesis tick");
for (std::uint64_t index = 0; index < count; ++index) {
@@ -177,4 +180,21 @@ inline CellularTickIntents inputs(const CellularLives& state, std::uint64_t seed
return tick;
}
inline Owner cellular_descendants() {
auto state = opening(1, true);
std::set<std::uint64_t> mutated;
for (unsigned step = 0; step < 8192; ++step) {
const auto input = inputs(*state, 1, mutated);
const auto executed =
checked(state->advance_tick_with_mutations(input.lives, input.mutations),
"descendant fixture tick");
for (const auto& mutation : executed.mutations)
if (mutation.result == CellularMutationResult::applied)
mutated.insert(mutation.life_id);
}
require(std::ranges::any_of(state->lives(),
[](const auto& life) { return life.account == LifeAccount{}; }),
"fixture has no funded descendant");
return state;
}
} // namespace evo::fixture
+159
View File
@@ -0,0 +1,159 @@
#include "evo/persistence/region_checkpoint.hpp"
#include "evo/server/lifecycle/cellular_population_batch.hpp"
#include "fixtures/cellular_ecology.hpp"
namespace {
using namespace evo;
using namespace evo::server;
using namespace evo::persistence;
using namespace evo::fixture;
template <std::size_t N> std::array<std::uint8_t, N> filled(std::uint8_t byte) {
std::array<std::uint8_t, N> out{};
out.fill(byte);
return out;
}
CellularBatchHeader header(const CellularPopulation& state, std::uint64_t ticks) {
const auto& s = state.state();
return {s.world(), s.region(), s.frame(), filled<16>(1),
filled<32>(2), s.tick(), s.tick() + ticks};
}
CellularBatch inputs_batch(const CellularPopulation& base) {
CellularBatch batch{header(base, 64), {}};
auto biological = restore(base.state());
for (unsigned tick = 0; tick < 64; ++tick) {
auto inputs =
checked(wildlife_intents(*biological, biological->tick() + 1), "batch wildlife");
for (const auto& life : biological->lives()) {
if (life.account == LifeAccount{})
continue;
CellularLifeIntent frozen{life.identity.life, {}};
frozen.intent.frozen = true;
inputs.push_back(frozen);
}
std::ranges::sort(inputs, {}, &CellularLifeIntent::life_id);
batch.ticks.push_back({inputs, {}, {}});
checked(biological->advance_tick(inputs), "build biological input fixture");
}
return batch;
}
void traces() {
auto population = checked(
CellularPopulation::create(cellular_descendants(), {true, 1200, 1800}), "batch population");
std::uint64_t converted = 0;
for (unsigned interval = 0; interval < 6; ++interval) {
auto inputs = inputs_batch(*population);
require(checked(unattended_population_inputs(population->state(), inputs.header),
"unattended worker batch") == inputs,
"worker interval changed frozen/wildlife input contract");
const auto predecessor = population->snapshot();
auto execution = checked(prepare_population_batch(*population, inputs), "prepare trace");
const auto bytes = checked(encode_population_batch(execution.batch), "encode trace");
const auto decoded = checked(decode_population_batch(bytes), "decode trace");
require(decoded == execution.batch, "population trace round trip");
auto replay = checked(replay_population_batch(*population, decoded), "replay trace");
require(replay->snapshot() == execution.state->snapshot() &&
population->snapshot() == predecessor,
"trace changed predecessor or replay result");
auto altered = decoded;
++altered.boundaries.back().sequence;
require(!replay_population_batch(*population, altered), "altered sequence admitted");
altered = decoded;
altered.biology.ticks.front().lives.front().intent.frozen = false;
require(!replay_population_batch(*population, altered),
"unfrozen controlled step admitted");
for (std::size_t length = 0; length < bytes.size(); length += 113)
require(!decode_population_batch(std::span{bytes}.first(length)),
"truncated trace admitted");
auto extended = bytes;
extended.push_back(0);
require(!decode_population_batch(extended), "appended trace bytes admitted");
converted += replay->members().size();
population = std::move(replay);
}
require(converted > 0 && !population->members().empty(), "batch test has no cohorts");
const auto genome = population->members().front().genome;
const auto before = population->state().snapshot();
auto conversion =
checked(prepare_population_conversion(*population, header(*population, 0), {genome, false}),
"manual trace");
const auto encoded = checked(encode_population_batch(conversion.batch), "manual encode");
const auto decoded = checked(decode_population_batch(encoded), "manual decode");
auto replay = checked(replay_population_batch(*population, decoded), "manual replay");
require(replay->state().snapshot() == before && replay->members().empty(),
"manual materialization changed biology");
}
void manifests() {
auto state = cellular_descendants();
auto population = checked(CellularPopulation::create(restore(*state), {true, 1200, 1800}),
"manifest population");
CheckpointManifest source;
source.profile = CheckpointProfile::cellular_lives_v1;
source.cellular_versions = cellular_v9_versions;
source.history_profile = cellular_revision_history_profile;
source.key = {state->world(), state->region()};
source.frame = state->frame();
source.tick_microseconds = 50000;
source.sequence = 2;
source.commit = filled<16>(1);
source.predecessor_commit = filled<16>(2);
source.predecessor_digest = filled<32>(3);
source.holder = filled<16>(4);
source.epoch = 1;
source.begin_tick = state->tick() - 1;
source.end_tick = state->tick();
source.build = filled<32>(5);
source.payload_bytes = state->snapshot().size();
source.payload_sha256 = filled<32>(6);
source.batch = {128, filled<32>(7), 0, {}};
require(encode_manifest(source).has_value(), "source manifest fixture");
LeaseGrant lease{filled<16>(4), 1, state->frame(), std::chrono::milliseconds{20000}};
auto next = checked(population_profile_transition_manifest(
source, filled<32>(8), filled<16>(9), lease, source.build,
population->snapshot().size(), filled<32>(10)),
"profile transition");
require(next.profile == CheckpointProfile::cellular_population_v1 && supported(next),
"wrong profile");
const auto encoded = checked(encode_manifest(next), "population manifest");
require(checked(decode_manifest(encoded), "manifest decode") == next,
"manifest profile changed");
auto restored_population =
checked(restore_population_payload(population->snapshot(), next), "profile payload");
require(restored_population->snapshot() == population->snapshot(),
"population payload changed");
require(!restore_cellular_payload(population->snapshot(), next),
"population mislabeled as cellular");
auto back = checked(population_profile_transition_manifest(
next, filled<32>(11), filled<16>(12), lease, source.build,
state->snapshot().size(), filled<32>(13)),
"reverse transition");
require(back.end_tick == source.end_tick && back.profile == source.profile &&
checked(restore_cellular_payload(state->snapshot(), back), "unwrapped payload")
->snapshot() == state->snapshot(),
"profile transition changed biology/time");
auto execution = checked(prepare_population_batch(*population, inputs_batch(*population)),
"manifest tick fixture");
const auto trace = checked(encode_population_batch(execution.batch), "manifest trace fixture");
const auto advancing = population_successor_manifest(
next, filled<32>(11), filled<16>(12), lease, execution.state->state().tick(), source.build,
execution.state->snapshot().size(), filled<32>(13), {trace.size(), filled<32>(14), 0, {}});
require(advancing.has_value() &&
restore_population_payload(execution.state->snapshot(), *advancing).has_value(),
"population successor refused");
require(!clone_manifest(next, filled<32>(1), {9999, 1}, filled<16>(3), 100, filled<32>(4), {}),
"population clone admitted without identity remapping");
auto malformed = next;
malformed.sequence = 0;
require(!encode_manifest(malformed), "population genesis admitted");
malformed = next;
malformed.cellular_versions = cellular_v8_versions;
require(!supported(malformed), "unsupported nested rules admitted");
}
} // namespace
int main() try {
traces();
manifests();
return 0;
} catch (const std::exception& error) {
std::fprintf(stderr, "%s\n", error.what());
return 1;
}
+486
View File
@@ -0,0 +1,486 @@
#include "evo/persistence/account_control_store.hpp"
#include "evo/persistence/population_checkpoint_store.hpp"
#include "evo/persistence/sha256.hpp"
#include "evo/server/cellular_region_host.hpp"
#include "fixtures/cellular_ecology.hpp"
#include <csignal>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <stdexcept>
#include <sys/wait.h>
#include <thread>
#include <type_traits>
#include <unistd.h>
void run_population_publication_tests();
namespace {
using namespace evo;
using namespace evo::server;
using namespace evo::persistence;
using namespace evo::fixture;
using namespace std::chrono_literals;
template <typename T, typename E> T take(std::expected<T, E> value, const char* where) {
if (!value) {
std::string message{where};
if constexpr (requires { value.error().cause.sqlstate; })
message += " SQLSTATE=" + std::string(value.error().cause.sqlstate.data(), 5);
if constexpr (requires { value.error().store.cause.sqlstate; })
message += " SQLSTATE=" + std::string(value.error().store.cause.sqlstate.data(), 5);
throw std::runtime_error(message);
}
if constexpr (!std::is_void_v<T>)
return std::move(*value);
}
template <typename T> T take(std::optional<T> value, const char* where) {
if (!value.has_value())
throw std::runtime_error(where);
return std::move(*value);
}
std::string environment(const char* name) {
const auto* value = std::getenv(name);
require(value != nullptr, "missing private test environment");
return value;
}
std::unique_ptr<Postgres> connection(bool owner = false) {
return take(Postgres::connect({environment("PGHOST"),
{},
environment("PGPORT"),
environment("PGDATABASE"),
environment(owner ? "PGUSER" : "EVO_PG_RUNTIME_USER"),
{},
{}},
5s),
"population connection");
}
Uuid identity(unsigned number) {
Uuid id{};
id[0] = 0xDA;
id[1] = 0x12;
id[14] = static_cast<std::uint8_t>(number >> 8U);
id[15] = static_cast<std::uint8_t>(number);
return id;
}
std::string hexadecimal(std::span<const std::uint8_t> bytes, bool prefix = true) {
std::string out = prefix ? "\\x" : "";
constexpr char digits[] = "0123456789abcdef";
for (const auto b : bytes) {
out.push_back(digits[b >> 4U]);
out.push_back(digits[b & 15U]);
}
return out;
}
struct Fixture {
RegionKey key{30201, 1};
std::unique_ptr<Postgres> owner = connection(true), db = connection();
std::unique_ptr<FilesystemObjectStore> objects;
LeaseGrant lease;
Sha256Digest build{};
CommittedCheckpoint head;
std::unique_ptr<CellularLives> raw;
std::unique_ptr<CellularPopulation> population;
unsigned next_id = 1;
Uuid id() {
return identity(next_id++);
}
CellularBatchHeader header(std::uint64_t count) const {
return {key.world,
key.region,
1,
head.head.commit,
head.head.digest,
head.head.end_tick,
head.head.end_tick + count};
}
};
void funded_source(Fixture& f) {
f.build.fill(0xDA);
const std::array<std::string, 1> build{hexadecimal(f.build)};
take(f.owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES($1::bytea) "
"ON CONFLICT DO NOTHING",
build, 5s),
"retain test build");
take(f.owner->query("INSERT INTO evolution.life_allocators VALUES(30201,100)", {}, 5s),
"test allocator");
f.objects = take(
FilesystemObjectStore::open(environment("PGHOST"), f.key, max_cellular_population_bytes),
"population object namespace");
f.raw = opening(30001, true, 4, false);
f.head =
take(provision_cellular_region(*f.owner, *f.objects, f.key, 1, *f.raw, f.id(), f.build, 5s),
"empty cellular genesis");
f.lease =
take(acquire_region_lease(*f.db, f.key, f.build, 60000ms, 5s), "population test lease");
CellularBatch birth{f.header(1), {{}}};
for (std::uint8_t index = 1; index <= 4; ++index) {
Uuid account{};
account.back() = index;
const auto control =
take(claim_account_control(*f.db, f.key, f.lease, account, 1, index, 60000ms, 5s),
"founder account control");
const auto reserved = take(
reserve_primitive_life(*f.db, f.key, f.lease, account, control.generation, 1, 1, 5s),
"funded founder reservation");
birth.ticks.front().births.push_back({account, 1, control.generation, reserved.identity});
}
f.raw = take(replay_cellular_batch(*f.raw, birth), "funded founder replay");
f.head = take(publish_cellular_batch(*f.db, *f.objects, f.lease, f.head, birth, *f.raw, f.id(),
f.build, 5s),
"funded founder publication")
.committed;
while (f.raw->next_bud_sequence() == 1 && f.raw->tick() < 20000) {
CellularBatch batch{f.header(1), {}};
for (unsigned tick = 0; tick < 64; ++tick) {
auto intents =
take(wildlife_intents(*f.raw, f.raw->tick() + 1), "funded source wildlife");
for (const auto& life : f.raw->lives()) {
if (life.account == LifeAccount{})
continue;
CellularLifeIntent intent{life.identity.life, {}};
intent.intent.bud = (f.raw->tick() + life.identity.life) % 32 == 0;
intents.push_back(intent);
}
std::ranges::sort(intents, {}, &CellularLifeIntent::life_id);
take(f.raw->advance_tick(intents), "funded source biology");
batch.ticks.push_back({intents, {}, {}});
if (f.raw->next_bud_sequence() > 1)
break;
}
batch.header.end_tick = f.raw->tick();
f.head = take(publish_cellular_batch(*f.db, *f.objects, f.lease, f.head, batch, *f.raw,
f.id(), f.build, 5s),
"funded source batch")
.committed;
take(renew_region_lease(*f.db, f.key, f.lease, 60000ms, 5s), "source lease renewal");
}
require(std::ranges::any_of(f.raw->lives(),
[](const auto& life) { return life.account == LifeAccount{}; }),
"durable fixture has no funded player-derived wildlife");
}
CellularPopulationExecution unattended(Fixture& f) {
auto working = restore(f.population->state());
CellularBatch batch{f.header(64), {}};
for (unsigned tick = 0; tick < 64; ++tick) {
auto intents = take(wildlife_intents(*working, working->tick() + 1), "unattended wildlife");
for (const auto& life : working->lives()) {
if (life.account == LifeAccount{})
continue;
CellularLifeIntent frozen{life.identity.life, {}};
frozen.intent.frozen = true;
intents.push_back(frozen);
}
std::ranges::sort(intents, {}, &CellularLifeIntent::life_id);
take(working->advance_tick(intents), "unattended fixture step");
batch.ticks.push_back({intents, {}, {}});
}
return take(prepare_population_batch(*f.population, std::move(batch)),
"population recorded interval");
}
void recover(Fixture& f) {
const std::array<Sha256Digest, 1> builds{f.build};
auto db = connection();
auto recovered =
take(recover_population_checkpoint(*db, *f.objects, f.key, f.lease, builds, 5s),
"population durable recovery");
f.head = std::move(recovered.committed);
f.population = std::move(recovered.state);
}
void conversions_and_retries(Fixture& f) {
const auto biology = f.raw->snapshot();
Uuid account{};
account.back() = 1;
const auto input =
encode_cellular_mutation_input({account, 9991, f.head.head.end_tick + 1, {100, 1, 1, 1}});
take(f.db->query("BEGIN", {}, 5s), "reservation guard transaction");
take(reserve_cellular_mutation(*f.db, f.key, f.lease, account, 1, 9991, input, 5s),
"reserve pending player choice");
const auto blocked = migrate_cellular_to_population(*f.db, *f.objects, f.lease, f.head, f.id(),
f.build, {true, 1200, 1800}, 5s);
require(!blocked && std::string(blocked.error().store.cause.sqlstate.data(), 5) == "EVL18",
"population entry stranded a reserved player choice");
take(f.db->query("ROLLBACK", {}, 5s), "rollback guard fixture");
f.head = take(migrate_cellular_to_population(*f.db, *f.objects, f.lease, f.head, f.id(),
f.build, {true, 1200, 1800}, 5s),
"initial population transition");
recover(f);
require(f.population->state().snapshot() == biology && f.population->members().empty(),
"transition changed biology");
const auto refused =
reserve_cellular_mutation(*f.db, f.key, f.lease, account, 1, 9991, input, 5s);
require(!refused && std::string(refused.error().cause.sqlstate.data(), 5) == "EVL06",
"population profile admitted a player mutation reservation");
const auto wildlife = std::ranges::find_if(f.population->state().lives(), [](const auto& life) {
return life.account == LifeAccount{};
});
require(wildlife != f.population->state().lives().end(), "missing durable descendant");
const auto genome = wildlife->identity.genome;
auto conversion =
take(prepare_population_conversion(*f.population, f.header(0), {genome, true}),
"collapse sample");
auto bad = conversion.batch;
++bad.boundaries.front().sequence;
require(!publish_population_batch(*f.db, *f.objects, f.lease, f.head, bad, *conversion.state,
f.id(), f.build, 5s),
"altered sample published");
const auto commit = f.id();
f.head = take(publish_population_batch(*f.db, *f.objects, f.lease, f.head, conversion.batch,
*conversion.state, commit, f.build, 5s),
"durable collapse");
const PopulationPreparedCommit prepared{
f.key, commit, f.head.manifest,
take(encode_population_batch(conversion.batch), "prepared trace")};
require(take(retry_population_prepared(*f.db, prepared, 5s), "idempotent retry").head ==
f.head.head,
"retry advanced head");
require(take(resolve_population_prepared(*f.db, prepared, 5s), "read-only resolve").status ==
Resolution::committed,
"commit unresolved");
auto changed = prepared;
auto changed_manifest = take(decode_manifest(changed.manifest), "conflict manifest");
changed_manifest.payload_sha256[0] ^= 1;
changed.manifest = take(encode_manifest(changed_manifest), "conflict encoding");
require(take(resolve_population_prepared(*f.db, changed, 5s), "conflicting resolve").status ==
Resolution::conflict,
"changed commit was accepted");
require(!publish_region_checkpoint(*f.db, f.head.manifest, {}, 5s),
"generic publisher bypassed profile gate");
const auto expected = conversion.state->snapshot();
recover(f);
require(f.population->snapshot() == expected && !f.population->members().empty(),
"committed sample not recovered");
require(f.population->state().snapshot() == biology, "collapse healed/aged/moved biology");
for (unsigned oscillation = 0; oscillation < 8; ++oscillation) {
const bool collapse = oscillation % 2 != 0;
auto next =
take(prepare_population_conversion(*f.population, f.header(0), {genome, collapse}),
"conversion oscillation");
f.head = take(publish_population_batch(*f.db, *f.objects, f.lease, f.head, next.batch,
*next.state, f.id(), f.build, 5s),
"publish oscillation");
recover(f);
require(f.population->state().snapshot() == biology,
"durable conversion changed exact state");
}
}
void process_loss(Fixture& f, int point) {
auto next = unattended(f);
const auto predecessor = f.head.head;
const auto expected = next.state->snapshot();
const auto commit = f.id();
int channel[2]{};
require(::pipe(channel) == 0, "process acknowledgement pipe");
const auto child = ::fork();
require(child >= 0, "population fork");
if (child == 0) {
::close(channel[0]);
try {
auto db = connection();
PublishHooks hooks;
if (point == 0)
hooks.before_transaction = [] { ::kill(::getpid(), SIGKILL); };
const auto published =
publish_population_batch(*db, *f.objects, f.lease, f.head, next.batch, *next.state,
commit, f.build, 5s, hooks);
if (!published)
::_exit(20);
if (point == 2) {
const char ack = 'A';
if (::write(channel[1], &ack, 1) != 1)
::_exit(21);
}
::kill(::getpid(), SIGKILL);
} catch (...) {
::_exit(22);
}
::_exit(23);
}
::close(channel[1]);
char ack{};
const auto acknowledged = ::read(channel[0], &ack, 1);
::close(channel[0]);
int status{};
require(::waitpid(child, &status, 0) == child && WIFSIGNALED(status) &&
WTERMSIG(status) == SIGKILL,
"child missed population crash boundary");
require((point == 2 && acknowledged == 1 && ack == 'A') || (point != 2 && acknowledged == 0),
"unexpected permanent acknowledgement");
recover(f);
if (point == 0)
require(f.head.head == predecessor, "uncommitted process published a head");
else
require(f.head.head.commit == commit && f.population->snapshot() == expected,
"committed process loss changed state");
}
void ambiguous_publication(Fixture& f, bool terminate) {
auto next = unattended(f);
const auto expected = next.state->snapshot();
auto locker = connection(true);
take(locker->query("BEGIN", {}, 5s), "population lease row transaction");
const std::array<std::string, 2> key{std::to_string(f.key.world), std::to_string(f.key.region)};
take(locker->query("SELECT 1 FROM evolution.region_leases WHERE world_id=$1::evolution.u64 "
"AND region_id=$2::evolution.u64 FOR UPDATE",
key, 5s),
"hold population publication");
auto timed = connection();
auto unknown = publish_population_batch(*timed, *f.objects, f.lease, f.head, next.batch,
*next.state, f.id(), f.build, 300ms);
require(!unknown && unknown.error().kind == PublicationError::unknown,
"population publication failed to retain ambiguous request");
if (terminate) {
const std::array<std::string, 1> user{environment("EVO_PG_RUNTIME_USER")};
take(locker->query("SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE "
"usename=$1 AND wait_event_type='Lock'",
user, 5s),
"terminate uncommitted population writer");
}
take(locker->query("ROLLBACK", {}, 5s), "release population publication");
auto resolver = connection();
bool resolved = false;
for (unsigned attempt = 0; attempt < 200; ++attempt) {
auto result = take(resolve_population_prepared(*resolver, unknown.error().prepared, 5s),
"resolve ambiguous population publication");
if (result.status == (terminate ? Resolution::absent : Resolution::committed)) {
resolved = true;
break;
}
std::this_thread::sleep_for(25ms);
}
require(resolved, "ambiguous population publication did not resolve");
f.head = take(retry_population_prepared(*resolver, unknown.error().prepared, 5s),
"retry exact population request");
recover(f);
require(f.population->snapshot() == expected, "ambiguous publication changed retained sample");
}
void isolation_and_reverse(Fixture& f) {
auto interval = unattended(f);
const auto old_lease = f.lease;
take(release_region_lease(*f.db, f.key, f.lease, 5s), "release old authority");
auto new_db = connection();
f.lease = take(acquire_region_lease(*new_db, f.key, f.build, 60000ms, 5s),
"new population authority");
require(f.lease.epoch > old_lease.epoch, "authority epoch did not advance");
const auto old_head = f.head.head;
auto stale = publish_population_batch(*f.db, *f.objects, old_lease, f.head, interval.batch,
*interval.state, f.id(), f.build, 5s);
require(!stale && stale.error().store.kind == LeaseStoreError::fenced,
"stale population writer published");
recover(f);
require(f.head.head == old_head, "fenced writer changed head");
const auto expected = f.population->state().snapshot();
f.head = take(
materialize_population_profile(*new_db, *f.objects, f.lease, f.head, f.id(), f.build, 5s),
"return to cellular profile");
const std::array<Sha256Digest, 1> builds{f.build};
auto recovered =
take(recover_cellular_checkpoint(*new_db, *f.objects, f.key, f.lease, builds, 5s),
"cellular recovery after materialization");
require(recovered.state->snapshot() == expected &&
recovered.manifest.profile == CheckpointProfile::cellular_lives_v1,
"reverse transition changed biology or time");
f.raw = std::move(recovered.state);
}
void missing_and_corrupt_objects(Fixture& f) {
const auto manifest = take(decode_manifest(f.head.manifest), "object test manifest");
const auto path = f.objects->directory() / hexadecimal(manifest.payload_sha256, false);
const auto backup = path.string() + ".population-test";
const std::array<Sha256Digest, 1> builds{f.build};
std::filesystem::rename(path, backup);
auto missing = recover_population_checkpoint(*f.db, *f.objects, f.key, f.lease, builds, 5s);
std::filesystem::rename(backup, path);
require(!missing && missing.error().kind == RecoveryError::missing_payload,
"missing population payload did not fail closed");
std::filesystem::rename(path, backup);
{
std::ofstream corrupt(path, std::ios::binary);
corrupt << 'X';
}
auto corrupt = recover_population_checkpoint(*f.db, *f.objects, f.key, f.lease, builds, 5s);
std::filesystem::remove(path);
std::filesystem::rename(backup, path);
require(!corrupt && corrupt.error().kind == RecoveryError::corrupt_payload,
"corrupt population payload did not fail closed");
recover(f);
}
void host_ownership_and_admission(Fixture& f) {
take(release_region_lease(*f.db, f.key, f.lease, 5s), "release fixture host authority");
const auto make_host = [&](bool enabled) {
auto objects = take(FilesystemObjectStore::open(environment("PGHOST"), f.key,
max_cellular_population_bytes),
"host objects");
CellularHostConfig config{f.key, 1, {}, f.build, {f.build}};
if (enabled)
config.population_policy = CellularTierPolicy{true, 1200, 1800};
return take(CellularRegionHost::create(
std::move(config),
[] {
return Postgres::connect({environment("PGHOST"),
{},
environment("PGPORT"),
environment("PGDATABASE"),
environment("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
},
std::move(objects)),
"population host");
};
auto host = make_host(false);
require(host->step().ready && !host->population_mode(), "raw host recovery");
require(!host->set_population_mode(true), "default host enabled population entry");
host->drain();
host = make_host(true);
require(host->step().ready, "opt-in host recovery");
const auto before = host->state()->snapshot();
const auto tick = host->state()->tick();
take(host->set_population_mode(true), "host population entry");
require(host->population_mode() && host->state()->snapshot() == before,
"host entry changed biology");
auto population =
take(CellularPopulation::create(
take(CellularLives::restore(before, f.key.world, f.key.region, 1, tick),
"host reference restore"),
{true, 1200, 1800}),
"host reference population");
f.head = take(host->committed(), "host population head");
auto next = unattended(f); // uses the same deterministic frozen/wildlife input contract.
// The fixture's old envelope may have a different membership history; biology is shared.
auto expected =
take(prepare_population_batch(*population, next.batch.biology), "host reference batch");
take(host->publish(next.batch.biology), "host population publication");
require(host->population_mode() &&
host->state()->snapshot() == expected.state->state().snapshot(),
"host population continuation differs");
const auto committed = take(host->committed(), "host continued head");
const auto continued = host->state()->snapshot();
host->drain();
host = make_host(false);
require(host->step().ready && host->population_mode() &&
take(host->committed(), "host recovered head").head == committed.head &&
host->state()->snapshot() == continued,
"restarted host failed to recover population head");
Uuid account{};
account.back() = 1;
// A returning player's operation completes the durable reverse transition before lookup.
[[maybe_unused]] const auto queried = host->query_primitive_life(account, 1, 1);
require(!host->population_mode() && host->state()->snapshot() == continued &&
host->state()->tick() == tick + 64,
"player operation did not materialize first");
host->drain();
}
} // namespace
void run_population_publication_tests() {
Fixture fixture;
funded_source(fixture);
conversions_and_retries(fixture);
ambiguous_publication(fixture, false);
ambiguous_publication(fixture, true);
process_loss(fixture, 0);
process_loss(fixture, 1);
process_loss(fixture, 2);
missing_and_corrupt_objects(fixture);
isolation_and_reverse(fixture);
host_ownership_and_admission(fixture);
std::puts("population publication, exact recovery, process loss and fencing passed");
}
+6
View File
@@ -9,6 +9,7 @@ void run_account_control_store_tests();
void run_life_reservation_store_tests();
void run_primitive_publication_tests();
void run_cellular_publication_tests();
void run_population_publication_tests();
void run_probe_handoff_store_tests();
void run_region_action_tests();
void run_region_checkpoint_store_tests();
@@ -125,6 +126,10 @@ void run() {
} // namespace
int main(int argc, char** argv) {
try {
if (argc == 2 && std::string_view(argv[1]) == "--population-only") {
run_population_publication_tests();
return 0;
}
if (argc == 2 && std::string_view(argv[1]) == "--life-reservations-only") {
run_life_reservation_store_tests();
run_primitive_publication_tests();
@@ -140,6 +145,7 @@ int main(int argc, char** argv) {
run_life_reservation_store_tests();
run_primitive_publication_tests();
run_cellular_publication_tests();
run_population_publication_tests();
run_probe_handoff_store_tests();
run_region_action_tests();
std::puts("region lease fencing integration passed");
+15 -1
View File
@@ -196,6 +196,20 @@ void upgrade_across_migration_and_barrier() {
" -v migration_sha_28=$(s 0028_cellular_v3_trace_bounds.sql)"
" -v migration_sha_29=$(s 0029_cellular_mutation_reservations.sql)"
" -v migration_sha_30=$(s 0030_cellular_birth_publication_binding.sql)"
" -v migration_sha_31=$(s 0031_fix_cellular_birth_publication_record.sql)"
" -v migration_sha_32=$(s 0032_fix_cellular_v3_manifest_normalization.sql)"
" -v migration_sha_33=$(s 0033_fix_cellular_action_tick_offset.sql)"
" -v migration_sha_34=$(s 0034_cellular_v4_engulf_bundle.sql)"
" -v migration_sha_35=$(s 0035_cellular_mutation_publication.sql)"
" -v migration_sha_36=$(s 0036_cellular_v5_budding_bundle.sql)"
" -v migration_sha_37=$(s 0037_cellular_life_endings.sql)"
" -v migration_sha_38=$(s 0038_cellular_v6_presence_bundle.sql)"
" -v migration_sha_39=$(s 0039_account_identities.sql)"
" -v migration_sha_40=$(s 0040_cellular_mutation_decline.sql)"
" -v migration_sha_41=$(s 0041_cellular_v7_balance_bundle.sql)"
" -v migration_sha_42=$(s 0042_cellular_v8_reproduction_bundle.sql)"
" -v migration_sha_43=$(s 0043_cellular_v9_foraging_bundle.sql)"
" -v migration_sha_44=$(s 0044_exact_population_publication.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");
@@ -212,7 +226,7 @@ void upgrade_across_migration_and_barrier() {
" EVO_PG_RUNTIME_ROLE=evo_runtime_test bash \"$EVO_SOURCE_ROOT/"
"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");
"25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44");
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 = "
+12 -5
View File
@@ -2,6 +2,7 @@
set -euo pipefail
# Usage: postgres-check.sh [--full|--sanitizer|--suite-only] <evo-postgres-tests>
# postgres-check.sh --life-reservations-only [<evo-postgres-tests>]
# postgres-check.sh --population-only <evo-postgres-tests>
# --full (default) is the complete qualification: the C++ suite, the backup, DR and
# upgrade process checks, then the SQL-only migration, permission and checksum checks.
# --sanitizer keeps everything that runs the binaries built beside the test binary
@@ -11,6 +12,7 @@ set -euo pipefail
root="$(cd "$(dirname "$0")/../.." && pwd)"
mode=full
case "${1:-}" in
--population-only) mode=population; shift ;;
--full) shift ;;
--sanitizer) mode=sanitizer; shift ;;
--suite-only) mode=suite-only; shift ;;
@@ -56,6 +58,11 @@ if [ "$mode" = life-reservations ]; then
bash "$root/tools/ci/life-reservations-concurrency.sh"
exit 0
fi
if [ "$mode" = population ]; then
phase population
"$1" --population-only
exit 0
fi
# M7.9 clone target: a separate database with its own runtime group and login,
# so a clone shares neither the source's database nor its runtime credentials.
psql -X -v ON_ERROR_STOP=1 -c 'CREATE ROLE evo_clone_runtime NOLOGIN' -c 'CREATE ROLE evo_clone_login LOGIN IN ROLE evo_clone_runtime'
@@ -122,7 +129,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
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
# 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%% *}"
@@ -143,7 +150,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")" = 43: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
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) || ':' || string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 44: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
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.
@@ -197,7 +204,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
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
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
@@ -250,9 +257,9 @@ expect_audit_failure 'REVOKE EXECUTE ON FUNCTION evolution.claim_account_control
bash "$root/tools/migrate-postgres.sh" # Restored configuration passes the audit again.
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=44 WHERE version=43'
psql -X -v ON_ERROR_STOP=1 -c 'UPDATE evolution.schema_migrations SET version=45 WHERE version=44'
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=43 WHERE version=44"
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET version=44 WHERE version=45"
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"
+3
View File
@@ -98,6 +98,8 @@ digest_42="$(sha256sum "$root/migrations/0042_cellular_v8_reproduction_bundle.sq
digest_42="${digest_42%% *}"
digest_43="$(sha256sum "$root/migrations/0043_cellular_v9_foraging_bundle.sql")"
digest_43="${digest_43%% *}"
digest_44="$(sha256sum "$root/migrations/0044_exact_population_publication.sql")"
digest_44="${digest_44%% *}"
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" \
@@ -134,5 +136,6 @@ psql -X --no-password --set=ON_ERROR_STOP=1 --set="migration_sha=$digest" \
--set="migration_sha_41=$digest_41" \
--set="migration_sha_42=$digest_42" \
--set="migration_sha_43=$digest_43" \
--set="migration_sha_44=$digest_44" \
--set="runtime_role=$runtime_role" \
--file="$root/migrations/apply.sql"