#include "evo/persistence/checkpoint_store.hpp" #include "checkpoint_detail.hpp" namespace evo::persistence { namespace { using namespace detail; using std::chrono::milliseconds; template std::expected provision(Postgres& owner, const FilesystemObjectStore& objects, RegionKey key, std::uint64_t frame, const typename Codec::State& opening, Uuid commit, const Sha256Digest& build, std::size_t budget, milliseconds timeout) { auto payload = Codec::snapshot(opening); if (!payload || Codec::tick(opening) != 0) return std::unexpected{fail(PublicationError::candidate)}; const auto digest = sha256(*payload); if (!digest) return std::unexpected{fail(PublicationError::digest)}; auto manifest = genesis_manifest(key, frame, commit, Codec::quantum(opening), build, payload->size(), *digest, Codec::profile); auto bytes = manifest ? encode_manifest(*manifest) : std::expected, CheckpointError>{ std::unexpected{CheckpointError::format}}; if (!bytes || !Codec::restore(*payload, *manifest, budget)) return std::unexpected{fail(PublicationError::candidate)}; if (auto stored = put_verified(objects, *payload, {*digest, payload->size()}); !stored) return std::unexpected{stored.error()}; const std::array p{hex_parameter(*bytes)}; auto done = owner.query("SELECT evolution.provision_region_checkpoint($1::bytea)", p, timeout); if (!done) { const bool unknown = done.error().kind == PgError::unknown; return std::unexpected{PublicationFailure{ unknown ? PublicationError::unknown : PublicationError::rejected, {unknown ? LeaseStoreError::unknown : LeaseStoreError::store, done.error()}, {}, {}}}; } auto committed = load_region_checkpoint(owner, key, timeout); if (!committed) return std::unexpected{ PublicationFailure{PublicationError::unknown, committed.error(), {}, {}}}; return confirm(committed->head, std::move(*bytes), *manifest, {}); } template std::expected publish_batch(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease, const CommittedCheckpoint& predecessor, const RegionBatch& batch, Uuid commit, const Sha256Digest& build, std::size_t budget, milliseconds timeout, const PublishHooks& hooks, std::span actions) { const auto previous = decode_manifest(predecessor.manifest); if (!previous || previous->profile != Codec::profile || !batch.sealed() || batch.steps().empty() || batch.begin_tick() != previous->end_tick) return std::unexpected{fail(PublicationError::candidate)}; // Replay the recorded inputs from the committed predecessor's verified bytes. auto base = objects.get({previous->payload_sha256, previous->payload_bytes}); if (!base) return std::unexpected{fail(PublicationError::predecessor, base.error())}; auto replay = Codec::restore(*base, *previous, budget); if (!replay) return std::unexpected{fail(PublicationError::predecessor)}; for (const auto& step : batch.steps()) { auto report = (*replay)->advance(step.report.tick, step.input); if (!report || *report != step.report) return std::unexpected{fail(PublicationError::candidate)}; } auto payload = Codec::snapshot(batch.state()); const auto replayed = Codec::snapshot(**replay); if (!payload || !replayed || *payload != *replayed) return std::unexpected{fail(PublicationError::candidate)}; const auto organisms = Codec::organisms(batch.state()); const auto decisions = derive_decisions(batch.steps(), organisms.producer, organisms.consumer); auto decision_bytes = encode_decisions(decisions, batch.begin_tick(), batch.end_tick()); const TraceHeader header{static_cast(Codec::profile), previous->key, previous->commit, predecessor.head.digest, batch.begin_tick(), batch.end_tick()}; auto trace = encode_trace(header, batch.steps()); auto action_bytes = encode_actions(actions, batch.begin_tick(), batch.end_tick()); if (!decision_bytes || !trace || !action_bytes) return std::unexpected{fail(PublicationError::candidate)}; const auto payload_digest = sha256(*payload); const auto trace_digest = sha256(*trace); const auto decisions_digest = sha256(*decision_bytes); if (!payload_digest || !trace_digest || !decisions_digest) return std::unexpected{fail(PublicationError::digest)}; const BatchDigests digests{trace->size(), *trace_digest, static_cast(decisions.size()), decisions.empty() ? Sha256Digest{} : *decisions_digest}; auto manifest = successor_manifest(*previous, predecessor.head.digest, commit, lease, batch.end_tick(), build, payload->size(), *payload_digest, digests); auto bytes = manifest ? encode_manifest(*manifest) : std::expected, CheckpointError>{ std::unexpected{CheckpointError::format}}; if (!bytes || !Codec::restore(*payload, *manifest, budget)) return std::unexpected{fail(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()}; PreparedCommit prepared{previous->key, commit, *bytes, *decision_bytes, *action_bytes}; if (hooks.before_transaction) hooks.before_transaction(); auto published = retry_prepared(db, prepared, timeout); auto committed = confirm(published, std::move(*bytes), *manifest, std::move(prepared)); if (!committed) return std::unexpected{committed.error()}; return PublishedBatch{std::move(*committed), decisions}; } } // namespace std::expected provision_environmental_region( Postgres& owner, const FilesystemObjectStore& objects, RegionKey key, std::uint64_t frame, const processes::EnvironmentalCommunity& opening, Uuid commit, const Sha256Digest& build, std::size_t restore_budget, milliseconds timeout) { return provision(owner, objects, key, frame, opening, commit, build, restore_budget, timeout); } std::expected publish_environmental_batch(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease, const CommittedCheckpoint& predecessor, const RegionBatch& batch, Uuid commit, const Sha256Digest& build, std::size_t restore_budget, milliseconds timeout, const PublishHooks& hooks, std::span actions) { return publish_batch(db, objects, lease, predecessor, batch, commit, build, restore_budget, timeout, hooks, actions); } std::expected recover_environmental_checkpoint(Postgres& db, const FilesystemObjectStore& objects, RegionKey key, std::span retained_builds, std::size_t restore_budget, milliseconds timeout) { return recover(db, objects, key, retained_builds, restore_budget, timeout); } std::expected provision_lineage_region(Postgres& owner, const FilesystemObjectStore& objects, RegionKey key, std::uint64_t frame, const processes::LineageRegion& opening, Uuid commit, const Sha256Digest& build, std::size_t restore_budget, milliseconds timeout) { return provision(owner, objects, key, frame, opening, commit, build, restore_budget, timeout); } std::expected publish_lineage_batch(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease, const CommittedCheckpoint& predecessor, const RegionBatch& batch, Uuid commit, const Sha256Digest& build, std::size_t restore_budget, milliseconds timeout, const PublishHooks& hooks, std::span actions) { return publish_batch(db, objects, lease, predecessor, batch, commit, build, restore_budget, timeout, hooks, actions); } std::expected recover_lineage_checkpoint(Postgres& db, const FilesystemObjectStore& objects, RegionKey key, std::span retained_builds, std::size_t restore_budget, milliseconds timeout) { return recover(db, objects, key, retained_builds, restore_budget, timeout); } std::expected resolve_prepared(Postgres& db, const PreparedCommit& prepared, milliseconds timeout) { if (!prepared.actions.empty()) return resolve_region_commit(db, prepared.key, prepared.commit, prepared.manifest, prepared.decisions, prepared.actions, timeout); return resolve_region_commit(db, prepared.key, prepared.commit, prepared.manifest, prepared.decisions, timeout); } std::expected retry_prepared(Postgres& db, const PreparedCommit& prepared, milliseconds timeout) { // Without actions the schema v5 publication is used, exactly as before v11. if (!prepared.actions.empty()) return publish_region_checkpoint(db, prepared.manifest, prepared.decisions, prepared.actions, timeout); return publish_region_checkpoint(db, prepared.manifest, prepared.decisions, timeout); } } // namespace evo::persistence