Files
aevolution/src/persistence/cellular_checkpoint_store.cpp
T
dingo a479ce2d95
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m59s
Foundation / checks (checks) (push) Failing after 2m10s
Foundation / checks (postgres) (push) Failing after 10m34s
Foundation / checks (network) (push) Failing after 12m19s
Foundation / checks (tsan) (push) Failing after 2m14s
Foundation / checks (client) (push) Successful in 15m7s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped
Add cellular genome revision profile migration
2026-10-11 06:13:17 -04:00

567 lines
33 KiB
C++

#include "evo/persistence/checkpoint_store.hpp"
#include "evo/persistence/sha256.hpp"
#include <algorithm>
#include <array>
#include <string>
#include <string_view>
#include <utility>
namespace evo::persistence {
namespace {
using std::chrono::milliseconds;
std::uint64_t input_tick(const server::CellularActionRecord& action) {
std::uint64_t tick{};
for (std::size_t i = 0; i < 8; ++i)
tick |= static_cast<std::uint64_t>(action.input[i]) << (i * 8U);
return tick;
}
CellularPublicationFailure failure(PublicationError kind, ObjectError object = {},
LeaseStoreFailure store = {},
CellularPreparedCommit prepared = {}) {
return {kind, store, object, std::move(prepared)};
}
CellularProfileMigrationFailure migration_failure(PublicationError kind, ObjectError object = {},
LeaseStoreFailure store = {},
CellularProfileMigrationPrepared prepared = {}) {
return {kind, store, object, std::move(prepared)};
}
std::expected<void, CellularPublicationFailure> put_verified(const FilesystemObjectStore& objects,
std::span<const std::uint8_t> bytes,
VerifiedObject expected) {
auto stored = objects.put(bytes);
if (!stored)
return std::unexpected{failure(PublicationError::upload, stored.error())};
auto readback = objects.get(*stored);
if (!readback || *stored != expected || !std::ranges::equal(*readback, bytes))
return std::unexpected{
failure(PublicationError::verify, readback ? ObjectError::corrupt : readback.error())};
return {};
}
std::expected<CommittedCheckpoint, CellularPublicationFailure>
confirm(const RegionHead& head, const CellularPreparedCommit& prepared,
const CheckpointManifest& manifest) {
const auto digest = sha256(prepared.manifest);
if (!digest || head.digest != *digest || head.sequence != manifest.sequence ||
head.commit != manifest.commit || head.end_tick != manifest.end_tick ||
head.frame != manifest.frame)
return std::unexpected{failure(PublicationError::receipt)};
return CommittedCheckpoint{head, prepared.manifest};
}
bool prepared_is_canonical(const CellularPreparedCommit& prepared,
const CheckpointManifest& manifest, const server::CellularBatch& trace) {
const auto decoded_actions = server::decode_cellular_action_block(
prepared.actions, manifest.begin_tick, manifest.end_tick);
const auto encoded_actions =
decoded_actions
? server::encode_cellular_action_block(*decoded_actions, manifest.begin_tick,
manifest.end_tick)
: std::expected<std::vector<std::uint8_t>, server::CellularActionBlockError>{
std::unexpected{server::CellularActionBlockError::format}};
const auto encoded_trace = server::encode_cellular_batch(trace);
const auto digest = sha256(prepared.trace);
return manifest.profile == CheckpointProfile::cellular_lives_v1 &&
manifest.key == prepared.key && manifest.commit == prepared.commit &&
manifest.sequence > 0 && manifest.batch.trace_bytes == prepared.trace.size() && digest &&
*digest == manifest.batch.trace_sha256 && manifest.batch.decision_count == 0 &&
manifest.batch.decisions_sha256 == Sha256Digest{} &&
trace.header.world == prepared.key.world && trace.header.region == prepared.key.region &&
trace.header.frame == manifest.frame &&
trace.header.predecessor == manifest.predecessor_commit &&
trace.header.predecessor_digest == manifest.predecessor_digest &&
trace.header.begin_tick == manifest.begin_tick &&
trace.header.end_tick == manifest.end_tick && encoded_actions &&
*encoded_actions == prepared.actions && encoded_trace &&
*encoded_trace == prepared.trace;
}
} // namespace
std::expected<CommittedCheckpoint, CellularPublicationFailure>
provision_cellular_region(Postgres& owner, const FilesystemObjectStore& objects, RegionKey key,
std::uint64_t frame, const server::CellularLives& opening, Uuid commit,
const Sha256Digest& build, milliseconds timeout) {
const auto payload = opening.snapshot();
if (opening.world() != key.world || opening.region() != key.region ||
opening.frame() != frame || opening.tick() != 0 || !opening.lives().empty() ||
!opening.corpses().empty() || opening.archive().recorded() != 0 ||
opening.archive().archived() != 0)
return std::unexpected{failure(PublicationError::candidate)};
const auto digest = sha256(payload);
if (!digest)
return std::unexpected{failure(PublicationError::digest)};
auto manifest =
genesis_manifest(key, frame, commit, biology::cellular_motion_tick_microseconds, build,
payload.size(), *digest, CheckpointProfile::cellular_lives_v1);
if (manifest && opening.format_version() == server::cellular_lives_format &&
opening.rules_version() == server::cellular_lives_rules)
manifest->cellular_versions = cellular_v2_versions;
else if (manifest && (opening.format_version() != server::cellular_lives_legacy_format ||
opening.rules_version() != 1))
return std::unexpected{failure(PublicationError::candidate)};
auto encoded = manifest ? encode_manifest(*manifest)
: std::expected<std::vector<std::uint8_t>, CheckpointError>{
std::unexpected{CheckpointError::format}};
if (!encoded || !restore_cellular_payload(payload, *manifest))
return std::unexpected{failure(PublicationError::candidate)};
if (auto stored = put_verified(objects, payload, {*digest, payload.size()}); !stored)
return std::unexpected{stored.error()};
std::string manifest_hex = "\\x";
constexpr std::string_view digits = "0123456789abcdef";
manifest_hex.reserve(2 + encoded->size() * 2);
for (const auto byte : *encoded) {
manifest_hex.push_back(digits[byte >> 4U]);
manifest_hex.push_back(digits[byte & 0x0fU]);
}
const std::array<std::string, 1> parameters{std::move(manifest_hex)};
auto inserted =
owner.query("SELECT evolution.provision_region_checkpoint($1::bytea)", parameters, timeout);
if (!inserted) {
auto existing = load_region_checkpoint(owner, key, timeout);
if (existing && existing->manifest == *encoded)
return confirm(existing->head, CellularPreparedCommit{key, commit, *encoded, {}, {}},
*manifest);
if (existing)
return std::unexpected{failure(PublicationError::rejected)};
if (existing.error().kind != LeaseStoreError::not_provisioned &&
inserted.error().kind == PgError::unknown)
return std::unexpected{failure(PublicationError::unknown, {}, existing.error())};
const bool unknown = inserted.error().kind == PgError::unknown;
return std::unexpected{failure(
unknown ? PublicationError::unknown : PublicationError::rejected, {},
{unknown ? LeaseStoreError::unknown : LeaseStoreError::store, inserted.error()})};
}
auto committed = load_region_checkpoint(owner, key, timeout);
if (!committed)
return std::unexpected{failure(PublicationError::unknown, {}, committed.error())};
CellularPreparedCommit prepared{key, commit, *encoded, {}, {}};
auto confirmed = confirm(committed->head, prepared, *manifest);
if (!confirmed)
return std::unexpected{confirmed.error()};
return *confirmed;
}
std::expected<CommittedCheckpoint, CellularProfileMigrationFailure>
retry_cellular_profile_migration(Postgres& db, const CellularProfileMigrationPrepared& prepared,
milliseconds timeout) {
const auto manifest = decode_manifest(prepared.manifest);
if (!manifest || manifest->key != prepared.key || manifest->commit != prepared.commit ||
manifest->profile != CheckpointProfile::cellular_lives_v1 ||
(manifest->cellular_versions != cellular_v2_versions &&
manifest->cellular_versions != cellular_v3_versions) ||
manifest->begin_tick != manifest->end_tick || manifest->batch != BatchDigests{})
return std::unexpected{migration_failure(PublicationError::candidate, {}, {}, prepared)};
const auto confirm_commit = [&](const RegionHead& head) {
const auto digest = sha256(prepared.manifest);
if (!digest || head.sequence != manifest->sequence || head.commit != manifest->commit ||
head.digest != *digest || head.end_tick != manifest->end_tick ||
head.frame != manifest->frame)
return std::expected<CommittedCheckpoint, CellularProfileMigrationFailure>{
std::unexpected{migration_failure(PublicationError::receipt, {}, {}, prepared)}};
return std::expected<CommittedCheckpoint, CellularProfileMigrationFailure>{
CommittedCheckpoint{head, prepared.manifest}};
};
auto published = publish_cellular_profile_migration(db, prepared.manifest, timeout);
if (published)
return confirm_commit(*published);
if (published.error().kind == LeaseStoreError::unknown) {
const auto stored = load_region_commit(db, prepared.key, manifest->sequence, timeout);
if (stored && stored->manifest == prepared.manifest)
return confirm_commit(stored->head);
if (!stored && stored.error().kind != LeaseStoreError::not_provisioned)
return std::unexpected{
migration_failure(PublicationError::unknown, {}, stored.error(), prepared)};
return std::unexpected{
migration_failure(PublicationError::unknown, {}, published.error(), prepared)};
}
return std::unexpected{
migration_failure(PublicationError::rejected, {}, published.error(), prepared)};
}
std::expected<CommittedCheckpoint, CellularProfileMigrationFailure>
migrate_cellular_profile_to_v2(Postgres& db, const FilesystemObjectStore& objects,
const LeaseGrant& lease, const CommittedCheckpoint& predecessor,
Uuid commit, const Sha256Digest& build, milliseconds timeout) {
const auto previous = decode_manifest(predecessor.manifest);
const auto previous_digest = sha256(predecessor.manifest);
if (!previous || !previous_digest ||
previous->profile != CheckpointProfile::cellular_lives_v1 ||
previous->cellular_versions != cellular_v1_versions ||
predecessor.head.digest != *previous_digest ||
predecessor.head.sequence != previous->sequence ||
predecessor.head.commit != previous->commit ||
predecessor.head.end_tick != previous->end_tick || lease.frame != previous->frame ||
previous->sequence == 0 || previous->end_tick == 0)
return std::unexpected{migration_failure(PublicationError::candidate)};
auto source_payload = objects.get({previous->payload_sha256, previous->payload_bytes});
if (!source_payload)
return std::unexpected{
migration_failure(PublicationError::predecessor, source_payload.error())};
const auto source_digest = sha256(*source_payload);
if (!source_digest || *source_digest != previous->payload_sha256)
return std::unexpected{
migration_failure(PublicationError::predecessor, ObjectError::corrupt)};
auto source = restore_cellular_payload(*source_payload, *previous);
if (!source || (*source)->format_version() != server::cellular_lives_legacy_format ||
(*source)->rules_version() != 1)
return std::unexpected{migration_failure(PublicationError::predecessor)};
auto migrated = (*source)->migrate_to_v2();
if (!migrated || (*migrated)->tick() != (*source)->tick() ||
(*migrated)->current_total() != (*source)->current_total())
return std::unexpected{migration_failure(PublicationError::candidate)};
const auto payload = (*migrated)->snapshot();
const auto payload_digest = sha256(payload);
if (!payload_digest)
return std::unexpected{migration_failure(PublicationError::digest)};
auto manifest = cellular_profile_migration_manifest(*previous, *previous_digest, commit, lease,
build, payload.size(), *payload_digest);
auto encoded = manifest ? encode_manifest(*manifest)
: std::expected<std::vector<std::uint8_t>, CheckpointError>{
std::unexpected{CheckpointError::format}};
if (!encoded || !restore_cellular_payload(payload, *manifest))
return std::unexpected{migration_failure(PublicationError::candidate)};
if (auto stored = put_verified(objects, payload, {*payload_digest, payload.size()}); !stored)
return std::unexpected{migration_failure(stored.error().kind, stored.error().object)};
return retry_cellular_profile_migration(
db, CellularProfileMigrationPrepared{previous->key, commit, std::move(*encoded)}, timeout);
}
std::expected<CommittedCheckpoint, CellularProfileMigrationFailure>
migrate_cellular_profile_to_v3(Postgres& db, const FilesystemObjectStore& objects,
const LeaseGrant& lease, const CommittedCheckpoint& predecessor,
Uuid commit, const Sha256Digest& build, milliseconds timeout) {
const auto previous = decode_manifest(predecessor.manifest);
const auto previous_digest = sha256(predecessor.manifest);
if (!previous || !previous_digest ||
previous->profile != CheckpointProfile::cellular_lives_v1 ||
previous->cellular_versions != cellular_v2_versions ||
predecessor.head.digest != *previous_digest ||
predecessor.head.sequence != previous->sequence ||
predecessor.head.commit != previous->commit ||
predecessor.head.end_tick != previous->end_tick || lease.frame != previous->frame ||
previous->sequence == 0 || previous->end_tick == 0)
return std::unexpected{migration_failure(PublicationError::candidate)};
auto source_payload = objects.get({previous->payload_sha256, previous->payload_bytes});
if (!source_payload)
return std::unexpected{
migration_failure(PublicationError::predecessor, source_payload.error())};
const auto source_digest = sha256(*source_payload);
if (!source_digest || *source_digest != previous->payload_sha256)
return std::unexpected{
migration_failure(PublicationError::predecessor, ObjectError::corrupt)};
auto source = restore_cellular_payload(*source_payload, *previous);
if (!source || (*source)->format_version() != server::cellular_lives_format ||
(*source)->rules_version() != server::cellular_lives_rules)
return std::unexpected{migration_failure(PublicationError::predecessor)};
auto migrated = (*source)->migrate_to_v3();
if (!migrated || (*migrated)->tick() != (*source)->tick() ||
(*migrated)->current_total() != (*source)->current_total())
return std::unexpected{migration_failure(PublicationError::candidate)};
const auto payload = (*migrated)->snapshot();
const auto payload_digest = sha256(payload);
if (!payload_digest)
return std::unexpected{migration_failure(PublicationError::digest)};
auto manifest = cellular_profile_migration_manifest(*previous, *previous_digest, commit, lease,
build, payload.size(), *payload_digest);
auto encoded = manifest ? encode_manifest(*manifest)
: std::expected<std::vector<std::uint8_t>, CheckpointError>{
std::unexpected{CheckpointError::format}};
if (!encoded || !restore_cellular_payload(payload, *manifest))
return std::unexpected{migration_failure(PublicationError::candidate)};
if (auto stored = put_verified(objects, payload, {*payload_digest, payload.size()}); !stored)
return std::unexpected{migration_failure(stored.error().kind, stored.error().object)};
return retry_cellular_profile_migration(
db, CellularProfileMigrationPrepared{previous->key, commit, std::move(*encoded)}, timeout);
}
std::expected<CommittedCheckpoint, CellularPublicationFailure>
retry_cellular_prepared(Postgres& db, const CellularPreparedCommit& prepared,
milliseconds timeout) {
auto manifest = decode_manifest(prepared.manifest);
auto trace = server::decode_cellular_batch(prepared.trace);
if (!manifest || !trace || !prepared_is_canonical(prepared, *manifest, *trace))
return std::unexpected{failure(PublicationError::candidate)};
auto result = publish_cellular_checkpoint(db, prepared.manifest, {}, prepared.actions,
prepared.trace, timeout);
if (!result) {
return std::unexpected{failure(result.error().kind == LeaseStoreError::unknown
? PublicationError::unknown
: PublicationError::rejected,
{}, result.error(), prepared)};
}
return confirm(*result, prepared, *manifest);
}
std::expected<ResolvedCommit, LeaseStoreFailure>
resolve_cellular_prepared(Postgres& db, const CellularPreparedCommit& prepared,
milliseconds timeout) {
auto manifest = decode_manifest(prepared.manifest);
auto trace = server::decode_cellular_batch(prepared.trace);
if (!manifest || !trace || !prepared_is_canonical(prepared, *manifest, *trace))
return std::unexpected{LeaseStoreFailure{LeaseStoreError::invalid, {}}};
return resolve_cellular_region_commit(db, prepared.key, prepared.commit, prepared.manifest, {},
prepared.actions, prepared.trace, timeout);
}
std::expected<PublishedCellularBatch, CellularPublicationFailure>
publish_cellular_batch(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease,
const CommittedCheckpoint& predecessor, const server::CellularBatch& batch,
const server::CellularLives& candidate, Uuid commit,
const Sha256Digest& build, milliseconds timeout, const PublishHooks& hooks,
std::span<const server::CellularActionRecord> actions) {
const auto previous = decode_manifest(predecessor.manifest);
const auto predecessor_digest = sha256(predecessor.manifest);
const auto trace = server::encode_cellular_batch(batch);
const auto action_block = server::encode_cellular_action_block(actions, batch.header.begin_tick,
batch.header.end_tick);
if (!previous || !predecessor_digest || !trace || !action_block ||
previous->profile != CheckpointProfile::cellular_lives_v1 ||
predecessor.head.digest != *predecessor_digest ||
previous->sequence != predecessor.head.sequence ||
previous->commit != predecessor.head.commit ||
previous->end_tick != predecessor.head.end_tick ||
batch.header.world != previous->key.world || batch.header.region != previous->key.region ||
batch.header.frame != previous->frame || batch.header.predecessor != previous->commit ||
batch.header.predecessor_digest != *predecessor_digest ||
batch.header.begin_tick != previous->end_tick || candidate.world() != previous->key.world ||
candidate.region() != previous->key.region || candidate.frame() != previous->frame ||
candidate.format_version() != previous->cellular_versions.envelope ||
candidate.rules_version() != previous->cellular_versions.rules ||
candidate.tick() != batch.header.end_tick)
return std::unexpected{failure(PublicationError::candidate)};
auto predecessor_bytes = objects.get({previous->payload_sha256, previous->payload_bytes});
if (!predecessor_bytes)
return std::unexpected{failure(PublicationError::predecessor, predecessor_bytes.error())};
auto base = restore_cellular_payload(*predecessor_bytes, *previous);
if (!base)
return std::unexpected{failure(PublicationError::predecessor)};
auto replay = server::replay_cellular_batch(**base, batch);
const auto payload = candidate.snapshot();
if (!replay || (*replay)->snapshot() != payload ||
!server::match_cellular_actions_to_trace(**base, batch, actions))
return std::unexpected{failure(PublicationError::candidate)};
const auto payload_digest = sha256(payload);
const auto trace_digest = sha256(*trace);
if (!payload_digest || !trace_digest)
return std::unexpected{failure(PublicationError::digest)};
auto manifest = successor_manifest(*previous, *predecessor_digest, commit, lease,
batch.header.end_tick, build, payload.size(),
*payload_digest, {trace->size(), *trace_digest, 0, {}});
auto manifest_bytes = manifest ? encode_manifest(*manifest)
: std::expected<std::vector<std::uint8_t>, CheckpointError>{
std::unexpected{CheckpointError::format}};
if (!manifest || !manifest_bytes || !restore_cellular_payload(payload, *manifest))
return std::unexpected{failure(PublicationError::candidate)};
if (auto stored = put_verified(objects, payload, {*payload_digest, payload.size()}); !stored)
return std::unexpected{stored.error()};
if (auto stored = put_verified(objects, *trace, {*trace_digest, trace->size()}); !stored)
return std::unexpected{stored.error()};
CellularPreparedCommit prepared{previous->key, commit, *manifest_bytes, *trace, *action_block};
if (hooks.before_transaction)
hooks.before_transaction();
auto committed = retry_cellular_prepared(db, prepared, timeout);
if (!committed)
return std::unexpected{committed.error()};
return PublishedCellularBatch{std::move(*committed)};
}
std::expected<RecoveredCellularCheckpoint, RecoveryFailure>
recover_cellular_checkpoint(Postgres& db, const FilesystemObjectStore& objects, RegionKey key,
const LeaseGrant& lease, std::span<const Sha256Digest> retained_builds,
milliseconds timeout) {
const auto fail_with = [](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()}};
const auto digest = sha256(committed->manifest);
auto manifest = decode_manifest(committed->manifest);
if (!digest || *digest != committed->head.digest || !manifest || manifest->key != key ||
manifest->sequence != committed->head.sequence ||
manifest->commit != committed->head.commit ||
manifest->end_tick != committed->head.end_tick || manifest->frame != committed->head.frame)
return fail_with(RecoveryError::manifest);
if (!supported(*manifest) || manifest->profile != CheckpointProfile::cellular_lives_v1 ||
std::ranges::find(retained_builds, manifest->build) == retained_builds.end())
return fail_with(RecoveryError::unsupported);
if (lease.frame != manifest->frame)
return fail_with(RecoveryError::unsupported);
auto payload = objects.get({manifest->payload_sha256, manifest->payload_bytes});
if (!payload)
return fail_with(payload.error() == ObjectError::io ? RecoveryError::store
: RecoveryError::corrupt_payload);
auto state = restore_cellular_payload(*payload, *manifest);
if (!state)
return fail_with(RecoveryError::payload);
std::vector<server::CellularActionRecord> actions;
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()}};
if (!*migration || (*migration)->target_sequence != manifest->sequence ||
(*migration)->target_commit != manifest->commit ||
(*migration)->target_manifest_sha256 != *digest ||
(*migration)->target_payload_sha256 != manifest->payload_sha256 ||
(*migration)->target_sequence == 0)
return fail_with(RecoveryError::history);
auto predecessor = load_region_commit(db, key, manifest->sequence - 1, timeout);
if (!predecessor)
return std::unexpected{RecoveryFailure{RecoveryError::tail, predecessor.error()}};
const auto source_manifest_digest = sha256(predecessor->manifest);
auto source_manifest = decode_manifest(predecessor->manifest);
const auto source_manifest_bytes =
encode_manifest(source_manifest ? *source_manifest : CheckpointManifest{});
const auto target_manifest_bytes = encode_manifest(*manifest);
if (!source_manifest_digest || !source_manifest || !source_manifest_bytes ||
!target_manifest_bytes || *source_manifest_digest != manifest->predecessor_digest ||
predecessor->head.digest != *source_manifest_digest ||
predecessor->head.commit != manifest->predecessor_commit ||
predecessor->head.sequence != manifest->sequence - 1 ||
source_manifest->profile != CheckpointProfile::cellular_lives_v1 ||
(source_manifest->cellular_versions != cellular_v1_versions &&
source_manifest->cellular_versions != cellular_v2_versions) ||
((source_manifest->cellular_versions == cellular_v1_versions) !=
(manifest->cellular_versions == cellular_v2_versions)) ||
source_manifest->end_tick != manifest->end_tick ||
(*migration)->source_sequence != source_manifest->sequence ||
(*migration)->source_commit != source_manifest->commit ||
(*migration)->source_manifest_sha256 != *source_manifest_digest ||
(*migration)->source_payload_sha256 != source_manifest->payload_sha256 ||
(*migration)->source_versions.size() != 36 ||
!std::ranges::equal((*migration)->source_versions,
std::span{*source_manifest_bytes}.subspan(160, 36)) ||
(*migration)->target_versions.size() != 36 ||
!std::ranges::equal((*migration)->target_versions,
std::span{*target_manifest_bytes}.subspan(160, 36)))
return fail_with(RecoveryError::history);
auto source_bytes =
objects.get({source_manifest->payload_sha256, source_manifest->payload_bytes});
if (!source_bytes)
return fail_with(source_bytes.error() == ObjectError::io ? RecoveryError::store
: RecoveryError::tail);
const auto source_payload_digest = sha256(*source_bytes);
if (!source_payload_digest || *source_payload_digest != source_manifest->payload_sha256)
return fail_with(RecoveryError::tail);
auto source_state = restore_cellular_payload(*source_bytes, *source_manifest);
if (!source_state ||
(*source_state)->format_version() != source_manifest->cellular_versions.envelope)
return fail_with(RecoveryError::tail);
auto migrated = source_manifest->cellular_versions == cellular_v1_versions
? (*source_state)->migrate_to_v2()
: (*source_state)->migrate_to_v3();
if (!migrated || (*migrated)->tick() != manifest->end_tick ||
(*migrated)->snapshot() != *payload)
return fail_with(RecoveryError::history);
return RecoveredCellularCheckpoint{std::move(*committed), *manifest, std::move(*state), {}};
}
if (manifest->sequence != 0) {
auto action_bytes =
load_cellular_publication_actions(db, key, lease, manifest->commit, timeout);
if (!action_bytes)
return std::unexpected{RecoveryFailure{RecoveryError::store, action_bytes.error()}};
if (!*action_bytes)
return fail_with(RecoveryError::history);
auto trace_bytes = objects.get({manifest->batch.trace_sha256, manifest->batch.trace_bytes});
if (!trace_bytes)
return fail_with(trace_bytes.error() == ObjectError::io ? RecoveryError::store
: RecoveryError::tail);
auto trace = server::decode_cellular_batch(*trace_bytes);
if (!trace)
return fail_with(RecoveryError::tail);
if (trace->header.world != key.world || trace->header.region != key.region ||
trace->header.frame != manifest->frame ||
trace->header.predecessor != manifest->predecessor_commit ||
trace->header.predecessor_digest != manifest->predecessor_digest ||
trace->header.begin_tick != manifest->begin_tick ||
trace->header.end_tick != manifest->end_tick)
return fail_with(RecoveryError::tail);
auto committed_births =
load_cellular_publication_births(db, key, lease, manifest->commit, timeout);
if (!committed_births)
return std::unexpected{RecoveryFailure{RecoveryError::store, committed_births.error()}};
std::vector<CellularBirthBinding> traced_births;
for (std::size_t tick_index = 0; tick_index < trace->ticks.size(); ++tick_index) {
for (const auto& birth : trace->ticks[tick_index].births) {
traced_births.push_back({birth.account, manifest->commit, birth.request,
birth.identity, manifest->begin_tick + tick_index + 1,
manifest->sequence});
}
}
if (traced_births != *committed_births)
return fail_with(RecoveryError::history);
auto predecessor = load_region_commit(db, key, manifest->sequence - 1, timeout);
if (!predecessor)
return std::unexpected{RecoveryFailure{RecoveryError::tail, predecessor.error()}};
const auto predecessor_digest = sha256(predecessor->manifest);
auto previous = decode_manifest(predecessor->manifest);
if (!predecessor_digest || *predecessor_digest != manifest->predecessor_digest ||
predecessor->head.digest != manifest->predecessor_digest ||
predecessor->head.commit != manifest->predecessor_commit ||
predecessor->head.sequence != manifest->sequence - 1 || !previous ||
previous->profile != CheckpointProfile::cellular_lives_v1 ||
previous->end_tick != manifest->begin_tick)
return fail_with(RecoveryError::tail);
auto base_bytes = objects.get({previous->payload_sha256, previous->payload_bytes});
if (!base_bytes)
return fail_with(base_bytes.error() == ObjectError::io ? RecoveryError::store
: RecoveryError::tail);
auto base = restore_cellular_payload(*base_bytes, *previous);
if (!base)
return fail_with(RecoveryError::tail);
auto batch_actions = server::decode_cellular_action_block(
**action_bytes, manifest->begin_tick, manifest->end_tick);
if (!batch_actions ||
!server::match_cellular_actions_to_trace(**base, *trace, *batch_actions))
return fail_with(RecoveryError::history);
auto replay = server::replay_cellular_batch(**base, *trace);
if (!replay || (*replay)->snapshot() != *payload)
return fail_with(RecoveryError::tail);
std::vector<ActionRef> refs;
refs.reserve(batch_actions->size());
for (const auto& action : *batch_actions)
refs.push_back({action.account, action.action_id});
auto records = find_region_action_records(db, key, lease, refs, timeout);
if (!records)
return std::unexpected{RecoveryFailure{RecoveryError::store, records.error()}};
for (std::size_t i = 0; i < batch_actions->size(); ++i) {
if (!(*records)[i])
return fail_with(RecoveryError::history);
const auto& record = *(*records)[i];
const auto& action = (*batch_actions)[i];
if (record.kind != 2 || record.result != 5 || !record.cellular_input ||
*record.cellular_input !=
std::vector<std::uint8_t>(action.input.begin(), action.input.end()) ||
record.action.region != key.region || record.action.tick != input_tick(action) ||
record.action.commit_sequence != manifest->sequence)
return fail_with(RecoveryError::history);
}
actions = std::move(*batch_actions);
}
return RecoveredCellularCheckpoint{std::move(*committed), *manifest, std::move(*state),
std::move(actions)};
}
} // namespace evo::persistence