#include "evo/persistence/checkpoint_store.hpp" #include "evo/persistence/sha256.hpp" #include #include #include #include #include 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(action.input[i]) << (i * 8U); return tick; } CellularPublicationFailure failure(PublicationError kind, ObjectError object = {}, LeaseStoreFailure store = {}, CellularPreparedCommit prepared = {}) { return {kind, store, object, std::move(prepared)}; } std::expected put_verified(const FilesystemObjectStore& objects, std::span 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 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, 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 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); auto encoded = manifest ? encode_manifest(*manifest) : std::expected, 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 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 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 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 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 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.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, 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 recover_cellular_checkpoint(Postgres& db, const FilesystemObjectStore& objects, RegionKey key, const LeaseGrant& lease, std::span 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 actions; 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 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 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(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