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
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:
@@ -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_, {});
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user