Files
aevolution/src/persistence/primitive_checkpoint_store.cpp
T
dingo 7461d02961
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m53s
Foundation / checks (client) (push) Successful in 12m22s
Foundation / checks (network) (push) Successful in 13m52s
Foundation / checks (tsan) (push) Successful in 8m7s
Foundation / checks (checks) (push) Successful in 33m54s
Foundation / checks (postgres) (push) Successful in 47m38s
Foundation / postgres-tools (push) Successful in 19s
Foundation / image (push) Successful in 2m39s
Foundation / server-image (push) Successful in 4m16s
Add primitive object publication and recovery adapter (M11.2c-2d)
2026-10-10 11:15:44 -04:00

348 lines
18 KiB
C++

#include "evo/persistence/checkpoint_store.hpp"
#include "evo/persistence/sha256.hpp"
#include <algorithm>
#include <array>
#include <charconv>
#include <ranges>
namespace evo::persistence {
namespace {
using std::chrono::milliseconds;
constexpr std::string_view digits = "0123456789abcdef";
std::string hex(std::span<const std::uint8_t> 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<std::uint8_t> nibble(char c) {
const auto i = digits.find(c);
if (i == std::string_view::npos)
return std::nullopt;
return static_cast<std::uint8_t>(i);
}
template <std::size_t N> std::optional<std::array<std::uint8_t, N>> unhex(std::string_view s) {
if (s.size() != N * 2)
return std::nullopt;
std::array<std::uint8_t, N> 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<std::uint8_t>((*hi << 4U) | *lo);
}
return out;
}
std::optional<Uuid> uuid(const std::optional<std::string>& 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 <typename T> std::optional<T> integer(const std::optional<std::string>& 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<void, PrimitivePublicationFailure> put_verified(const FilesystemObjectStore& objects,
std::span<const std::uint8_t> 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<RegionHead> parse_head(const PgRows& rows) {
if (rows.size() != 1 || rows[0].size() != 5)
return std::nullopt;
const auto frame = integer<std::uint64_t>(rows[0][0]);
const auto sequence = integer<std::uint64_t>(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<std::uint64_t>(rows[0][4]);
if (!frame || !sequence || !commit || !digest || !tick)
return std::nullopt;
return RegionHead{*frame, *sequence, *commit, *digest, *tick};
}
std::expected<CommittedCheckpoint, PrimitivePublicationFailure>
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<std::vector<PrimitiveLifeBinding>, 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<CommittedCheckpoint, PrimitivePublicationFailure>
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<std::vector<std::uint8_t>, 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<std::string, 1> 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<CommittedCheckpoint, PrimitivePublicationFailure>
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<std::string, 2> 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<PublishedPrimitiveBatch, PrimitivePublicationFailure>
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<std::vector<std::uint8_t>, 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<RecoveredPrimitiveCheckpoint, RecoveryFailure>
recover_primitive_checkpoint(Postgres& db, const FilesystemObjectStore& objects, RegionKey key,
std::span<const Sha256Digest> 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<server::PrimitiveBatch, server::PrimitiveBatchError>{
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