Add fenced cellular region host
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 41s
Foundation / checks (ecs) (push) Successful in 1m54s
Foundation / checks (postgres) (push) Failing after 53s
Foundation / checks (tsan) (push) Failing after 33s
Foundation / checks (network) (push) Failing after 3m4s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (client) (push) Canceled after 4m14s

This commit is contained in:
dingo
2026-10-10 23:27:26 -04:00
parent 4930fd7159
commit 0ddba31d42
6 changed files with 487 additions and 20 deletions
+351
View File
@@ -0,0 +1,351 @@
#include "evo/server/cellular_region_host.hpp"
#include "evo/persistence/sha256.hpp"
#include <algorithm>
#include <array>
#include <chrono>
#include <utility>
namespace evo::server {
struct CellularRegionHost::Pending {
persistence::CellularPreparedCommit prepared;
std::unique_ptr<CellularLives> candidate;
std::vector<CellularActionRecord> actions;
};
namespace {
using persistence::LeaseClock;
using persistence::LeaseStoreError;
using std::chrono::milliseconds;
bool valid(const CellularHostConfig& config) {
return config.key.world != 0 && config.key.region != 0 && config.frame != 0 &&
persistence::valid(config.lease) && config.build != persistence::Sha256Digest{} &&
std::ranges::find(config.retained_builds, config.build) != config.retained_builds.end();
}
std::optional<persistence::Uuid> commit_id(const persistence::CommittedCheckpoint& previous,
std::span<const std::uint8_t> trace,
std::span<const std::uint8_t> actions) {
std::vector<std::uint8_t> identity;
identity.reserve(previous.head.digest.size() + 16 + trace.size() + actions.size());
identity.insert(identity.end(), previous.head.digest.begin(), previous.head.digest.end());
const auto append_length = [&](std::size_t size) {
const auto length = static_cast<std::uint64_t>(size);
for (unsigned i = 0; i < 8; ++i)
identity.push_back(static_cast<std::uint8_t>(length >> (i * 8U)));
};
append_length(trace.size());
identity.insert(identity.end(), trace.begin(), trace.end());
append_length(actions.size());
identity.insert(identity.end(), actions.begin(), actions.end());
const auto digest = persistence::sha256(identity);
if (!digest)
return std::nullopt;
persistence::Uuid out{};
std::ranges::copy_n(digest->begin(), out.size(), out.begin());
if (out == persistence::Uuid{})
out.back() = 1;
return out;
}
} // namespace
CellularRegionHost::CellularRegionHost(
CellularHostConfig config, CellularConnect connect,
std::unique_ptr<persistence::FilesystemObjectStore> objects)
: config_{std::move(config)}, connect_{std::move(connect)}, objects_{std::move(objects)},
authority_{config_.lease} {}
CellularRegionHost::~CellularRegionHost() = default;
std::expected<std::unique_ptr<CellularRegionHost>, CellularHostError>
CellularRegionHost::create(CellularHostConfig config, CellularConnect connect,
std::unique_ptr<persistence::FilesystemObjectStore> objects) {
if (!valid(config) || !connect || !objects)
return std::unexpected{CellularHostError::configuration};
return std::unique_ptr<CellularRegionHost>{
new CellularRegionHost{std::move(config), std::move(connect), std::move(objects)}};
}
bool CellularRegionHost::database() {
if (db_)
return true;
auto connection = connect_();
if (!connection) {
++status_.store_failures;
return false;
}
db_ = std::move(*connection);
return true;
}
void CellularRegionHost::acquire() {
if (!database())
return;
const auto sent = LeaseClock::now();
auto lease = persistence::acquire_region_lease(*db_, config_.key, config_.build,
config_.lease.duration,
config_.lease.renew_timeout);
if (!lease) {
if (lease.error().kind == LeaseStoreError::not_provisioned ||
lease.error().kind == LeaseStoreError::unsupported) {
status_.phase = HostPhase::quarantined;
} else if (lease.error().kind != LeaseStoreError::busy) {
db_.reset();
++status_.store_failures;
}
return;
}
if (lease->frame != config_.frame ||
!authority_.acquired(*lease, sent, LeaseClock::now())) {
status_.phase = HostPhase::quarantined;
return;
}
auto recovered = persistence::recover_cellular_checkpoint(
*db_, *objects_, config_.key, *lease, config_.retained_builds,
config_.lease.commit_timeout);
if (!recovered) {
if (recovered.error().kind == persistence::RecoveryError::store) {
db_.reset();
++status_.store_failures;
return;
}
authority_.fence();
status_.phase = HostPhase::quarantined;
return;
}
state_ = std::move(recovered->state);
committed_ = std::move(recovered->committed);
status_.phase = HostPhase::running;
status_.simulated_tick = committed_->head.end_tick;
status_.committed_tick = committed_->head.end_tick;
status_.committed_sequence = committed_->head.sequence;
}
void CellularRegionHost::upkeep() {
if (authority_.state(LeaseClock::now()) == persistence::LeaseState::fenced) {
authority_.fence();
state_.reset();
committed_.reset();
pending_.reset();
status_.ready = false;
status_.phase = HostPhase::acquiring;
++status_.fences;
return;
}
if (authority_.state(LeaseClock::now()) != persistence::LeaseState::renew_due || !database())
return;
const auto grant = *authority_.grant();
const auto sent = LeaseClock::now();
auto renewed = persistence::renew_region_lease(*db_, config_.key, grant, config_.lease.duration,
config_.lease.renew_timeout);
if (renewed) {
if (!authority_.renewed(grant.epoch, *renewed, sent, LeaseClock::now())) {
authority_.fence();
state_.reset();
committed_.reset();
pending_.reset();
status_.ready = false;
status_.phase = HostPhase::acquiring;
}
return;
}
if (renewed.error().kind == LeaseStoreError::unknown)
authority_.renewal_unknown(config_.lease.duration, sent);
else if (renewed.error().kind == LeaseStoreError::fenced) {
authority_.fence();
state_.reset();
committed_.reset();
pending_.reset();
status_.ready = false;
status_.phase = HostPhase::acquiring;
++status_.fences;
}
db_.reset();
++status_.store_failures;
}
void CellularRegionHost::resolve() {
if (!pending_ || !database())
return;
if (!authority_.may_begin_commit(LeaseClock::now())) {
authority_.fence();
state_.reset();
committed_.reset();
pending_.reset();
status_.phase = HostPhase::acquiring;
status_.ready = false;
++status_.fences;
return;
}
const auto resolved = persistence::resolve_cellular_prepared(
*db_, pending_->prepared, config_.lease.commit_timeout);
if (!resolved) {
if (resolved.error().kind == LeaseStoreError::fenced) {
authority_.fence();
state_.reset();
committed_.reset();
pending_.reset();
status_.phase = HostPhase::acquiring;
status_.ready = false;
++status_.fences;
} else {
db_.reset();
++status_.store_failures;
}
return;
}
if (resolved->status == persistence::Resolution::conflict) {
authority_.fence();
state_.reset();
committed_.reset();
pending_.reset();
status_.phase = HostPhase::quarantined;
status_.ready = false;
return;
}
if (resolved->status == persistence::Resolution::absent &&
!authority_.may_begin_commit(LeaseClock::now()))
return;
auto retried = persistence::retry_cellular_prepared(
*db_, pending_->prepared, config_.lease.commit_timeout);
if (!retried) {
if (retried.error().kind == persistence::PublicationError::unknown) {
db_.reset();
++status_.unknown_outcomes;
status_.phase = HostPhase::resolving;
status_.ready = false;
} else if (retried.error().store.kind == LeaseStoreError::fenced) {
authority_.fence();
state_.reset();
committed_.reset();
pending_.reset();
status_.phase = HostPhase::acquiring;
status_.ready = false;
++status_.fences;
} else {
authority_.fence();
state_.reset();
committed_.reset();
pending_.reset();
status_.phase = HostPhase::quarantined;
status_.ready = false;
}
return;
}
state_ = std::move(pending_->candidate);
committed_ = std::move(*retried);
for (const auto& action : pending_->actions)
finalized_actions_.push_back({action, committed_->head.sequence});
pending_.reset();
++status_.commits;
status_.committed_sequence = committed_->head.sequence;
status_.committed_tick = committed_->head.end_tick;
status_.simulated_tick = committed_->head.end_tick;
status_.phase = HostPhase::running;
}
void CellularRegionHost::refresh() {
const auto& grant = authority_.grant();
status_.ready = status_.phase == HostPhase::running && state_ && committed_ && grant &&
authority_.may_originate(LeaseClock::now());
status_.epoch = grant ? grant->epoch : 0;
status_.lease_remaining_ms =
status_.ready
? static_cast<std::uint64_t>(std::chrono::duration_cast<milliseconds>(
authority_.deadline() - LeaseClock::now())
.count())
: 0;
}
const HostStatus& CellularRegionHost::step() {
if (status_.phase == HostPhase::quarantined || status_.phase == HostPhase::stopped)
return status_;
if (authority_.grant())
upkeep();
if (pending_)
resolve();
else if (!state_)
acquire();
refresh();
return status_;
}
std::expected<persistence::PublishedCellularBatch, CellularHostError>
CellularRegionHost::publish(const CellularBatch& batch,
std::span<const CellularActionRecord> actions) {
if (!status_.ready || !state_ || !committed_ ||
!authority_.may_begin_commit(LeaseClock::now()))
return std::unexpected{CellularHostError::not_ready};
auto candidate = replay_cellular_batch(*state_, batch);
if (!candidate)
return std::unexpected{CellularHostError::invalid_batch};
auto trace = encode_cellular_batch(batch);
auto action_block = encode_cellular_action_block(actions, batch.header.begin_tick,
batch.header.end_tick);
const auto commit = trace && action_block
? commit_id(*committed_, *trace, *action_block)
: std::nullopt;
if (!commit)
return std::unexpected{CellularHostError::invalid_batch};
auto published = persistence::publish_cellular_batch(
*db_, *objects_, *authority_.grant(), *committed_, batch, **candidate, *commit,
config_.build, config_.lease.commit_timeout, {}, actions);
if (!published) {
if (published.error().kind == persistence::PublicationError::unknown) {
pending_ = std::make_unique<Pending>(
Pending{published.error().prepared, std::move(*candidate),
{actions.begin(), actions.end()}});
status_.phase = HostPhase::resolving;
status_.ready = false;
++status_.unknown_outcomes;
db_.reset();
} else if (published.error().store.kind == LeaseStoreError::fenced) {
authority_.fence();
state_.reset();
committed_.reset();
status_.phase = HostPhase::acquiring;
status_.ready = false;
++status_.fences;
}
return std::unexpected{CellularHostError::publication};
}
state_ = std::move(*candidate);
committed_ = published->committed;
for (const auto& action : actions)
finalized_actions_.push_back({action, committed_->head.sequence});
++status_.commits;
status_.committed_sequence = committed_->head.sequence;
status_.committed_tick = committed_->head.end_tick;
status_.simulated_tick = committed_->head.end_tick;
refresh();
return *published;
}
std::vector<FinalCellularAction> CellularRegionHost::take_finalized_actions() {
return std::exchange(finalized_actions_, {});
}
void CellularRegionHost::drain() {
status_.ready = false;
status_.phase = HostPhase::draining;
pending_.reset();
const auto grant = authority_.grant();
if (grant && authority_.may_originate(LeaseClock::now()) && database())
static_cast<void>(persistence::release_region_lease(
*db_, config_.key, *grant, config_.lease.renew_timeout));
authority_.fence();
state_.reset();
committed_.reset();
status_.phase = HostPhase::stopped;
status_.epoch = 0;
status_.lease_remaining_ms = 0;
}
std::optional<persistence::LeaseGrant> CellularRegionHost::authority() const {
if (!status_.ready || !authority_.may_originate(LeaseClock::now()))
return std::nullopt;
return authority_.grant();
}
} // namespace evo::server