#include "evo/persistence/checkpoint_store.hpp" #include "evo/persistence/sha256.hpp" #include #include #include #include namespace evo::persistence { namespace { using std::chrono::milliseconds; constexpr std::string_view digits = "0123456789abcdef"; std::string hex(std::span bytes) { std::string out = "\\x"; out.reserve(2 + bytes.size() * 2); for (const auto b : bytes) { out.push_back(digits[b >> 4U]); out.push_back(digits[b & 0x0fU]); } return out; } std::optional nibble(char c) { const auto i = digits.find(c); if (i == std::string_view::npos) return std::nullopt; return static_cast(i); } template std::optional> unhex(std::string_view s) { if (s.size() != N * 2) return std::nullopt; std::array out{}; for (std::size_t i = 0; i < N; ++i) { const auto hi = nibble(s[i * 2]); const auto lo = nibble(s[i * 2 + 1]); if (!hi || !lo) return std::nullopt; out[i] = static_cast((*hi << 4U) | *lo); } return out; } std::optional uuid(const std::optional& value) { if (!value || value->size() != 36) return std::nullopt; std::string compact; compact.reserve(32); for (std::size_t i = 0; i < value->size(); ++i) { const bool dash = i == 8 || i == 13 || i == 18 || i == 23; if (dash != ((*value)[i] == '-')) return std::nullopt; if (!dash) compact.push_back((*value)[i]); } return unhex<16>(compact); } template std::optional integer(const std::optional& s) { if (!s || s->empty() || s->size() > 20 || s->front() == '-' || s->front() == '+') return std::nullopt; T value{}; const auto [end, ec] = std::from_chars(s->data(), s->data() + s->size(), value); if (ec != std::errc{} || end != s->data() + s->size()) return std::nullopt; return value; } PrimitivePublicationFailure fail(PublicationError kind, ObjectError object = {}, LeaseStoreFailure store = {}, PrimitivePreparedCommit 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{fail(PublicationError::upload, stored.error())}; auto readback = objects.get(*stored); if (!readback || *stored != expected || !std::ranges::equal(*readback, bytes)) return std::unexpected{ fail(PublicationError::verify, readback ? ObjectError::corrupt : readback.error())}; return {}; } std::optional parse_head(const PgRows& rows) { if (rows.size() != 1 || rows[0].size() != 5) return std::nullopt; const auto frame = integer(rows[0][0]); const auto sequence = integer(rows[0][1]); const auto commit = uuid(rows[0][2]); const auto digest_text = rows[0][3].value_or(std::string{}); const auto digest = unhex<32>(digest_text); const auto tick = integer(rows[0][4]); if (!frame || !sequence || !commit || !digest || !tick) return std::nullopt; return RegionHead{*frame, *sequence, *commit, *digest, *tick}; } std::expected confirm(const RegionHead& head, const PrimitivePreparedCommit& 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{fail(PublicationError::receipt)}; return CommittedCheckpoint{head, prepared.manifest}; } bool same_binding(const server::PrimitiveLife& life, const PrimitiveLifeBinding& binding) { return life.request.account == binding.account && life.request.action == binding.request && life.identity.life == binding.identity && life.identity.born.value == binding.born; } std::expected, RecoveryFailure> load_bindings(Postgres& db, RegionKey key, milliseconds timeout) { auto bindings = load_primitive_lives(db, key, timeout); if (!bindings) return std::unexpected{RecoveryFailure{ RecoveryError::store, {bindings.error().kind == LifeReservationError::unknown ? LeaseStoreError::unknown : LeaseStoreError::store, bindings.error().cause}}}; return std::move(*bindings); } } // namespace std::expected provision_primitive_region(Postgres& owner, const FilesystemObjectStore& objects, RegionKey key, std::uint64_t frame, const server::PrimitiveLives& opening, Uuid commit, const Sha256Digest& build, milliseconds timeout) { const auto& config = opening.config(); const auto payload = opening.snapshot(); if (config.world != key.world || config.region != key.region || config.frame != frame || !opening.lives().empty()) 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, 50000, build, payload.size(), *digest, CheckpointProfile::primitive_lives_v1); auto encoded = manifest ? encode_manifest(*manifest) : std::expected, CheckpointError>{ std::unexpected{CheckpointError::format}}; if (!encoded || !restore_primitive_payload(payload, *manifest)) 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(*encoded)}; auto inserted = owner.query("SELECT evolution.provision_region_checkpoint($1::bytea)", p, timeout); if (!inserted) { const bool unknown = inserted.error().kind == PgError::unknown; return std::unexpected{ fail(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{fail(PublicationError::unknown, {}, committed.error())}; PrimitivePreparedCommit prepared{key, commit, *encoded, {}}; auto confirmed = confirm(committed->head, prepared, *manifest); if (!confirmed) return std::unexpected{confirmed.error()}; return *confirmed; } std::expected retry_primitive_prepared(Postgres& db, const PrimitivePreparedCommit& prepared, milliseconds timeout) { auto manifest = decode_manifest(prepared.manifest); auto trace = server::decode_primitive_batch(prepared.trace); const auto trace_digest = sha256(prepared.trace); if (!manifest || !trace || !trace_digest || manifest->key != prepared.key || manifest->commit != prepared.commit || manifest->profile != CheckpointProfile::primitive_lives_v1 || manifest->sequence == 0 || manifest->batch.trace_bytes != prepared.trace.size() || manifest->batch.trace_sha256 != *trace_digest || 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) return std::unexpected{fail(PublicationError::candidate)}; const std::array p{hex(prepared.manifest), hex(prepared.trace)}; auto rows = db.query( "SELECT * FROM evolution.publish_primitive_checkpoint($1::bytea, $2::bytea)", p, timeout); if (!rows) { const bool unknown = rows.error().kind == PgError::unknown; return std::unexpected{fail( unknown ? PublicationError::unknown : PublicationError::rejected, {}, {unknown ? LeaseStoreError::unknown : LeaseStoreError::store, rows.error()}, prepared)}; } const auto head = parse_head(*rows); if (!head) return std::unexpected{ fail(PublicationError::unknown, {}, {LeaseStoreError::unknown, {}}, prepared)}; return confirm(*head, prepared, *manifest); } std::expected publish_primitive_batch(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease, const CommittedCheckpoint& predecessor, const server::PrimitiveBatch& batch, const server::PrimitiveLives& candidate, Uuid commit, const Sha256Digest& build, milliseconds timeout, const PublishHooks& hooks) { const auto previous = decode_manifest(predecessor.manifest); const auto predecessor_digest = sha256(predecessor.manifest); auto trace = server::encode_primitive_batch(batch); if (!previous || !predecessor_digest || !trace || previous->profile != CheckpointProfile::primitive_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) return std::unexpected{fail(PublicationError::candidate)}; auto base_bytes = objects.get({previous->payload_sha256, previous->payload_bytes}); if (!base_bytes) return std::unexpected{fail(PublicationError::predecessor, base_bytes.error())}; auto base = restore_primitive_payload(*base_bytes, *previous); if (!base) return std::unexpected{fail(PublicationError::predecessor)}; auto replay = server::replay_primitive_batch(**base, batch); const auto candidate_bytes = candidate.snapshot(); if (!replay || (*replay)->snapshot() != candidate_bytes) return std::unexpected{fail(PublicationError::candidate)}; const auto digest = sha256(candidate_bytes); const auto trace_digest = sha256(*trace); if (!digest || !trace_digest) return std::unexpected{fail(PublicationError::digest)}; auto manifest = successor_manifest(*previous, *predecessor_digest, commit, lease, batch.header.end_tick, build, candidate_bytes.size(), *digest, {trace->size(), *trace_digest, 0, {}}); auto encoded = manifest ? encode_manifest(*manifest) : std::expected, CheckpointError>{ std::unexpected{CheckpointError::format}}; if (!encoded || !restore_primitive_payload(candidate_bytes, *manifest)) return std::unexpected{fail(PublicationError::candidate)}; if (auto stored = put_verified(objects, candidate_bytes, {*digest, candidate_bytes.size()}); !stored) return std::unexpected{stored.error()}; if (auto stored = put_verified(objects, *trace, {*trace_digest, trace->size()}); !stored) return std::unexpected{stored.error()}; PrimitivePreparedCommit prepared{previous->key, commit, *encoded, *trace}; if (hooks.before_transaction) hooks.before_transaction(); auto committed = retry_primitive_prepared(db, prepared, timeout); if (!committed) return std::unexpected{committed.error()}; return PublishedPrimitiveBatch{std::move(*committed)}; } std::expected recover_primitive_checkpoint(Postgres& db, const FilesystemObjectStore& objects, RegionKey key, std::span retained_builds, milliseconds timeout) { 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 std::unexpected{RecoveryFailure{RecoveryError::manifest, {}}}; if (!supported(*manifest) || manifest->profile != CheckpointProfile::primitive_lives_v1 || std::ranges::find(retained_builds, manifest->build) == retained_builds.end()) return std::unexpected{RecoveryFailure{RecoveryError::unsupported, {}}}; auto payload = objects.get({manifest->payload_sha256, manifest->payload_bytes}); if (!payload) return std::unexpected{RecoveryFailure{ payload.error() == ObjectError::missing ? RecoveryError::missing_payload : payload.error() == ObjectError::corrupt ? RecoveryError::corrupt_payload : payload.error() == ObjectError::io ? RecoveryError::store : RecoveryError::corrupt_payload, {}}}; auto state = restore_primitive_payload(*payload, *manifest); if (!state) return std::unexpected{RecoveryFailure{RecoveryError::payload, {}}}; auto bindings = load_bindings(db, key, timeout); if (!bindings) return std::unexpected{bindings.error()}; if ((*state)->lives().size() != bindings->size()) return std::unexpected{RecoveryFailure{RecoveryError::history, {}}}; for (const auto& life : (*state)->lives()) { const auto binding = std::ranges::find_if(*bindings, [&](const auto& b) { return same_binding(life, b) && b.commit_sequence <= manifest->sequence; }); if (binding == bindings->end()) return std::unexpected{RecoveryFailure{RecoveryError::history, {}}}; } if (manifest->sequence == 0) { if (!bindings->empty() || !(*state)->lives().empty()) return std::unexpected{RecoveryFailure{RecoveryError::history, {}}}; } else { auto trace_bytes = objects.get({manifest->batch.trace_sha256, manifest->batch.trace_bytes}); auto trace = trace_bytes ? server::decode_primitive_batch(*trace_bytes) : std::expected{ std::unexpected{server::PrimitiveBatchError::format}}; if (!trace_bytes || !trace) return std::unexpected{RecoveryFailure{RecoveryError::tail, {}}}; const auto& h = trace->header; if (h.world != key.world || h.region != key.region || h.frame != manifest->frame || h.predecessor != manifest->predecessor_commit || h.predecessor_digest != manifest->predecessor_digest || h.begin_tick != manifest->begin_tick || h.end_tick != manifest->end_tick) return std::unexpected{RecoveryFailure{RecoveryError::tail, {}}}; 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 predecessor_manifest = decode_manifest(predecessor->manifest); if (!predecessor_digest || *predecessor_digest != manifest->predecessor_digest || predecessor->head.sequence != manifest->sequence - 1 || predecessor->head.commit != manifest->predecessor_commit || predecessor->head.digest != manifest->predecessor_digest || !predecessor_manifest || predecessor_manifest->sequence != manifest->sequence - 1 || predecessor_manifest->end_tick != manifest->begin_tick) return std::unexpected{RecoveryFailure{RecoveryError::tail, {}}}; auto predecessor_payload = objects.get( {predecessor_manifest->payload_sha256, predecessor_manifest->payload_bytes}); if (!predecessor_payload) return std::unexpected{RecoveryFailure{RecoveryError::tail, {}}}; auto predecessor_state = restore_primitive_payload(*predecessor_payload, *predecessor_manifest); if (!predecessor_state) return std::unexpected{RecoveryFailure{RecoveryError::tail, {}}}; auto replay = server::replay_primitive_batch(**predecessor_state, *trace); if (!replay || (*replay)->snapshot() != *payload) return std::unexpected{RecoveryFailure{RecoveryError::tail, {}}}; for (const auto& birth : trace->births) { const auto binding = std::ranges::find_if(*bindings, [&](const auto& b) { return b.account == birth.request.account && b.request == birth.request.action; }); if (binding == bindings->end() || binding->identity != birth.identity || binding->born != birth.born.value || binding->commit != manifest->commit || binding->commit_sequence != manifest->sequence) return std::unexpected{RecoveryFailure{RecoveryError::history, {}}}; } } return RecoveredPrimitiveCheckpoint{std::move(*committed), *manifest, std::move(*state), std::move(*bindings)}; } } // namespace evo::persistence