Files
aevolution/src/persistence/cellular_migration_store.cpp
T
dingo d3a867a662
Foundation / checks (ecs) (push) Successful in 2m20s
Foundation / checks (deploy) (push) Successful in 4m7s
Foundation / checks (network) (push) Successful in 21m2s
Foundation / checks (client) (push) Successful in 22m21s
Foundation / checks (tsan) (push) Successful in 28m57s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 38m8s
Foundation / checks (checks) (push) Canceled after 38m19s
feat(persistence): admit durable maturing wildlife migrations
2026-10-19 11:57:00 -04:00

727 lines
39 KiB
C++

#include "evo/persistence/cellular_migration_store.hpp"
#include "cellular_migration_observation_detail.hpp"
#include "evo/persistence/sha256.hpp"
#include "evo/server/lifecycle/cellular_census_set.hpp"
#include <algorithm>
#include <charconv>
#include <limits>
#include <string_view>
namespace evo::persistence {
namespace {
using std::chrono::milliseconds;
LeaseStoreFailure failure(const PgFailure& cause) {
const std::string_view state(cause.sqlstate.data(), 5);
auto kind = LeaseStoreError::store;
if (cause.kind == PgError::unknown)
kind = LeaseStoreError::unknown;
else if (state == "22023" || cause.kind == PgError::bounds || cause.kind == PgError::config)
kind = LeaseStoreError::invalid;
else if (state == "EVL02")
kind = LeaseStoreError::fenced;
else if (state == "EVL03")
kind = LeaseStoreError::head_mismatch;
else if (state == "EVL04")
kind = LeaseStoreError::not_provisioned;
else if (state == "EVL06")
kind = LeaseStoreError::unsupported;
else if (state == "EVL07" || state == "EVL18")
kind = LeaseStoreError::commit_conflict;
return {kind, cause};
}
std::string hex(std::span<const std::uint8_t> bytes) {
constexpr std::string_view digits = "0123456789abcdef";
std::string out;
for (const auto byte : bytes) {
out += digits[byte >> 4U];
out += digits[byte & 15U];
}
return out;
}
std::string uuid(const Uuid& id) {
const auto h = hex(id);
return h.substr(0, 8) + '-' + h.substr(8, 4) + '-' + h.substr(12, 4) + '-' + h.substr(16, 4) +
'-' + h.substr(20);
}
std::optional<std::vector<std::uint8_t>> unhex(std::string_view value, std::size_t cap) {
if (value.size() % 2 != 0 || value.size() / 2 > cap)
return std::nullopt;
std::vector<std::uint8_t> out;
out.reserve(value.size() / 2);
for (std::size_t at = 0; at < value.size(); at += 2) {
unsigned byte{};
const auto [end, error] =
std::from_chars(value.data() + at, value.data() + at + 2, byte, 16);
if (error != std::errc{} || end != value.data() + at + 2 || byte > 255)
return std::nullopt;
out.push_back(static_cast<std::uint8_t>(byte));
}
return out;
}
struct Record {
std::vector<std::uint8_t> trace, source, destination;
bool aborted{};
};
std::optional<Record> parse(const PgRows::value_type& row) {
if (row.size() != 4 || (row[3].value_or("") != "true" && row[3].value_or("") != "false"))
return std::nullopt;
auto trace = unhex(row[0].value_or(""), server::max_migration_trace_bytes);
auto source = unhex(row[1].value_or(""), checkpoint_manifest_bytes);
auto destination = unhex(row[2].value_or(""), checkpoint_manifest_bytes);
if (!trace || !source || !destination)
return std::nullopt;
return Record{std::move(*trace), std::move(*source), std::move(*destination),
row[3].value_or("") == "true"};
}
bool bound(const CommittedCheckpoint& c, const CheckpointManifest& m) {
const auto digest = sha256(c.manifest);
return digest && *digest == c.head.digest && m.commit == c.head.commit &&
m.frame == c.head.frame && m.sequence == c.head.sequence &&
m.end_tick == c.head.end_tick;
}
bool cuts(const CheckpointManifest& s, const CheckpointManifest& d,
const Sha256Digest& source_digest, const Sha256Digest& destination_digest,
const server::CellularMigrationTrace& t) {
const auto profile = t.representation == server::CellularMigrationRepresentation::individual
? CheckpointProfile::cellular_lives_v1
: CheckpointProfile::cellular_population_v1;
const bool version = (t.format_version == 1 && s.cellular_versions == cellular_v10_versions) ||
(t.format_version == 2 && s.cellular_versions == cellular_v11_versions);
return version && supported(s) && supported(d) && encode_manifest(s) && encode_manifest(d) &&
d.cellular_versions == s.cellular_versions && s.profile == profile &&
d.profile == profile && s.sequence > 0 && d.sequence > 0 &&
s.key == RegionKey{t.world, t.request.source.region} &&
d.key == RegionKey{t.world, t.request.destination.region} && s.frame == t.frame &&
d.frame == t.frame && s.end_tick == t.tick && d.end_tick == t.tick &&
s.commit == t.request.source.predecessor &&
d.commit == t.request.destination.predecessor &&
source_digest == t.request.source.predecessor_digest &&
destination_digest == t.request.destination.predecessor_digest;
}
std::expected<server::CellularMigrationTrace, CheckpointError>
derive(const CheckpointManifest& s, const CheckpointManifest& d,
std::span<const std::uint8_t> source, std::span<const std::uint8_t> destination,
const server::CellularMigrationRequest& request) {
if (s.profile == CheckpointProfile::cellular_lives_v1) {
auto src = restore_cellular_payload(source, s),
dst = restore_cellular_payload(destination, d);
if (!src || !dst)
return std::unexpected(CheckpointError::payload);
auto pair = server::prepare_migration_trace(**src, **dst, request);
if (!pair)
return std::unexpected(CheckpointError::payload);
return std::move(pair->trace);
}
auto src = restore_population_payload(source, s),
dst = restore_population_payload(destination, d);
if (!src || !dst)
return std::unexpected(CheckpointError::payload);
auto pair = server::prepare_migration_trace(**src, **dst, request);
if (!pair)
return std::unexpected(CheckpointError::payload);
return std::move(pair->trace);
}
std::optional<CellularMigrationFreeze> checked_record(const Record& record, RegionKey key,
const LeaseGrant& lease) {
auto trace = server::decode_migration_trace(record.trace);
const auto source = decode_manifest(record.source),
destination = decode_manifest(record.destination);
const auto s = sha256(record.source), d = sha256(record.destination);
if (!trace || !source || !destination || !s || !d ||
key != RegionKey{trace->world, trace->request.source.region} ||
lease.frame != trace->frame || !cuts(*source, *destination, *s, *d, *trace))
return std::nullopt;
return CellularMigrationFreeze{std::move(*trace), record.aborted};
}
constexpr auto columns = "encode(trace,'hex'),encode(source_manifest,'hex'),"
"encode(destination_manifest,'hex'),aborted::text";
CellularMigrationFailure failed(PublicationError kind, LeaseStoreFailure store = {},
ObjectError object = {}, CellularMigrationPrepared prepared = {}) {
return {kind, store, object, std::move(prepared)};
}
} // namespace
std::expected<CellularMigrationFreeze, CellularMigrationFailure>
retry_cellular_migration_freeze(Postgres& db, const LeaseGrant& lease,
const CellularMigrationPrepared& prepared, milliseconds timeout) {
const auto trace = server::decode_migration_trace(prepared.trace);
if (!trace || prepared.key != RegionKey{trace->world, trace->request.source.region} ||
lease.frame != trace->frame)
return std::unexpected(failed(PublicationError::candidate));
const std::array<std::string, 5> args{std::to_string(prepared.key.world),
std::to_string(prepared.key.region), uuid(lease.holder),
std::to_string(lease.epoch), "\\x" + hex(prepared.trace)};
auto rows =
db.query(std::string("SELECT ") + columns +
" FROM evolution.prepare_cellular_migration_freeze("
"$1::evolution.u64,$2::evolution.u64,$3::uuid,$4::evolution.u64,$5::bytea)",
args, timeout);
if (!rows) {
const auto store = failure(rows.error());
return std::unexpected(failed(store.kind == LeaseStoreError::unknown
? PublicationError::unknown
: PublicationError::rejected,
store, {}, prepared));
}
const auto record = rows->size() == 1 ? parse(rows->front()) : std::nullopt;
const auto result = record ? checked_record(*record, prepared.key, lease) : std::nullopt;
if (!result || record->trace != prepared.trace)
return std::unexpected(failed(PublicationError::unknown, {}, {}, prepared));
return *result;
}
std::expected<CellularMigrationFreeze, CellularMigrationFailure>
prepare_cellular_migration_freeze(Postgres& db, const FilesystemObjectStore& source_objects,
const FilesystemObjectStore& destination_objects,
const LeaseGrant& lease, const CommittedCheckpoint& source,
const CommittedCheckpoint& destination,
const server::CellularMigrationRequest& request,
milliseconds timeout, const PublishHooks& hooks) {
const auto s = decode_manifest(source.manifest), d = decode_manifest(destination.manifest);
if (!s || !d || !bound(source, *s) || !bound(destination, *d))
return std::unexpected(failed(PublicationError::predecessor));
auto src = source_objects.get({s->payload_sha256, s->payload_bytes});
auto dst = destination_objects.get({d->payload_sha256, d->payload_bytes});
if (!src || !dst)
return std::unexpected(
failed(PublicationError::predecessor, {}, !src ? src.error() : dst.error()));
auto trace = derive(*s, *d, *src, *dst, request);
if (!trace || !cuts(*s, *d, source.head.digest, destination.head.digest, *trace) ||
lease.frame != s->frame)
return std::unexpected(failed(PublicationError::candidate));
auto encoded = server::encode_migration_trace(*trace);
if (!encoded)
return std::unexpected(failed(PublicationError::candidate));
auto capsule = source_objects.put(*dst);
if (!capsule)
return std::unexpected(failed(PublicationError::upload, {}, capsule.error()));
auto readback = source_objects.get(*capsule);
if (!readback || *readback != *dst ||
*capsule != VerifiedObject{d->payload_sha256, d->payload_bytes})
return std::unexpected(failed(PublicationError::verify, {},
readback ? ObjectError::corrupt : readback.error()));
if (hooks.before_transaction)
hooks.before_transaction();
return retry_cellular_migration_freeze(db, lease, {s->key, std::move(*encoded)}, timeout);
}
std::expected<CellularMigrationFreeze, LeaseStoreFailure>
abort_cellular_migration_freeze(Postgres& db, RegionKey key, const LeaseGrant& lease,
const Uuid& request, milliseconds timeout) {
const std::array<std::string, 5> args{std::to_string(key.world), std::to_string(key.region),
uuid(lease.holder), std::to_string(lease.epoch),
uuid(request)};
auto rows =
db.query(std::string("SELECT ") + columns +
" FROM evolution.abort_cellular_migration_freeze("
"$1::evolution.u64,$2::evolution.u64,$3::uuid,$4::evolution.u64,$5::uuid)",
args, timeout);
if (!rows)
return std::unexpected(failure(rows.error()));
const auto record = rows->size() == 1 ? parse(rows->front()) : std::nullopt;
auto result = record ? checked_record(*record, key, lease) : std::nullopt;
if (!result || !result->aborted || result->trace.request.request != request)
return std::unexpected(LeaseStoreFailure{LeaseStoreError::unknown, {}});
return *result;
}
std::expected<std::optional<CellularMigrationFreeze>, RecoveryFailure>
load_cellular_migration_freeze(Postgres& db, const FilesystemObjectStore& objects, RegionKey key,
const LeaseGrant& lease, milliseconds timeout) {
const auto fail = [](RecoveryError kind) { return std::unexpected(RecoveryFailure{kind, {}}); };
const std::array<std::string, 4> args{std::to_string(key.world), std::to_string(key.region),
uuid(lease.holder), std::to_string(lease.epoch)};
auto rows = db.query(std::string("SELECT ") + columns +
" FROM evolution.load_cellular_migration_freeze("
"$1::evolution.u64,$2::evolution.u64,$3::uuid,$4::evolution.u64)",
args, timeout);
if (!rows)
return std::unexpected(RecoveryFailure{RecoveryError::store, failure(rows.error())});
if (rows->empty())
return std::optional<CellularMigrationFreeze>{};
const auto record = rows->size() == 1 ? parse(rows->front()) : std::nullopt;
auto result = record ? checked_record(*record, key, lease) : std::nullopt;
if (!result || result->aborted)
return fail(RecoveryError::history);
const auto s = decode_manifest(record->source), d = decode_manifest(record->destination);
if (!s || !d)
return fail(RecoveryError::manifest);
auto src = objects.get({s->payload_sha256, s->payload_bytes});
auto dst = objects.get({d->payload_sha256, d->payload_bytes});
if (!src || !dst)
return fail(RecoveryError::tail);
const auto replay = derive(*s, *d, *src, *dst, result->trace.request);
if (!replay || *replay != result->trace)
return fail(RecoveryError::history);
return result;
}
namespace {
constexpr auto stage_columns = "encode(trace,'hex'),encode(source_manifest,'hex'),"
"encode(destination_manifest,'hex'),aborted::text,"
"encode(ghost_sha256,'hex'),ghost_bytes::text";
struct StageRecord {
Record cut;
VerifiedObject ghost;
};
std::optional<StageRecord> parse_stage(const PgRows::value_type& row) {
if (row.size() != 6)
return std::nullopt;
auto cut = parse(PgRows::value_type(row.begin(), row.begin() + 4));
const auto digest = unhex(row[4].value_or(""), 32);
const auto size = row[5].value_or("");
std::uint64_t bytes{};
const auto [end, error] = std::from_chars(size.data(), size.data() + size.size(), bytes);
if (!cut || !digest || digest->size() != 32 || error != std::errc{} ||
end != size.data() + size.size() || bytes == 0)
return std::nullopt;
VerifiedObject ghost{{}, bytes};
std::ranges::copy(*digest, ghost.sha256.begin());
return StageRecord{std::move(*cut), ghost};
}
std::optional<CellularMigrationStage> checked_stage(const StageRecord& record, RegionKey key,
const LeaseGrant& lease) {
const auto trace = server::decode_migration_trace(record.cut.trace);
if (!trace || key != RegionKey{trace->world, trace->request.destination.region})
return std::nullopt;
const auto freeze =
checked_record(record.cut, {trace->world, trace->request.source.region}, lease);
const auto destination = decode_manifest(record.cut.destination);
if (!freeze || !destination || record.ghost.sha256 == Sha256Digest{} ||
record.ghost.bytes > max_payload_bytes(destination->profile))
return std::nullopt;
return CellularMigrationStage{*freeze, record.ghost};
}
struct MigrationPayloads {
std::vector<std::uint8_t> source, destination;
};
std::optional<MigrationPayloads> migration_payloads(const CheckpointManifest& s,
const CheckpointManifest& d,
std::span<const std::uint8_t> source,
std::span<const std::uint8_t> destination,
const server::CellularMigrationTrace& trace) {
if (s.profile == CheckpointProfile::cellular_lives_v1) {
auto src = restore_cellular_payload(source, s),
dst = restore_cellular_payload(destination, d);
if (!src || !dst)
return std::nullopt;
auto pair = server::replay_migration_trace(**src, **dst, trace.request, trace);
if (!pair)
return std::nullopt;
return MigrationPayloads{pair->source->snapshot(), pair->destination->snapshot()};
}
auto src = restore_population_payload(source, s),
dst = restore_population_payload(destination, d);
if (!src || !dst)
return std::nullopt;
auto pair = server::replay_migration_trace(**src, **dst, trace.request, trace);
if (!pair)
return std::nullopt;
return MigrationPayloads{pair->source->snapshot(), pair->destination->snapshot()};
}
std::optional<std::vector<std::uint8_t>>
ghost_candidate(const CheckpointManifest& s, const CheckpointManifest& d,
std::span<const std::uint8_t> source, std::span<const std::uint8_t> destination,
const server::CellularMigrationTrace& trace) {
auto pair = migration_payloads(s, d, source, destination, trace);
if (!pair)
return std::nullopt;
return std::move(pair->destination);
}
CellularMigrationStageFailure stage_failed(PublicationError kind, LeaseStoreFailure store = {},
ObjectError object = {},
CellularMigrationStagePrepared prepared = {}) {
return {kind, store, object, std::move(prepared)};
}
} // namespace
std::expected<CellularMigrationStage, CellularMigrationStageFailure>
retry_cellular_migration_stage(Postgres& db, const LeaseGrant& lease,
const CellularMigrationStagePrepared& prepared,
milliseconds timeout) {
const auto trace = server::decode_migration_trace(prepared.trace);
if (!trace || prepared.key != RegionKey{trace->world, trace->request.destination.region} ||
lease.frame != trace->frame || prepared.ghost.sha256 == Sha256Digest{} ||
prepared.ghost.bytes == 0)
return std::unexpected(stage_failed(PublicationError::candidate));
const std::array<std::string, 7> args{std::to_string(prepared.key.world),
std::to_string(prepared.key.region),
uuid(lease.holder),
std::to_string(lease.epoch),
"\\x" + hex(prepared.trace),
"\\x" + hex(prepared.ghost.sha256),
std::to_string(prepared.ghost.bytes)};
auto rows = db.query(std::string("SELECT ") + stage_columns +
" FROM evolution.stage_cellular_migration($1::evolution.u64,"
"$2::evolution.u64,$3::uuid,$4::evolution.u64,$5::bytea,$6::bytea,"
"$7::evolution.u64)",
args, timeout);
if (!rows) {
const auto store = failure(rows.error());
return std::unexpected(stage_failed(store.kind == LeaseStoreError::unknown
? PublicationError::unknown
: PublicationError::rejected,
store, {}, prepared));
}
const auto record = rows->size() == 1 ? parse_stage(rows->front()) : std::nullopt;
const auto result = record ? checked_stage(*record, prepared.key, lease) : std::nullopt;
if (!result || record->cut.trace != prepared.trace || result->ghost != prepared.ghost)
return std::unexpected(stage_failed(PublicationError::unknown, {}, {}, prepared));
return *result;
}
std::expected<CellularMigrationStage, CellularMigrationStageFailure>
stage_cellular_migration(Postgres& db, const FilesystemObjectStore& source_objects,
const FilesystemObjectStore& destination_objects, const LeaseGrant& lease,
const CommittedCheckpoint& source, const CommittedCheckpoint& destination,
const server::CellularMigrationTrace& trace, milliseconds timeout,
const PublishHooks& hooks) {
const auto s = decode_manifest(source.manifest), d = decode_manifest(destination.manifest);
if (!s || !d || !bound(source, *s) || !bound(destination, *d) ||
!cuts(*s, *d, source.head.digest, destination.head.digest, trace) ||
lease.frame != d->frame)
return std::unexpected(stage_failed(PublicationError::predecessor));
auto src = source_objects.get({s->payload_sha256, s->payload_bytes});
auto dst = destination_objects.get({d->payload_sha256, d->payload_bytes});
if (!src || !dst)
return std::unexpected(
stage_failed(PublicationError::predecessor, {}, !src ? src.error() : dst.error()));
const auto candidate = ghost_candidate(*s, *d, *src, *dst, trace);
const auto encoded = server::encode_migration_trace(trace);
if (!candidate || !encoded)
return std::unexpected(stage_failed(PublicationError::candidate));
auto capsule = destination_objects.put(*src);
if (!capsule)
return std::unexpected(stage_failed(PublicationError::upload, {}, capsule.error()));
auto capsule_bytes = destination_objects.get(*capsule);
if (!capsule_bytes || *capsule_bytes != *src ||
*capsule != VerifiedObject{s->payload_sha256, s->payload_bytes})
return std::unexpected(
stage_failed(PublicationError::verify, {},
capsule_bytes ? ObjectError::corrupt : capsule_bytes.error()));
auto ghost = destination_objects.put(*candidate);
if (!ghost)
return std::unexpected(stage_failed(PublicationError::upload, {}, ghost.error()));
auto readback = destination_objects.get(*ghost);
if (!readback || *readback != *candidate)
return std::unexpected(stage_failed(PublicationError::verify, {},
readback ? ObjectError::corrupt : readback.error()));
if (hooks.before_transaction)
hooks.before_transaction();
return retry_cellular_migration_stage(db, lease, {d->key, *encoded, *ghost}, timeout);
}
std::expected<std::optional<CellularMigrationStage>, RecoveryFailure>
load_cellular_migration_stage(Postgres& db, const FilesystemObjectStore& objects, RegionKey key,
const LeaseGrant& lease, milliseconds timeout) {
const auto fail = [](RecoveryError kind) { return std::unexpected(RecoveryFailure{kind, {}}); };
const std::array<std::string, 4> args{std::to_string(key.world), std::to_string(key.region),
uuid(lease.holder), std::to_string(lease.epoch)};
auto rows = db.query(std::string("SELECT ") + stage_columns +
" FROM evolution.load_cellular_migration_stage($1::evolution.u64,"
"$2::evolution.u64,$3::uuid,$4::evolution.u64)",
args, timeout);
if (!rows)
return std::unexpected(RecoveryFailure{RecoveryError::store, failure(rows.error())});
if (rows->empty())
return std::optional<CellularMigrationStage>{};
const auto record = rows->size() == 1 ? parse_stage(rows->front()) : std::nullopt;
auto result = record ? checked_stage(*record, key, lease) : std::nullopt;
if (!result || result->freeze.aborted)
return fail(RecoveryError::history);
const auto s = decode_manifest(record->cut.source),
d = decode_manifest(record->cut.destination);
if (!s || !d)
return fail(RecoveryError::manifest);
auto src = objects.get({s->payload_sha256, s->payload_bytes});
auto dst = objects.get({d->payload_sha256, d->payload_bytes});
auto ghost = objects.get(result->ghost);
if (!src || !dst || !ghost)
return fail(RecoveryError::tail);
const auto candidate = ghost_candidate(*s, *d, *src, *dst, result->freeze.trace);
if (!candidate || *candidate != *ghost)
return fail(RecoveryError::history);
return result;
}
namespace detail {
std::expected<std::vector<CapturedCellularMigration>, RecoveryFailure>
capture_cellular_migrations(Postgres& db, std::uint64_t world, milliseconds timeout) {
const std::array<std::string, 1> args{std::to_string(world)};
const auto rows =
db.query("SELECT encode(trace,'hex'),encode(source_manifest,'hex'),"
"encode(destination_manifest,'hex'),encode(ghost_sha256,'hex'),"
"pg_catalog.trunc(ghost_bytes)::text,coherent::text "
"FROM evolution.load_world_cellular_migrations_v1($1::evolution.u64)",
args, timeout);
if (!rows)
return std::unexpected(RecoveryFailure{RecoveryError::store, failure(rows.error())});
if (rows->size() > server::max_cellular_census_regions)
return std::unexpected(
RecoveryFailure{RecoveryError::store, {LeaseStoreError::invalid, {PgError::bounds}}});
std::vector<CapturedCellularMigration> result;
for (const auto& row : *rows) {
if (row.size() != 6 || row[5].value_or("") != "true")
return std::unexpected(RecoveryFailure{RecoveryError::history});
auto cut = parse({row[0], row[1], row[2], std::string{"false"}});
if (!cut)
return std::unexpected(RecoveryFailure{RecoveryError::history});
std::optional<VerifiedObject> ghost;
if (row[3] || row[4]) {
auto stage =
parse_stage({row[0], row[1], row[2], std::string{"false"}, row[3], row[4]});
if (!stage)
return std::unexpected(RecoveryFailure{RecoveryError::history});
ghost = stage->ghost;
}
result.push_back(
{std::move(cut->trace), std::move(cut->source), std::move(cut->destination), ghost});
}
return result;
}
std::expected<CellularMigrationObservation, RecoveryFailure>
verify_captured_cellular_migration(const CapturedCellularMigration& record,
const FilesystemObjectStore& source_objects,
const FilesystemObjectStore& destination_objects) {
const auto fail = [](RecoveryError kind) { return std::unexpected(RecoveryFailure{kind}); };
auto trace = server::decode_migration_trace(record.trace);
const auto s = decode_manifest(record.source), d = decode_manifest(record.destination);
const auto sd = sha256(record.source), dd = sha256(record.destination);
if (!trace || !s || !d || !sd || !dd || !cuts(*s, *d, *sd, *dd, *trace))
return fail(RecoveryError::history);
const auto source = source_objects.get({s->payload_sha256, s->payload_bytes});
const auto capsule = source_objects.get({d->payload_sha256, d->payload_bytes});
if (!source || !capsule)
return fail(RecoveryError::tail);
const auto replay = derive(*s, *d, *source, *capsule, trace->request);
if (!replay || *replay != *trace)
return fail(RecoveryError::history);
if (record.ghost) {
if (record.ghost->sha256 == Sha256Digest{} || record.ghost->bytes == 0 ||
record.ghost->bytes > max_payload_bytes(d->profile))
return fail(RecoveryError::history);
const auto sc = destination_objects.get({s->payload_sha256, s->payload_bytes});
const auto dc = destination_objects.get({d->payload_sha256, d->payload_bytes});
const auto ghost = destination_objects.get(*record.ghost);
if (!sc || !dc || !ghost)
return fail(RecoveryError::tail);
const auto candidate = ghost_candidate(*s, *d, *sc, *dc, *trace);
if (!candidate || *candidate != *ghost)
return fail(RecoveryError::history);
}
return CellularMigrationObservation{std::move(*trace), record.ghost.has_value()};
}
} // namespace detail
namespace {
constexpr auto commit_columns =
"encode(trace,'hex'),encode(source_predecessor,'hex'),"
"encode(destination_predecessor,'hex'),encode(source_result,'hex'),"
"encode(destination_result,'hex'),encode(ghost_sha256,'hex'),ghost_bytes::text";
std::optional<CheckpointManifest>
migration_manifest(const CheckpointManifest& p, const Sha256Digest& digest, const Uuid& commit,
const LeaseGrant& lease, const Sha256Digest& build, VerifiedObject object) {
if (!supported(p) ||
(p.cellular_versions != cellular_v10_versions &&
p.cellular_versions != cellular_v11_versions) ||
p.sequence == 0 || p.sequence == std::numeric_limits<std::uint64_t>::max() ||
lease.frame != p.frame)
return std::nullopt;
auto m = p;
m.commit = commit;
++m.sequence;
m.predecessor_commit = p.commit;
m.predecessor_digest = digest;
m.begin_tick = m.end_tick;
m.holder = lease.holder;
m.epoch = lease.epoch;
m.build = build;
m.payload_bytes = object.bytes;
m.payload_sha256 = object.sha256;
m.batch = {};
if (!encode_manifest(m))
return std::nullopt;
return m;
}
std::optional<CommittedCheckpoint> checkpoint(std::vector<std::uint8_t> bytes) {
const auto m = decode_manifest(bytes);
const auto digest = sha256(bytes);
if (!m || !digest)
return std::nullopt;
return CommittedCheckpoint{{m->frame, m->sequence, m->commit, *digest, m->end_tick},
std::move(bytes)};
}
struct CommitRecord {
StageRecord stage;
CellularMigrationCommitted result;
};
std::optional<CommitRecord> parse_commit(const PgRows::value_type& row) {
if (row.size() != 7)
return std::nullopt;
auto stage = parse_stage({row[0], row[1], row[2], std::string{"false"}, row[5], row[6]});
auto s = unhex(row[3].value_or(""), checkpoint_manifest_bytes),
d = unhex(row[4].value_or(""), checkpoint_manifest_bytes);
auto source = s ? checkpoint(std::move(*s)) : std::nullopt;
auto destination = d ? checkpoint(std::move(*d)) : std::nullopt;
if (!stage || !source || !destination)
return std::nullopt;
return CommitRecord{std::move(*stage), {std::move(*source), std::move(*destination)}};
}
bool checked_commit(const CommitRecord& record) {
const auto t = server::decode_migration_trace(record.stage.cut.trace);
const auto s = decode_manifest(record.stage.cut.source),
d = decode_manifest(record.stage.cut.destination);
const auto sr = decode_manifest(record.result.source.manifest),
dr = decode_manifest(record.result.destination.manifest);
const auto sd = sha256(record.stage.cut.source), dd = sha256(record.stage.cut.destination);
if (!t || !s || !d || !sr || !dr || !sd || !dd || !cuts(*s, *d, *sd, *dd, *t) ||
record.stage.ghost != VerifiedObject{dr->payload_sha256, dr->payload_bytes})
return false;
const auto expected_s = migration_manifest(*s, *sd, t->request.source.commit,
{sr->holder, sr->epoch, sr->frame, milliseconds{0}},
sr->build, {sr->payload_sha256, sr->payload_bytes});
const auto expected_d = migration_manifest(*d, *dd, t->request.destination.commit,
{dr->holder, dr->epoch, dr->frame, milliseconds{0}},
dr->build, {dr->payload_sha256, dr->payload_bytes});
return expected_s && expected_d && *expected_s == *sr && *expected_d == *dr;
}
CellularMigrationCommitFailure commit_failed(PublicationError kind, LeaseStoreFailure store = {},
ObjectError object = {},
CellularMigrationCommitPrepared prepared = {}) {
return {kind, store, object, std::move(prepared)};
}
} // namespace
std::expected<CellularMigrationCommitted, CellularMigrationCommitFailure>
retry_cellular_migration_commit(Postgres& db, const LeaseGrant& source_lease,
const LeaseGrant& destination_lease,
const CellularMigrationCommitPrepared& prepared,
milliseconds timeout) {
const auto s = decode_manifest(prepared.source_manifest),
d = decode_manifest(prepared.destination_manifest);
if (!s || !d || prepared.request == Uuid{} || s->frame != source_lease.frame ||
d->frame != destination_lease.frame)
return std::unexpected(commit_failed(PublicationError::candidate));
const std::array<std::string, 7> args{uuid(prepared.request),
"\\x" + hex(prepared.source_manifest),
"\\x" + hex(prepared.destination_manifest),
uuid(source_lease.holder),
std::to_string(source_lease.epoch),
uuid(destination_lease.holder),
std::to_string(destination_lease.epoch)};
auto rows = db.query(
std::string("SELECT ") + commit_columns +
" FROM evolution.publish_cellular_migration($1::uuid,$2::bytea,$3::bytea,$4::uuid,"
"$5::evolution.u64,$6::uuid,$7::evolution.u64)",
args, timeout);
if (!rows) {
const auto store = failure(rows.error());
return std::unexpected(commit_failed(store.kind == LeaseStoreError::unknown
? PublicationError::unknown
: PublicationError::rejected,
store, {}, prepared));
}
auto record = rows->size() == 1 ? parse_commit(rows->front()) : std::nullopt;
if (!record || !checked_commit(*record) ||
record->result.source.manifest != prepared.source_manifest ||
record->result.destination.manifest != prepared.destination_manifest)
return std::unexpected(commit_failed(PublicationError::unknown, {}, {}, prepared));
const auto trace = server::decode_migration_trace(record->stage.cut.trace);
if (!trace || trace->request.request != prepared.request)
return std::unexpected(commit_failed(PublicationError::unknown, {}, {}, prepared));
return std::move(record->result);
}
std::expected<CellularMigrationCommitted, CellularMigrationCommitFailure>
publish_cellular_migration(Postgres& db, const FilesystemObjectStore& source_objects,
const FilesystemObjectStore& destination_objects,
const LeaseGrant& source_lease, const LeaseGrant& destination_lease,
const CommittedCheckpoint& source,
const CommittedCheckpoint& destination,
const server::CellularMigrationTrace& trace, const Sha256Digest& build,
milliseconds timeout, const PublishHooks& hooks) {
const auto s = decode_manifest(source.manifest), d = decode_manifest(destination.manifest);
if (!s || !d || !bound(source, *s) || !bound(destination, *d) ||
!cuts(*s, *d, source.head.digest, destination.head.digest, trace))
return std::unexpected(commit_failed(PublicationError::predecessor));
auto src = source_objects.get({s->payload_sha256, s->payload_bytes}),
dst = destination_objects.get({d->payload_sha256, d->payload_bytes});
if (!src || !dst)
return std::unexpected(
commit_failed(PublicationError::predecessor, {}, !src ? src.error() : dst.error()));
const auto pair = migration_payloads(*s, *d, *src, *dst, trace);
if (!pair)
return std::unexpected(commit_failed(PublicationError::candidate));
const auto so = source_objects.put(pair->source),
dest = destination_objects.put(pair->destination);
if (!so || !dest)
return std::unexpected(
commit_failed(PublicationError::upload, {}, !so ? so.error() : dest.error()));
const auto sb = source_objects.get(*so), dbb = destination_objects.get(*dest);
if (!sb || !dbb || *sb != pair->source || *dbb != pair->destination)
return std::unexpected(commit_failed(PublicationError::verify));
const auto sm = migration_manifest(*s, source.head.digest, trace.request.source.commit,
source_lease, build, *so),
dm =
migration_manifest(*d, destination.head.digest, trace.request.destination.commit,
destination_lease, build, *dest);
if (!sm || !dm)
return std::unexpected(commit_failed(PublicationError::candidate));
const auto sm_bytes = encode_manifest(*sm), dm_bytes = encode_manifest(*dm);
if (!sm_bytes || !dm_bytes)
return std::unexpected(commit_failed(PublicationError::candidate));
if (hooks.before_transaction)
hooks.before_transaction();
return retry_cellular_migration_commit(db, source_lease, destination_lease,
{trace.request.request, *sm_bytes, *dm_bytes}, timeout);
}
std::expected<bool, RecoveryFailure>
verify_cellular_migration_checkpoint(Postgres& db, const FilesystemObjectStore& objects,
const LeaseGrant& lease, const CommittedCheckpoint& committed,
std::span<const std::uint8_t> payload, milliseconds timeout) {
const auto fail = [](RecoveryError kind) { return std::unexpected(RecoveryFailure{kind, {}}); };
const auto m = decode_manifest(committed.manifest);
if (!m || !bound(committed, *m) || lease.frame != m->frame)
return fail(RecoveryError::manifest);
const std::array<std::string, 5> args{std::to_string(m->key.world),
std::to_string(m->key.region), uuid(lease.holder),
std::to_string(lease.epoch), uuid(m->commit)};
auto rows = db.query(
std::string("SELECT ") + commit_columns +
" FROM evolution.load_cellular_migration_commit($1::evolution.u64,$2::evolution.u64,"
"$3::uuid,$4::evolution.u64,$5::uuid)",
args, timeout);
if (!rows)
return std::unexpected(RecoveryFailure{RecoveryError::store, failure(rows.error())});
if (rows->empty())
return false;
const auto record = rows->size() == 1 ? parse_commit(rows->front()) : std::nullopt;
if (!record || !checked_commit(*record))
return fail(RecoveryError::history);
const auto s = decode_manifest(record->stage.cut.source),
d = decode_manifest(record->stage.cut.destination);
const auto sr = decode_manifest(record->result.source.manifest),
dr = decode_manifest(record->result.destination.manifest);
const auto trace = server::decode_migration_trace(record->stage.cut.trace);
if (!s || !d || !sr || !dr || !trace)
return fail(RecoveryError::history);
const bool is_source = m->key == s->key;
if (committed.manifest !=
(is_source ? record->result.source.manifest : record->result.destination.manifest))
return fail(RecoveryError::history);
const auto src = objects.get({s->payload_sha256, s->payload_bytes}),
dst = objects.get({d->payload_sha256, d->payload_bytes});
if (!src || !dst)
return fail(RecoveryError::tail);
const auto pair = migration_payloads(*s, *d, *src, *dst, *trace);
if (!pair)
return fail(RecoveryError::history);
const auto sd = sha256(pair->source), dd = sha256(pair->destination);
if (!sd || !dd || *sd != sr->payload_sha256 || *dd != dr->payload_sha256 ||
pair->source.size() != sr->payload_bytes || pair->destination.size() != dr->payload_bytes ||
!std::ranges::equal(is_source ? pair->source : pair->destination, payload))
return fail(RecoveryError::history);
return true;
}
} // namespace evo::persistence