Files
aevolution/tests/cellular_publication_tests.cpp
T
dingo bb6e00ebca
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 43s
Foundation / checks (ecs) (push) Successful in 1m52s
Foundation / checks (postgres) (push) Failing after 52s
Foundation / checks (tsan) (push) Failing after 32s
Foundation / checks (network) (push) Failing after 3m4s
Foundation / checks (client) (push) Failing after 4m24s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped
Publish cellular births with durable control
2026-10-11 00:44:57 -04:00

251 lines
12 KiB
C++

// Profile-4 publication and recovery against the migration-backed PostgreSQL adapter.
#include "evo/persistence/checkpoint_store.hpp"
#include "evo/persistence/account_control_store.hpp"
#include "evo/persistence/life_reservation_store.hpp"
#include "evo/persistence/sha256.hpp"
#include "evo/server/cellular_region_host.hpp"
#include <cstdlib>
#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__))
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;
}
} // 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 account = filled<16>(0x47);
const auto control = claim_account_control(*runtime, key, *authority, account, 1, 1,
20'000ms, 5s);
CHECK(control);
const auto reservation = reserve_primitive_life(*runtime, key, *authority, account,
control->generation, 7, 1, 5s);
CHECK(reservation && reservation->refusal == LifeRefusal::none &&
reservation->region == key.region);
CellularBatch batch;
const auto predecessor_digest = sha256(host->committed()->manifest);
CHECK(predecessor_digest);
batch.header = {key.world, key.region, 1, host->committed()->head.commit,
*predecessor_digest, 0, 1};
CellularTickIntents tick;
tick.births.push_back({account, 7, control->generation, reservation->identity});
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);
CHECK(published && published->committed.head.sequence == 1 &&
host->state()->snapshot() == (*candidate)->snapshot());
const auto outcome = query_primitive_life(*runtime, key, *authority, account,
control->generation, 7, 5s);
CHECK(outcome && outcome->has_value() && (*outcome)->published &&
(*outcome)->published->identity == reservation->identity &&
(*outcome)->published->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();
}
} // namespace
void run_cellular_publication_tests() {
cellular_birth_publication_is_durable();
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->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 endowed = evo::biology::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);
LifeRequest founder;
founder.account = filled<16>(0x43);
founder.action = 7;
CHECK((*primitive)->spawn(founder, {1, 101, 201, 301, {0}}));
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().size() == 1);
const auto payload = (*opening)->snapshot();
const auto payload_digest = sha256(payload);
CHECK(payload_digest);
const auto genesis = genesis_manifest(key, 1, filled<16>(0x21), 50'000, build,
payload.size(), *payload_digest,
CheckpointProfile::cellular_lives_v1);
CHECK(genesis);
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));
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);
CellularBatch batch;
const auto predecessor_digest = sha256(host->committed()->manifest);
CHECK(predecessor_digest);
batch.header = {key.world, key.region, 1, host->committed()->head.commit,
*predecessor_digest, 0, 2};
batch.ticks.resize(2);
for (auto& tick : batch.ticks)
tick.lives.push_back({(*opening)->lives()[0].identity.life, {}});
const auto replay = replay_cellular_batch(*host->state(), batch);
CHECK(replay);
CellularActionRecord action;
action.account = founder.account;
action.action_id = 77;
action.input[0] = 1; // Tick 1, neutral movement, no patch target.
const std::array actions{action};
auto published = host->publish(batch, actions);
CHECK(published && published->committed.head.sequence == 1 &&
published->committed.head.end_tick == 2 &&
host->state()->snapshot() == (**replay).snapshot());
CHECK(host->take_finalized_actions() ==
std::vector<FinalCellularAction>{{action, 1}});
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 && restarted->state()->tick() == 2 &&
restarted->state()->snapshot() == (**replay).snapshot() &&
restarted->committed()->head.sequence == 1);
restarted->drain();
}