Queue durable cellular first-life requests
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 39s
Foundation / checks (ecs) (push) Successful in 1m53s
Foundation / checks (postgres) (push) Failing after 51s
Foundation / checks (tsan) (push) Failing after 33s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (network) (push) Canceled after 3m4s
Foundation / checks (client) (push) Canceled after 3m37s

This commit is contained in:
dingo
2026-10-11 00:55:06 -04:00
parent 9c84c8f5b4
commit 0fbba51204
4 changed files with 169 additions and 9 deletions
+122 -1
View File
@@ -1,5 +1,6 @@
#include "evo/server/cellular_region_host.hpp"
#include "evo/biology/founder.hpp"
#include "evo/persistence/sha256.hpp"
#include <algorithm>
@@ -12,6 +13,7 @@ struct CellularRegionHost::Pending {
persistence::CellularPreparedCommit prepared;
std::unique_ptr<CellularLives> candidate;
std::vector<CellularActionRecord> actions;
std::vector<CellularTickIntents::Birth> births;
};
namespace {
@@ -25,6 +27,29 @@ bool valid(const CellularHostConfig& config) {
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) {
@@ -238,6 +263,7 @@ void CellularRegionHost::resolve() {
committed_ = std::move(*retried);
for (const auto& action : pending_->actions)
finalized_actions_.push_back({action, committed_->head.sequence});
finalize_births(pending_->births);
pending_.reset();
++status_.commits;
status_.committed_sequence = committed_->head.sequence;
@@ -296,7 +322,7 @@ CellularRegionHost::publish(const CellularBatch& batch,
if (published.error().kind == persistence::PublicationError::unknown) {
pending_ = std::make_unique<Pending>(
Pending{published.error().prepared, std::move(*candidate),
{actions.begin(), actions.end()}});
{actions.begin(), actions.end()}, births_in(batch)});
status_.phase = HostPhase::resolving;
status_.ready = false;
++status_.unknown_outcomes;
@@ -315,6 +341,8 @@ CellularRegionHost::publish(const CellularBatch& batch,
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);
++status_.commits;
status_.committed_sequence = committed_->head.sequence;
status_.committed_tick = committed_->head.end_tick;
@@ -323,6 +351,99 @@ CellularRegionHost::publish(const CellularBatch& batch,
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();
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_, {});
}