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
348 lines
18 KiB
C++
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
|