Files
aevolution/tests/cellular_publication_tests.cpp
T
dingoandClaude Opus 5.5 1bbac48543 Publish mutation choices atomically with their checkpoint
ADR-0121, schema v35. A checkpoint whose trace carries mutation
selections publishes with its canonical mutation block and one result
byte per choice. SQL checks the block's order, matches each record to
one reserved choice of this region and to its trace selection (tick,
life, offer, operator, successor identity), binds it to the commit with
its result, refuses a choice already bound elsewhere and checks exact
retries. The four-argument publisher becomes an internal helper behind
a wrapper that refuses traces with selections.

C++ publication takes the results from its own replay rather than a
caller, prepared commits carry block and results through retry and
resolution, and recovery rebuilds the bound choices and requires the
replay's results to match. A PostgreSQL test feeds a v4 cell to its
first offer, publishes a reserved choice, recovers it and restarts a
host. Host and session admission follow in 11.4c-2.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-13 19:23:39 -04:00

637 lines
30 KiB
C++

// Profile-4 publication and recovery against the migration-backed PostgreSQL adapter.
#include "evo/persistence/account_control_store.hpp"
#include "evo/persistence/checkpoint_store.hpp"
#include "evo/persistence/life_reservation_store.hpp"
#include "evo/persistence/sha256.hpp"
#include "evo/server/cellular_region_host.hpp"
#include <cstdlib>
#include <optional>
#include <source_location>
#include <stdexcept>
void run_cellular_publication_tests();
namespace {
using namespace evo::persistence;
using namespace evo::server;
using namespace std::chrono_literals;
void check(bool value, std::source_location at = std::source_location::current()) {
if (!value)
throw std::runtime_error("cellular publication test line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
template <typename T> const T& checked_value(const std::optional<T>& value) {
if (!value.has_value())
throw std::runtime_error("cellular publication test expected an optional value");
return *value;
}
template <typename T, typename E> const T& checked_value(const std::expected<T, E>& value) {
if (!value.has_value())
throw std::runtime_error("cellular publication test expected a successful result");
return *value;
}
std::string env(const char* name) {
const auto* value = std::getenv(name);
if (!value)
throw std::runtime_error("missing PostgreSQL test environment");
return value;
}
auto connect_as(const std::string& user) {
auto db =
Postgres::connect({env("PGHOST"), {}, env("PGPORT"), env("PGDATABASE"), user, {}, {}}, 5s);
CHECK(db);
return std::move(*db);
}
template <std::size_t N> std::array<std::uint8_t, N> filled(std::uint8_t value) {
std::array<std::uint8_t, N> out{};
out.fill(value);
return out;
}
std::string hex(std::span<const std::uint8_t> bytes) {
constexpr char digits[] = "0123456789abcdef";
std::string out = "\\x";
for (const auto byte : bytes) {
out.push_back(digits[byte >> 4U]);
out.push_back(digits[byte & 15U]);
}
return out;
}
void refresh_cellular_checksum(std::vector<std::uint8_t>& bytes) {
std::uint64_t value = 14695981039346656037ULL;
for (const auto byte : std::span{bytes}.first(bytes.size() - 8))
value = (value ^ byte) * 1099511628211ULL;
for (unsigned index = 0; index < 8; ++index)
bytes[bytes.size() - 8 + index] = static_cast<std::uint8_t>(value >> (index * 8U));
}
} // namespace
namespace {
void cellular_birth_publication_is_durable() {
using namespace evo::biology;
constexpr RegionKey key{9758, 1};
auto owner = connect_as(env("PGUSER"));
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto build = filled<32>(0xD9);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('d9',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowed = primitive_endowment();
CHECK(endowed);
auto funding = endowed->body;
funding.energy.value = endowed->reserve.energy.value + endowed->construction.value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
auto habitat = CellularHabitat::create({key.world, key.region, 1, 1'000, 1'000, {}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
CHECK(opening && (*opening)->lives().empty());
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
const auto genesis = provision_cellular_region(*owner, **objects, key, 1, **opening,
filled<16>(0x30), build, 5s);
CHECK(genesis);
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9758,1000)", {}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
CellularHostConfig config{key, 1, {}, build, {build}};
auto made = CellularRegionHost::create(config, connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto authority = host->authority();
CHECK(authority);
const auto& authority_value = checked_value(authority);
const auto committed = host->committed();
CHECK(committed);
const auto& committed_value = checked_value(committed);
const auto account = filled<16>(0x47);
const auto control =
claim_account_control(*runtime, key, authority_value, account, 1, 1, 20'000ms, 5s);
CHECK(control);
const auto requested = host->create_primitive_life(account, control->generation, 7);
CHECK(requested.result == evo::network::PrimitiveLifeResult::pending &&
requested.life_identity != 0 && host->queued_births().size() == 1);
const auto retried = host->create_primitive_life(account, control->generation, 7);
CHECK(retried == requested && host->queued_births().size() == 1);
const auto reservation = host->queued_births().front();
CellularBatch batch;
const auto predecessor_digest = sha256(committed_value.manifest);
CHECK(predecessor_digest);
batch.header = {
key.world, key.region, 1, committed_value.head.commit, checked_value(predecessor_digest),
0, 1};
CellularTickIntents tick;
tick.births.push_back(reservation);
batch.ticks.push_back(tick);
auto candidate = replay_cellular_batch(*host->state(), batch);
CHECK(candidate && (*candidate)->lives().size() == 1 &&
(*candidate)->lives()[0].identity.life == reservation.identity);
auto published = host->publish(batch);
if (!published) {
const auto& failure = published.error();
auto message = "cellular host publish failed, error=" +
std::to_string(static_cast<unsigned>(failure.kind));
if (failure.publication)
message +=
", publication=" + std::to_string(static_cast<unsigned>(*failure.publication));
if (failure.store) {
message += ", store=" + std::to_string(static_cast<unsigned>(failure.store->kind));
const auto& state = failure.store->cause.sqlstate;
if (state[0] != '\0')
message += ", sqlstate=" + std::string(state.data(), 5);
}
if (failure.object)
message += ", object=" + std::to_string(static_cast<unsigned>(*failure.object));
throw std::runtime_error(message);
}
CHECK(published->committed.head.sequence == 1);
CHECK(host->state()->snapshot() == (*candidate)->snapshot());
CHECK(host->queued_births().empty());
const auto host_outcome = host->query_primitive_life(account, control->generation, 7);
CHECK(host_outcome.result == evo::network::PrimitiveLifeResult::born &&
host_outcome.life_identity == reservation.identity && host_outcome.commit_sequence == 1);
const auto outcome =
query_primitive_life(*runtime, key, authority_value, account, control->generation, 7, 5s);
CHECK(outcome && outcome.value().has_value());
const auto& outcome_value = checked_value(outcome.value());
CHECK(outcome_value.published.has_value());
const auto& published_value = checked_value(outcome_value.published);
CHECK(published_value.identity == reservation.identity && published_value.born == 1);
host->drain();
host.reset();
auto restarted_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(restarted_objects);
auto restarted_made =
CellularRegionHost::create(config, connect, std::move(*restarted_objects));
CHECK(restarted_made);
auto restarted = std::move(*restarted_made);
CHECK(restarted->step().ready && restarted->state()->tick() == 1 &&
restarted->state()->snapshot() == (*candidate)->snapshot());
restarted->drain();
}
void cellular_profile_migration_is_durable_and_recovers_without_a_tick() {
using namespace evo::biology;
constexpr RegionKey key{9759, 1};
auto owner = connect_as(env("PGUSER"));
const auto build = filled<32>(0xD9);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('d9',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowment = primitive_endowment();
CHECK(endowment);
auto funding = endowment->body;
funding.energy.value += endowment->reserve.energy.value + endowment->construction.value;
for (std::size_t index = 0; index < funding.matter.size(); ++index)
funding.matter[index].value += endowment->reserve.matter[index].value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
auto habitat = CellularHabitat::create({key.world, key.region, 1, 1'000, 1'000, {}});
CHECK(habitat);
auto current =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
CHECK(current && (*current)->lives().empty());
auto legacy_bytes = (*current)->snapshot();
constexpr std::uint64_t legacy_magic = 0x3130564C43564541ULL;
for (unsigned index = 0; index < 8; ++index)
legacy_bytes[index] = static_cast<std::uint8_t>(legacy_magic >> (index * 8U));
legacy_bytes[8] = 1;
legacy_bytes[9] = legacy_bytes[10] = legacy_bytes[11] = 0;
legacy_bytes[12] = 1;
legacy_bytes[13] = legacy_bytes[14] = legacy_bytes[15] = 0;
refresh_cellular_checksum(legacy_bytes);
auto legacy = CellularLives::restore(legacy_bytes, key.world, key.region, 1, 0);
CHECK(legacy && (*legacy)->format_version() == cellular_lives_legacy_format);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
auto genesis_commit = filled<16>(0x50);
genesis_commit[0] = 0x51;
auto provisioned =
provision_cellular_region(*owner, **objects, key, 1, **legacy, genesis_commit, build, 5s);
CHECK(provisioned);
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9759,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
CellularHostConfig config{key, 1, {}, build, {build}};
auto migration_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(migration_objects);
auto made = CellularRegionHost::create(config, connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto authority = host->authority();
CHECK(authority);
const auto& authority_value = checked_value(authority);
const auto predecessor = host->committed();
CHECK(predecessor);
const auto& predecessor_value = checked_value(predecessor);
CHECK(predecessor_value.head.sequence == 0);
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto account = filled<16>(0x5A);
const auto control =
claim_account_control(*runtime, key, authority_value, account, 1, 1, 20'000ms, 5s);
CHECK(control);
const auto requested = host->create_primitive_life(account, control->generation, 9);
CHECK(requested.result == evo::network::PrimitiveLifeResult::pending &&
requested.life_identity != 0 && host->queued_births().size() == 1);
CellularBatch batch;
const auto predecessor_digest = sha256(predecessor_value.manifest);
CHECK(predecessor_digest);
batch.header = {
key.world, key.region, 1, predecessor_value.head.commit, checked_value(predecessor_digest),
0, 1};
CellularTickIntents tick;
tick.births.push_back(host->queued_births().front());
batch.ticks.push_back(tick);
const auto published = host->publish(batch);
CHECK(published && published->committed.head.sequence == 1);
CHECK(host->state()->lives().size() == 1 &&
host->state()->lives().front().identity.born.value == 1);
auto migrated =
migrate_cellular_profile_to_v2(*owner, **migration_objects, authority_value,
published->committed, filled<16>(0x51), build, 5s);
CHECK(migrated && migrated->head.sequence == 2 && migrated->head.end_tick == 1);
CHECK(
retry_cellular_profile_migration(*owner, {key, filled<16>(0x51), migrated->manifest}, 5s));
auto revision_migrated = migrate_cellular_profile_to_v3(
*owner, **migration_objects, authority_value, *migrated, filled<16>(0x52), build, 5s);
CHECK(revision_migrated && revision_migrated->head.sequence == 3 &&
revision_migrated->head.end_tick == 1);
CHECK(retry_cellular_profile_migration(
*owner, {key, filled<16>(0x52), revision_migrated->manifest}, 5s));
host->drain();
host.reset();
auto recovery_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(recovery_objects);
const auto target_manifest = decode_manifest(revision_migrated->manifest);
CHECK(target_manifest);
const auto target_payload =
(*recovery_objects)->get({target_manifest->payload_sha256, target_manifest->payload_bytes});
CHECK(target_payload);
auto restarted_made = CellularRegionHost::create(config, connect, std::move(*recovery_objects));
CHECK(restarted_made);
auto restarted = std::move(*restarted_made);
CHECK(restarted->step().ready);
const auto restarted_committed = restarted->committed();
CHECK(restarted_committed);
const auto& restarted_committed_value = checked_value(restarted_committed);
CHECK(restarted_committed_value.head.sequence == 3 &&
restarted_committed_value.head.end_tick == 1 && restarted->state()->tick() == 1 &&
restarted->state()->format_version() == cellular_lives_revision_format &&
restarted->state()->snapshot() == *target_payload);
restarted->drain();
}
// ADR-0121 (schema v35): a reserved mutation choice publishes with its checkpoint, the
// bound result is the replay's, recovery reloads choice and result, and a restarted host
// resumes at the same state.
void cellular_mutation_publication_binds_results() {
using namespace evo::biology;
constexpr RegionKey key{9764, 1};
auto owner = connect_as(env("PGUSER"));
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto build = filled<32>(0xD9);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('d9',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowed = primitive_endowment();
CHECK(endowed);
auto funding = endowed->body;
funding.energy.value = endowed->reserve.energy.value + endowed->construction.value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
// A stocked patch under the spawn site feeds the cell to its first offer.
constexpr std::uint64_t stock = 100'000'000;
auto habitat = CellularHabitat::create(
{key.world,
key.region,
1,
1'000,
1'000,
{{{0, 0}, 29, {{stock}, {{{stock}, {stock}, {stock}, {stock}}}}}}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150},
CellularLivesProfile::engulf);
CHECK(opening);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
CHECK(provision_cellular_region(*owner, **objects, key, 1, **opening, filled<16>(0x60), build,
5s));
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9764,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
CellularHostConfig config{key, 1, {}, build, {build}};
auto made = CellularRegionHost::create(config, connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto authority = checked_value(host->authority());
const auto account = filled<16>(0x64);
const auto control =
claim_account_control(*runtime, key, authority, account, 1, 1, 60'000ms, 5s);
CHECK(control);
CHECK(host->create_primitive_life(account, control->generation, 11).result ==
evo::network::PrimitiveLifeResult::pending);
// Each batch starts at the host's committed head.
const auto header = [&](std::uint64_t ticks) {
const auto& committed = checked_value(host->committed());
const auto digest = sha256(committed.manifest);
CHECK(digest);
return CellularBatchHeader{key.world,
key.region,
1,
committed.head.commit,
checked_value(digest),
host->state()->tick(),
host->state()->tick() + ticks};
};
CellularBatch birth;
birth.header = header(1);
birth.ticks.push_back({{}, {host->queued_births().front()}, {}});
CHECK(host->publish(birth));
const auto life_id = host->state()->lives().front().identity.life;
for (int round = 0; round < 4 && !host->state()->lives().front().mutation.offer; ++round) {
CHECK(host->step().ready);
CellularBatch feeding;
feeding.header = header(64);
CellularStepIntent feed{};
feed.intake_target = CellularPatchAddress{0, 0};
for (int tick = 0; tick < 64; ++tick)
feeding.ticks.push_back({{{life_id, feed}}, {}, {}});
CHECK(host->publish(feeding));
}
const auto& life = host->state()->lives().front();
CHECK(life.mutation.offer.has_value());
const auto offer = checked_value(life.mutation.offer);
CellularMutationActionRecord choice;
choice.account = account;
choice.action_id = 21;
choice.tick = host->state()->tick() + 1;
choice.input = {life_id, life.mutation.event_index, life.mutation.offer_tick,
offer.candidates.front().operator_id};
const auto reservation =
reserve_cellular_mutation(*runtime, key, authority, account, control->generation,
choice.action_id, encode_cellular_mutation_input(choice), 5s);
CHECK(reservation);
CellularBatch mutation;
mutation.header = header(1);
mutation.ticks.push_back({{{life_id, {}}},
{},
{{life_id, choice.input.event_index, choice.input.offer_tick,
reservation->successor_identity, choice.input.operator_id}}});
auto candidate = replay_cellular_batch(*host->state(), mutation);
CHECK(candidate);
auto mutation_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(mutation_objects);
const std::array choices{choice};
// Publishing without the mutation block is refused: only the block binds the choice.
CHECK(!publish_cellular_batch(*runtime, **mutation_objects, authority,
checked_value(host->committed()), mutation, **candidate,
filled<16>(0x65), build, 5s));
const auto published = publish_cellular_batch(
*runtime, **mutation_objects, authority, checked_value(host->committed()), mutation,
**candidate, filled<16>(0x65), build, 5s, {}, {}, choices);
CHECK(published && published->mutation_results.size() == 1);
const auto result = published->mutation_results.front();
// Applied exactly when the replayed life now carries the reserved successor genome.
const bool applied =
(*candidate)->lives().front().identity.genome == reservation->successor_identity;
CHECK(result == (applied ? CellularMutationResult::applied
: CellularMutationResult::insufficient_funding));
auto recovery_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(recovery_objects);
const std::array<Sha256Digest, 1> retained{build};
auto recovered =
recover_cellular_checkpoint(*runtime, **recovery_objects, key, authority, retained, 5s);
CHECK(recovered && recovered->mutation_actions == std::vector{choice} &&
recovered->mutation_results == std::vector{result} &&
recovered->state->snapshot() == (*candidate)->snapshot());
host->drain();
host.reset();
auto restarted_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(restarted_objects);
auto restarted_made =
CellularRegionHost::create(config, connect, std::move(*restarted_objects));
CHECK(restarted_made);
auto restarted = std::move(*restarted_made);
CHECK(restarted->step().ready && restarted->state()->snapshot() == (*candidate)->snapshot());
restarted->drain();
}
} // namespace
void run_cellular_publication_tests() {
cellular_birth_publication_is_durable();
cellular_profile_migration_is_durable_and_recovers_without_a_tick();
cellular_mutation_publication_binds_results();
auto owner = connect_as(env("PGUSER"));
const auto build = filled<32>(0xD9);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('d9',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
constexpr RegionKey empty_key{9757, 1};
auto empty_nursery =
PrimitiveLives::create({empty_key.world, empty_key.region, 1, 17, {}, {{0, 0}}});
CHECK(empty_nursery);
auto empty_habitat = evo::biology::CellularHabitat::create(
{empty_key.world,
empty_key.region,
1,
1'000,
1'000,
{{{0, 0}, 19, {{12'000}, {{{10}, {20}, {30}, {40}}}}}}});
CHECK(empty_habitat);
auto empty_opening = CellularLives::create(**empty_nursery, std::move(*empty_habitat),
{{1'000, 1'000}, 0, 293'150});
CHECK(empty_opening && (*empty_opening)->lives().empty());
auto empty_objects =
FilesystemObjectStore::open(env("PGHOST"), empty_key, max_cellular_lives_bytes);
CHECK(empty_objects);
const auto empty_commit = filled<16>(0x20);
auto provisioned = provision_cellular_region(*owner, **empty_objects, empty_key, 1,
**empty_opening, empty_commit, build, 5s);
CHECK(provisioned && provisioned->head.sequence == 0 && provisioned->head.end_tick == 0);
auto empty_manifest = decode_manifest(provisioned->manifest);
CHECK(empty_manifest && empty_manifest->profile == CheckpointProfile::cellular_lives_v1 &&
empty_manifest->cellular_versions == cellular_v2_versions &&
empty_manifest->payload_bytes == (*empty_opening)->snapshot().size());
auto genesis_payload =
(*empty_objects)->get({empty_manifest->payload_sha256, empty_manifest->payload_bytes});
CHECK(genesis_payload);
auto restored_genesis = restore_cellular_payload(*genesis_payload, *empty_manifest);
CHECK(restored_genesis && (*restored_genesis)->lives().empty() &&
(*restored_genesis)->nursery() == (*empty_opening)->nursery() &&
(*restored_genesis)->habitat().snapshot() == (*empty_opening)->habitat().snapshot());
auto exact_retry = provision_cellular_region(*owner, **empty_objects, empty_key, 1,
**empty_opening, empty_commit, build, 5s);
CHECK(exact_retry && exact_retry->manifest == provisioned->manifest);
CHECK(!provision_cellular_region(*owner, **empty_objects, empty_key, 1, **empty_opening,
filled<16>(0x22), build, 5s));
constexpr RegionKey key{9756, 1};
auto endowment = evo::biology::primitive_endowment();
CHECK(endowment);
auto funding = endowment->body;
funding.energy.value = endowment->reserve.energy.value + endowment->construction.value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
auto habitat =
evo::biology::CellularHabitat::create({key.world, key.region, 1, 1'000, 1'000, {}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
CHECK(opening && (*opening)->lives().empty());
const auto payload = (*opening)->snapshot();
const auto payload_digest = sha256(payload);
CHECK(payload_digest);
auto genesis = genesis_manifest(key, 1, filled<16>(0x21), 50'000, build, payload.size(),
*payload_digest, CheckpointProfile::cellular_lives_v1);
CHECK(genesis);
genesis->cellular_versions = cellular_v2_versions;
const auto genesis_bytes = encode_manifest(*genesis);
CHECK(genesis_bytes);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects && (*objects)->put(payload));
CHECK(owner->query("SELECT evolution.provision_region_checkpoint($1::bytea)",
std::array{hex(*genesis_bytes)}, 5s));
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9756,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
CellularHostConfig config{key, 1, {}, build, {build}};
auto made_host = CellularRegionHost::create(config, connect, std::move(*objects));
CHECK(made_host);
auto host = std::move(*made_host);
CHECK(host->step().ready);
const auto authority = host->authority();
CHECK(authority);
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto account = filled<16>(0x43);
const auto control =
claim_account_control(*runtime, key, checked_value(authority), account, 1, 1, 20'000ms, 5s);
CHECK(control);
const auto requested = host->create_primitive_life(account, control->generation, 7);
CHECK(requested.result == evo::network::PrimitiveLifeResult::pending &&
requested.life_identity != 0 && host->queued_births().size() == 1);
const auto committed = host->committed();
CHECK(committed);
const auto& committed_value = checked_value(committed);
CellularBatch batch;
const auto predecessor_digest = sha256(committed_value.manifest);
CHECK(predecessor_digest);
batch.header = {
key.world, key.region, 1, committed_value.head.commit, checked_value(predecessor_digest),
0, 1};
batch.ticks.resize(1);
batch.ticks.front().births.push_back(host->queued_births().front());
const auto birth_replay = replay_cellular_batch(*host->state(), batch);
CHECK(birth_replay);
const auto birth_publication = host->publish(batch);
CHECK(birth_publication && birth_publication->committed.head.sequence == 1 &&
birth_publication->committed.head.end_tick == 1 &&
host->state()->snapshot() == (**birth_replay).snapshot());
const auto action_predecessor = host->committed();
CHECK(action_predecessor);
const auto& action_predecessor_value = checked_value(action_predecessor);
const auto action_predecessor_digest = sha256(action_predecessor_value.manifest);
CHECK(action_predecessor_digest);
batch = {};
batch.header = {key.world,
key.region,
1,
action_predecessor_value.head.commit,
checked_value(action_predecessor_digest),
1,
2};
batch.ticks.resize(1);
batch.ticks.front().lives.push_back({requested.life_identity, {}});
CellularActionRecord action;
action.account = account;
action.action_id = 77;
action.input[0] = 2; // Tick 2, neutral movement, no patch target.
const std::array actions{action};
const auto replay = replay_cellular_batch(*host->state(), batch);
CHECK(replay);
auto published = host->publish(batch, actions);
CHECK(published && published->committed.head.sequence == 2 &&
published->committed.head.end_tick == 2 &&
host->state()->snapshot() == (**replay).snapshot());
CHECK(host->take_finalized_actions() == std::vector<FinalCellularAction>{{action, 2}});
host->drain();
host.reset();
auto restarted_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(restarted_objects);
auto made_restarted =
CellularRegionHost::create(config, connect, std::move(*restarted_objects));
CHECK(made_restarted);
auto restarted = std::move(*made_restarted);
CHECK(restarted->step().ready);
const auto restarted_committed = restarted->committed();
CHECK(restarted_committed);
const auto& restarted_committed_value = checked_value(restarted_committed);
CHECK(restarted->state()->tick() == 2 &&
restarted->state()->snapshot() == (**replay).snapshot() &&
restarted_committed_value.head.sequence == 2);
restarted->drain();
}