Session protocol v10 adds type 26: the life's earned offer with its unranked candidates in operator order and each successor's capability value, maintenance and total mass. The cellular bridge sends it when the offer or the owner's session changes and clears a consumed offer; the client keeps the latest one for the maintainer's choice UI (ADR-0121, 11.4d server half). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
659 lines
28 KiB
C++
659 lines
28 KiB
C++
#include "evo/server/cellular_region_host.hpp"
|
|
|
|
#include "evo/biology/founder.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;
|
|
std::vector<CellularTickIntents::Birth> births;
|
|
std::vector<CellularMutationActionRecord> mutation_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();
|
|
}
|
|
|
|
network::PrimitiveLifeResult life_result(persistence::LifeRefusal refusal) {
|
|
switch (refusal) {
|
|
case persistence::LifeRefusal::none:
|
|
return network::PrimitiveLifeResult::pending;
|
|
case persistence::LifeRefusal::insufficient_funding:
|
|
return network::PrimitiveLifeResult::insufficient_funding;
|
|
case persistence::LifeRefusal::no_placement:
|
|
return network::PrimitiveLifeResult::no_placement;
|
|
case persistence::LifeRefusal::cancelled:
|
|
return network::PrimitiveLifeResult::cancelled;
|
|
case persistence::LifeRefusal::existing_life:
|
|
return network::PrimitiveLifeResult::existing_life;
|
|
}
|
|
return network::PrimitiveLifeResult::unknown;
|
|
}
|
|
|
|
std::vector<CellularTickIntents::Birth> births_in(const CellularBatch& batch) {
|
|
std::vector<CellularTickIntents::Birth> births;
|
|
for (const auto& tick : batch.ticks)
|
|
births.insert(births.end(), tick.births.begin(), tick.births.end());
|
|
return births;
|
|
}
|
|
|
|
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
|
|
|
|
network::AdmitStatus admit_status(CellularMutationAdmission admission) noexcept {
|
|
switch (admission) {
|
|
case CellularMutationAdmission::admitted:
|
|
return network::AdmitStatus::admitted;
|
|
case CellularMutationAdmission::not_ready:
|
|
return network::AdmitStatus::not_ready;
|
|
case CellularMutationAdmission::busy:
|
|
return network::AdmitStatus::too_many_unresolved;
|
|
case CellularMutationAdmission::final:
|
|
return network::AdmitStatus::duplicate;
|
|
case CellularMutationAdmission::invalid:
|
|
case CellularMutationAdmission::conflict:
|
|
break;
|
|
}
|
|
return network::AdmitStatus::invalid_action;
|
|
}
|
|
|
|
network::ActionOutcome action_outcome(const FinalCellularMutation& mutation) noexcept {
|
|
return {mutation.action_id,
|
|
mutation.result == CellularMutationResult::applied
|
|
? network::ActionResult::committed
|
|
: network::ActionResult::committed_no_effect,
|
|
mutation.tick, mutation.commit_sequence};
|
|
}
|
|
|
|
network::CellularMutationOffer offer_view(const CellularOwnedLife& life, std::uint64_t tick) {
|
|
network::CellularMutationOffer view{tick, life.identity.life, 0, 0, {}};
|
|
const auto& offer = life.mutation.offer;
|
|
if (!offer)
|
|
return view;
|
|
view.event_index = life.mutation.event_index;
|
|
view.offer_tick = life.mutation.offer_tick;
|
|
for (const auto& candidate : offer->candidates)
|
|
if (view.candidates.size() < network::max_cellular_offered_candidates)
|
|
view.candidates.push_back(
|
|
{candidate.operator_id, static_cast<std::uint8_t>(candidate.target),
|
|
static_cast<std::uint8_t>(candidate.effect), candidate.parameter,
|
|
candidate.maintenance, candidate.total_mass});
|
|
std::ranges::sort(view.candidates, {}, &network::CellularOfferedCandidate::operator_id);
|
|
return view;
|
|
}
|
|
|
|
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);
|
|
queued_mutations_.clear();
|
|
mutations_uncertain_ = true; // Reserved choices are reloaded under the new lease.
|
|
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});
|
|
finalize_births(pending_->births);
|
|
finalize_mutations(pending_->mutation_actions, pending_->prepared.results);
|
|
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();
|
|
if (!pending_ && state_ && mutations_uncertain_ && status_.phase == HostPhase::running)
|
|
reload_mutations();
|
|
refresh();
|
|
return status_;
|
|
}
|
|
|
|
void CellularRegionHost::reload_mutations() {
|
|
const auto grant = authority_.grant();
|
|
if (!grant || !committed_ || !database())
|
|
return;
|
|
auto pending = persistence::load_pending_cellular_mutations(*db_, config_.key, *grant,
|
|
config_.lease.commit_timeout);
|
|
if (!pending) {
|
|
if (pending.error().kind == persistence::LifeReservationError::fenced) {
|
|
authority_.fence();
|
|
status_.ready = false;
|
|
}
|
|
db_.reset();
|
|
++status_.store_failures;
|
|
return;
|
|
}
|
|
// Every reservation targets the tick after the head it was made at, and SQL refuses a
|
|
// checkpoint that skips one, so an unbound choice is always for the next tick.
|
|
queued_mutations_.clear();
|
|
for (const auto& reservation : *pending)
|
|
if (reservation.target_tick == committed_->head.end_tick + 1)
|
|
queued_mutations_.push_back(reservation);
|
|
mutations_uncertain_ = false;
|
|
}
|
|
|
|
void CellularRegionHost::finalize_mutations(std::span<const CellularMutationActionRecord> actions,
|
|
std::span<const std::uint8_t> results) {
|
|
if (!committed_)
|
|
return;
|
|
const auto sequence = committed_->head.sequence;
|
|
for (std::size_t i = 0; i < actions.size() && i < results.size(); ++i) {
|
|
const auto& action = actions[i];
|
|
std::erase_if(queued_mutations_, [&](const auto& queued) {
|
|
return queued.account == action.account && queued.action_id == action.action_id;
|
|
});
|
|
const FinalCellularMutation done{action.account, action.action_id, action.tick, sequence,
|
|
static_cast<CellularMutationResult>(results[i])};
|
|
finalized_mutations_.push_back(done);
|
|
std::erase_if(recent_mutations_,
|
|
[&](const auto& recent) { return recent.account == done.account; });
|
|
if (recent_mutations_.size() >= 1024)
|
|
recent_mutations_.erase(recent_mutations_.begin());
|
|
recent_mutations_.push_back(done);
|
|
}
|
|
}
|
|
|
|
std::vector<FinalCellularMutation> CellularRegionHost::take_finalized_mutations() {
|
|
return std::exchange(finalized_mutations_, {});
|
|
}
|
|
|
|
CellularMutationReply
|
|
CellularRegionHost::select_mutation(const persistence::Uuid& account, std::uint64_t generation,
|
|
std::uint64_t action_id,
|
|
const CellularMutationActionInput& input) {
|
|
using enum CellularMutationAdmission;
|
|
if (account == persistence::Uuid{} || generation == 0 || action_id == 0)
|
|
return {invalid, 0, {}};
|
|
if (const auto recent = std::ranges::find_if(recent_mutations_,
|
|
[&](const auto& done) {
|
|
return done.account == account &&
|
|
done.action_id == action_id;
|
|
});
|
|
recent != recent_mutations_.end())
|
|
return {final, recent->tick, *recent};
|
|
if (!status_.ready || mutations_uncertain_ || pending_ || !state_ || !committed_ ||
|
|
!authority_.may_begin_commit(LeaseClock::now()) || !database())
|
|
return {not_ready, 0, {}};
|
|
const auto tick = committed_->head.end_tick + 1;
|
|
const CellularMutationActionRecord record{account, action_id, tick, input};
|
|
const auto bytes = encode_cellular_mutation_input(record);
|
|
for (const auto& queued : queued_mutations_) {
|
|
if (queued.account != account)
|
|
continue;
|
|
if (queued.action_id != action_id)
|
|
return {busy, queued.target_tick, {}};
|
|
return queued.input == bytes ? CellularMutationReply{admitted, tick, {}}
|
|
: CellularMutationReply{conflict, 0, {}};
|
|
}
|
|
// The choice must name this account's living cell and its exact outstanding offer.
|
|
const auto life = std::ranges::find(state_->lives(), account, &CellularOwnedLife::account);
|
|
if (life == state_->lives().end() || life->identity.life != input.life_id ||
|
|
input.event_index == 0 || life->mutation.event_index != input.event_index ||
|
|
life->mutation.offer_tick != input.offer_tick || input.offer_tick >= tick)
|
|
return {invalid, 0, {}};
|
|
const auto& offer = life->mutation.offer;
|
|
if (!offer || !std::ranges::any_of(offer->candidates, [&](const auto& candidate) {
|
|
return candidate.operator_id == input.operator_id;
|
|
}))
|
|
return {invalid, 0, {}};
|
|
const auto grant = authority_.grant();
|
|
if (!grant)
|
|
return {not_ready, 0, {}};
|
|
auto reserved =
|
|
persistence::reserve_cellular_mutation(*db_, config_.key, *grant, account, generation,
|
|
action_id, bytes, config_.lease.commit_timeout);
|
|
if (!reserved) {
|
|
switch (reserved.error().kind) {
|
|
case persistence::LifeReservationError::pending_mutation:
|
|
return {busy, 0, {}};
|
|
case persistence::LifeReservationError::identity_conflict:
|
|
return {conflict, 0, {}};
|
|
case persistence::LifeReservationError::fenced:
|
|
authority_.fence();
|
|
status_.ready = false;
|
|
return {not_ready, 0, {}};
|
|
case persistence::LifeReservationError::unknown:
|
|
case persistence::LifeReservationError::store:
|
|
// The reservation may have committed: nothing publishes until it is reloaded.
|
|
mutations_uncertain_ = true;
|
|
db_.reset();
|
|
++status_.store_failures;
|
|
return {not_ready, 0, {}};
|
|
default:
|
|
return {invalid, 0, {}};
|
|
}
|
|
}
|
|
if (reserved->region != config_.key.region || reserved->target_tick != tick ||
|
|
reserved->input != bytes) {
|
|
mutations_uncertain_ = true;
|
|
return {not_ready, 0, {}};
|
|
}
|
|
queued_mutations_.push_back(*reserved);
|
|
return {admitted, tick, {}};
|
|
}
|
|
|
|
std::expected<persistence::PublishedCellularBatch, CellularPublishFailure>
|
|
CellularRegionHost::publish(const CellularBatch& batch,
|
|
std::span<const CellularActionRecord> actions,
|
|
std::span<const CellularMutationActionRecord> mutation_actions) {
|
|
const auto grant = authority_.grant();
|
|
if (!status_.ready || mutations_uncertain_ || !state_ || !committed_ || !grant ||
|
|
!authority_.may_begin_commit(LeaseClock::now()))
|
|
return std::unexpected{CellularPublishFailure{CellularHostError::not_ready, {}, {}, {}}};
|
|
auto candidate = replay_cellular_batch(*state_, batch);
|
|
if (!candidate)
|
|
return std::unexpected{
|
|
CellularPublishFailure{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{
|
|
CellularPublishFailure{CellularHostError::invalid_batch, {}, {}, {}}};
|
|
auto published = persistence::publish_cellular_batch(
|
|
*db_, *objects_, grant.value_or(persistence::LeaseGrant{}), *committed_, batch, **candidate,
|
|
*commit, config_.build, config_.lease.commit_timeout, {}, actions, mutation_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()},
|
|
births_in(batch),
|
|
{mutation_actions.begin(), mutation_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;
|
|
} else {
|
|
mutations_uncertain_ = true; // A refusal may name a choice the queue lacks.
|
|
}
|
|
return std::unexpected{
|
|
CellularPublishFailure{CellularHostError::publication, published.error().kind,
|
|
published.error().store, published.error().object}};
|
|
}
|
|
state_ = std::move(*candidate);
|
|
committed_ = published->committed;
|
|
for (const auto& action : actions)
|
|
finalized_actions_.push_back({action, committed_->head.sequence});
|
|
const auto births = births_in(batch);
|
|
finalize_births(births);
|
|
std::vector<std::uint8_t> results;
|
|
results.reserve(published->mutation_results.size());
|
|
for (const auto result : published->mutation_results)
|
|
results.push_back(static_cast<std::uint8_t>(result));
|
|
finalize_mutations(mutation_actions, results);
|
|
++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;
|
|
}
|
|
|
|
void CellularRegionHost::queue_birth(const CellularTickIntents::Birth& birth) {
|
|
const auto found = std::ranges::find_if(queued_births_, [&](const auto& queued) {
|
|
return queued.account == birth.account && queued.request == birth.request;
|
|
});
|
|
if (found == queued_births_.end())
|
|
queued_births_.push_back(birth);
|
|
}
|
|
|
|
void CellularRegionHost::finalize_births(std::span<const CellularTickIntents::Birth> births) {
|
|
for (const auto& birth : births)
|
|
std::erase_if(queued_births_, [&](const auto& queued) {
|
|
return queued.account == birth.account && queued.request == birth.request &&
|
|
queued.generation == birth.generation && queued.identity == birth.identity;
|
|
});
|
|
}
|
|
|
|
network::PrimitiveLifeOutcome CellularRegionHost::query_birth(const persistence::Uuid& account,
|
|
std::uint64_t generation,
|
|
std::uint64_t request, bool enqueue) {
|
|
using network::PrimitiveLifeResult;
|
|
const auto unknown = [&] {
|
|
return network::PrimitiveLifeOutcome{request, PrimitiveLifeResult::unknown, 0, 0};
|
|
};
|
|
if (!status_.ready || !authority_.may_begin_commit(LeaseClock::now()) ||
|
|
account == persistence::Uuid{} || generation == 0 || request == 0 || !database())
|
|
return unknown();
|
|
const auto grant = authority_.grant();
|
|
if (!grant)
|
|
return unknown();
|
|
auto queried = persistence::query_primitive_life(*db_, config_.key, *grant, account, generation,
|
|
request, config_.lease.commit_timeout);
|
|
if (!queried) {
|
|
if (queried.error().kind == persistence::LifeReservationError::unknown ||
|
|
queried.error().kind == persistence::LifeReservationError::store)
|
|
db_.reset();
|
|
if (queried.error().kind == persistence::LifeReservationError::fenced) {
|
|
authority_.fence();
|
|
status_.ready = false;
|
|
}
|
|
return unknown();
|
|
}
|
|
if (!queried->has_value())
|
|
return unknown();
|
|
const auto outcome = queried->value_or(persistence::PrimitiveLifeOutcome{});
|
|
if (outcome.published)
|
|
return {request, PrimitiveLifeResult::born, outcome.published->identity,
|
|
outcome.published->commit_sequence};
|
|
if (outcome.reservation.region != config_.key.region)
|
|
return unknown();
|
|
const auto result = life_result(outcome.reservation.refusal);
|
|
if (result == PrimitiveLifeResult::pending && enqueue)
|
|
queue_birth({account, request, generation, outcome.reservation.identity});
|
|
return {request, result, outcome.reservation.identity, 0};
|
|
}
|
|
|
|
network::PrimitiveLifeOutcome
|
|
CellularRegionHost::create_primitive_life(const persistence::Uuid& account,
|
|
std::uint64_t generation, std::uint64_t request) {
|
|
using network::PrimitiveLifeResult;
|
|
const auto existing = query_birth(account, generation, request, true);
|
|
if (existing.result != PrimitiveLifeResult::unknown)
|
|
return existing;
|
|
if (!status_.ready || !authority_.may_begin_commit(LeaseClock::now()) || !database())
|
|
return {request, PrimitiveLifeResult::unknown, 0, 0};
|
|
const auto grant = authority_.grant();
|
|
if (!grant)
|
|
return {request, PrimitiveLifeResult::unknown, 0, 0};
|
|
auto reserved = persistence::reserve_primitive_life(
|
|
*db_, config_.key, *grant, account, generation, request, biology::founder_life_rules,
|
|
config_.lease.commit_timeout);
|
|
if (!reserved) {
|
|
if (reserved.error().kind == persistence::LifeReservationError::unknown ||
|
|
reserved.error().kind == persistence::LifeReservationError::store)
|
|
db_.reset();
|
|
if (reserved.error().kind == persistence::LifeReservationError::fenced) {
|
|
authority_.fence();
|
|
status_.ready = false;
|
|
}
|
|
return {request, PrimitiveLifeResult::unknown, 0, 0};
|
|
}
|
|
if (reserved->region != config_.key.region)
|
|
return {request, PrimitiveLifeResult::unknown, reserved->identity, 0};
|
|
const auto result = life_result(reserved->refusal);
|
|
if (result == PrimitiveLifeResult::pending)
|
|
queue_birth({account, request, generation, reserved->identity});
|
|
return {request, result, reserved->identity, 0};
|
|
}
|
|
|
|
network::PrimitiveLifeOutcome
|
|
CellularRegionHost::query_primitive_life(const persistence::Uuid& account, std::uint64_t generation,
|
|
std::uint64_t request) {
|
|
return query_birth(account, generation, request, true);
|
|
}
|
|
|
|
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()) {
|
|
// Best effort during shutdown; the lease expires if release cannot be confirmed.
|
|
[[maybe_unused]] const auto released = 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
|