M12.4: retain and settle owned population intervals
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 2m28s
Foundation / checks (tsan) (push) Failing after 18m22s
Foundation / checks (network) (push) Successful in 20m38s
Foundation / checks (client) (push) Failing after 21m6s
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 46m54s
Foundation / checks (checks) (push) Canceled after 47m3s

This commit is contained in:
dingo
2026-10-17 17:31:05 -04:00
parent 627411983f
commit 0a8962b57e
34 changed files with 1032 additions and 75 deletions
@@ -0,0 +1,127 @@
#include "evo/persistence/population_interval_store.hpp"
#include <charconv>
#include <string_view>
namespace evo::persistence {
namespace {
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 (cause.kind == PgError::config || cause.kind == PgError::bounds || state == "22023")
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 == "EVL05")
kind = LeaseStoreError::exhausted;
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 b : bytes) {
out += digits[b >> 4U];
out += digits[b & 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);
}
template <std::size_t N> std::optional<std::array<std::uint8_t, N>> unhex(std::string_view value) {
if (value.size() != N * 2)
return std::nullopt;
std::array<std::uint8_t, N> out{};
for (std::size_t i = 0; i < N; ++i) {
unsigned byte{};
const auto [end, error] =
std::from_chars(value.data() + i * 2, value.data() + i * 2 + 2, byte, 16);
if (error != std::errc{} || end != value.data() + i * 2 + 2 || byte > 255)
return std::nullopt;
out[i] = static_cast<std::uint8_t>(byte);
}
return out;
}
std::optional<std::uint64_t> number(std::string_view value) {
std::uint64_t out{};
const auto [end, error] = std::from_chars(value.data(), value.data() + value.size(), out);
if (error != std::errc{} || end != value.data() + value.size())
return std::nullopt;
return out;
}
std::optional<PopulationInterval> parse(const PgRows::value_type& row) {
if (row.size() != 5)
return std::nullopt;
const auto text = row[0].value_or("");
if (text.size() != 36 || text[8] != '-' || text[13] != '-' || text[18] != '-' ||
text[23] != '-')
return std::nullopt;
std::string compact;
for (const auto c : text)
if (c != '-')
compact += c;
const auto source = unhex<16>(compact);
const auto digest = unhex<32>(row[1].value_or(""));
const auto begin = number(row[2].value_or("")), end = number(row[3].value_or(""));
if (!source || !digest || !begin || !end || *end <= *begin || *end - *begin > 64 ||
*source == Uuid{} || *digest == Sha256Digest{} || row[4].value_or("") != "1")
return std::nullopt;
return PopulationInterval{*source, *digest, *begin, *end, 1};
}
constexpr auto columns = "source_commit::text,encode(source_manifest_sha256,'hex'),begin_tick::"
"text,end_tick::text,controller_version::text";
} // namespace
std::expected<PopulationInterval, LeaseStoreFailure>
admit_population_interval(Postgres& db, RegionKey key, const LeaseGrant& lease,
const RegionHead& source, std::uint64_t end_tick,
std::chrono::milliseconds timeout) {
const std::array<std::string, 7> parameters{
std::to_string(key.world), std::to_string(key.region), uuid(lease.holder),
std::to_string(lease.epoch), uuid(source.commit), "\\x" + hex(source.digest),
std::to_string(end_tick)};
auto rows = db.query(std::string("SELECT ") + columns +
" FROM evolution.admit_population_interval("
"$1::evolution.u64,$2::evolution.u64,$3::uuid,$4::evolution.u64,$5::"
"uuid,$6::bytea,$7::evolution.u64)",
parameters, timeout);
if (!rows)
return std::unexpected(failure(rows.error()));
const auto interval = rows->size() == 1 ? parse(rows->front()) : std::nullopt;
if (!interval || interval->source_commit != source.commit ||
interval->source_manifest_sha256 != source.digest ||
interval->begin_tick != source.end_tick || interval->end_tick != end_tick)
return std::unexpected(LeaseStoreFailure{LeaseStoreError::unknown, {}});
return *interval;
}
std::expected<std::optional<PopulationInterval>, LeaseStoreFailure>
load_population_interval(Postgres& db, RegionKey key, const LeaseGrant& lease,
std::chrono::milliseconds timeout) {
const std::array<std::string, 4> parameters{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_population_interval("
"$1::evolution.u64,$2::evolution.u64,$3::uuid,$4::evolution.u64)",
parameters, timeout);
if (!rows)
return std::unexpected(failure(rows.error()));
if (rows->empty())
return std::optional<PopulationInterval>{};
const auto interval = rows->size() == 1 ? parse(rows->front()) : std::nullopt;
if (!interval)
return std::unexpected(LeaseStoreFailure{LeaseStoreError::store, {}});
return interval;
}
} // namespace evo::persistence