Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m56s
Foundation / checks (checks) (push) Failing after 3m58s
Foundation / checks (tsan) (push) Canceled after 0s
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 6m18s
Foundation / checks (postgres) (push) Canceled after 2m23s
Foundation / checks (network) (push) Canceled after 4m19s
280 lines
13 KiB
C++
280 lines
13 KiB
C++
#include "evo/server/cellular_session_batch.hpp"
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using namespace evo;
|
|
using namespace evo::server;
|
|
|
|
void check(bool value, std::source_location at = std::source_location::current()) {
|
|
if (!value)
|
|
throw std::runtime_error("cellular session batch line " + std::to_string(at.line()));
|
|
}
|
|
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
|
|
|
accounting::Inventory founder_price(std::uint64_t count) {
|
|
const auto endowment = biology::primitive_endowment();
|
|
CHECK(endowment);
|
|
auto funding = endowment->body;
|
|
funding.energy.value = endowment->reserve.energy.value + endowment->construction.value;
|
|
funding.energy.value *= count;
|
|
for (auto& channel : funding.matter)
|
|
channel.value *= count;
|
|
return funding;
|
|
}
|
|
|
|
void actions_bind_to_owned_life_and_preserve_other_inputs() {
|
|
auto primitive = PrimitiveLives::create({90, 1, 7, 17, founder_price(2), {{0, 0}, {20, 0}}});
|
|
CHECK(primitive);
|
|
LifeRequest request{};
|
|
request.account.back() = 1;
|
|
request.action = 1;
|
|
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
|
|
request.account.back() = 2;
|
|
CHECK((*primitive)->spawn(request, {2, 102, 202, 302, {1}}));
|
|
|
|
biology::CellularHabitatConfig habitat_config{
|
|
90,
|
|
1,
|
|
7,
|
|
20'000,
|
|
20'000,
|
|
{{{0, 0}, 29, {{10}, {{{10}, {10}, {10}, {10}}}}},
|
|
{{15'000, 15'000}, 30, {{10}, {{{10}, {10}, {10}, {10}}}}}}};
|
|
auto habitat = biology::CellularHabitat::create(std::move(habitat_config));
|
|
CHECK(habitat);
|
|
auto state =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{20'000, 20'000}, 1, 293'150});
|
|
CHECK(state && (*state)->lives().size() == 2);
|
|
|
|
const auto& controlled = (*state)->lives()[0];
|
|
const auto& other = (*state)->lives()[1];
|
|
const auto visible = (*state)->perceive(controlled.identity.life);
|
|
CHECK(visible && visible->size() == 1 &&
|
|
visible->front().address == (biology::CellularPatchAddress{0, 0}));
|
|
const std::array baseline{CellularLifeIntent{controlled.identity.life, {{5, 6}, {}}},
|
|
CellularLifeIntent{other.identity.life, {{7, 8}, {}}}};
|
|
const auto input = network::encode_cellular_action_input({2, -3, 4, true, 0, 0});
|
|
network::CarriedAction action{network::AccountId{controlled.account}, 77, 2,
|
|
network::ActionKind::cellular, input};
|
|
const std::array actions{action};
|
|
const auto prepared = prepare_cellular_session_tick(**state, 2, baseline, actions);
|
|
CHECK(prepared && prepared->intents.lives.size() == 2 && prepared->actions.size() == 1);
|
|
CHECK(prepared->intents.lives[0] ==
|
|
CellularLifeIntent{controlled.identity.life,
|
|
{{-3, 4}, biology::CellularPatchAddress{0, 0}}});
|
|
CHECK(prepared->intents.lives[1] == baseline[1]);
|
|
CHECK(prepared->actions[0] == CellularActionRecord{controlled.account, 77, input});
|
|
|
|
const auto guessed_input =
|
|
network::encode_cellular_action_input({2, 0, 0, true, 15'000, 15'000});
|
|
const network::CarriedAction guessed{network::AccountId{controlled.account}, 78, 2,
|
|
network::ActionKind::cellular, guessed_input};
|
|
const std::array guessed_actions{guessed};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, guessed_actions).error() ==
|
|
CellularSessionBatchError::unperceived_target);
|
|
|
|
CellularBatch batch;
|
|
batch.header = {(*state)->world(), (*state)->region(), (*state)->frame(), {}, {}, 1, 2};
|
|
batch.header.predecessor.fill(1);
|
|
batch.header.predecessor_digest.fill(2);
|
|
batch.ticks.push_back(prepared->intents);
|
|
CHECK(match_cellular_actions_to_trace(**state, batch, prepared->actions));
|
|
|
|
persistence::RegionHead head{};
|
|
head.frame = (*state)->frame();
|
|
head.sequence = 4;
|
|
head.end_tick = (*state)->tick();
|
|
head.commit.fill(1);
|
|
head.digest.fill(2);
|
|
auto builder = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(builder);
|
|
CHECK(builder->append(2, baseline, actions));
|
|
std::vector<CellularLifeIntent> next_baseline;
|
|
for (const auto& life : builder->candidate().lives())
|
|
next_baseline.push_back({life.identity.life, {}});
|
|
CHECK(builder->append(3, next_baseline, {}));
|
|
CHECK(builder->batch().header.begin_tick == 1 && builder->batch().header.end_tick == 3 &&
|
|
builder->batch().ticks.size() == 2);
|
|
CHECK(builder->actions().size() == 1 && builder->actions()[0] == prepared->actions[0]);
|
|
const auto replayed = replay_cellular_batch(**state, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
const auto repeated_input = network::encode_cellular_action_input({4, 0, 0, false, 0, 0});
|
|
const network::CarriedAction repeated{network::AccountId{controlled.account}, 77, 4,
|
|
network::ActionKind::cellular, repeated_input};
|
|
const std::array repeated_actions{repeated};
|
|
CHECK(builder->append(4, next_baseline, repeated_actions).error() ==
|
|
CellularSessionBatchError::duplicate_action);
|
|
CHECK(builder->append(5, next_baseline, {}).error() == CellularSessionBatchError::tick);
|
|
|
|
auto wrong_head = head;
|
|
++wrong_head.end_tick;
|
|
CHECK(CellularSessionBatchBuilder::create(**state, wrong_head).error() ==
|
|
CellularSessionBatchError::head);
|
|
|
|
auto altered = baseline;
|
|
altered[1].intent.movement.x = 10;
|
|
const auto preserved = prepare_cellular_session_tick(**state, 2, altered, actions);
|
|
CHECK(preserved && preserved->intents.lives[1].intent.movement.x == 10);
|
|
|
|
CHECK(prepare_cellular_session_tick(**state, 3, baseline, actions).error() ==
|
|
CellularSessionBatchError::tick);
|
|
CHECK(
|
|
prepare_cellular_session_tick(**state, 2, std::span{baseline}.first(1), actions).error() ==
|
|
CellularSessionBatchError::intents);
|
|
|
|
const std::array duplicate{action, action};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, duplicate).error() ==
|
|
CellularSessionBatchError::duplicate_action);
|
|
auto unknown = action;
|
|
unknown.account.bytes.back() = 3;
|
|
const std::array unknown_actions{unknown};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, unknown_actions).error() ==
|
|
CellularSessionBatchError::life);
|
|
auto malformed = action;
|
|
malformed.cellular_input = std::array<std::uint8_t, network::cellular_action_input_bytes>{};
|
|
const std::array malformed_actions{malformed};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, malformed_actions).error() ==
|
|
CellularSessionBatchError::action);
|
|
}
|
|
|
|
void durable_mutation_reservations_bind_to_the_exact_offer() {
|
|
auto primitive = PrimitiveLives::create({93, 1, 1, 17, founder_price(1), {{0, 0}}});
|
|
CHECK(primitive);
|
|
LifeRequest request{};
|
|
request.account.back() = 3;
|
|
request.action = 1;
|
|
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
|
|
accounting::Inventory stock{{1'000'000'000'000ULL},
|
|
{{{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL}}}};
|
|
auto habitat = biology::CellularHabitat::create(
|
|
{93, 1, 1, 1'000, 1'000, {{{0, 0}, 29, stock}}});
|
|
CHECK(habitat);
|
|
auto created = CellularLives::create(**primitive, std::move(*habitat),
|
|
{{1'000, 1'000}, 1, 293'150});
|
|
CHECK(created && (*created)->lives().size() == 1);
|
|
auto& owner = **created;
|
|
const auto life_id = owner.lives()[0].identity.life;
|
|
bool offered = false;
|
|
for (std::size_t tick = 0; tick < 10'000 && !offered; ++tick) {
|
|
const std::array intent{CellularLifeIntent{life_id, {{0, 0}, {{0, 0}}}}};
|
|
CHECK(owner.advance_tick(intent));
|
|
const auto current_offer = owner.mutation_offer(life_id);
|
|
CHECK(current_offer);
|
|
offered = current_offer->has_value();
|
|
}
|
|
CHECK(offered);
|
|
auto revision_owner = owner.migrate_to_v3();
|
|
CHECK(revision_owner);
|
|
const auto offer = (*revision_owner)->mutation_offer(life_id);
|
|
CHECK(offer && *offer && !(*offer)->candidates.empty());
|
|
const auto& live = (*revision_owner)->lives()[0];
|
|
const auto action_tick = (*revision_owner)->tick() + 1;
|
|
const auto& candidate = (*offer)->candidates.front();
|
|
persistence::CellularMutationReservation reservation;
|
|
reservation.account = live.account;
|
|
reservation.action_id = 42;
|
|
reservation.region = (*revision_owner)->region();
|
|
reservation.generation = 7;
|
|
reservation.target_tick = action_tick;
|
|
reservation.successor_identity = 999;
|
|
const auto put_field = [&](std::size_t offset, std::uint64_t value, std::size_t bytes) {
|
|
for (std::size_t i = 0; i < bytes; ++i)
|
|
reservation.input[offset + i] = static_cast<std::uint8_t>(value >> (i * 8U));
|
|
};
|
|
put_field(0, action_tick, 8);
|
|
put_field(8, life_id, 8);
|
|
put_field(16, live.mutation.event_index, 8);
|
|
put_field(24, live.mutation.offer_tick, 8);
|
|
put_field(32, candidate.operator_id, 2);
|
|
|
|
persistence::RegionHead head{};
|
|
head.frame = (*revision_owner)->frame();
|
|
head.sequence = 3;
|
|
head.end_tick = (*revision_owner)->tick();
|
|
head.commit.fill(0x31);
|
|
head.digest.fill(0x41);
|
|
auto builder = CellularSessionBatchBuilder::create(**revision_owner, head);
|
|
CHECK(builder);
|
|
const std::array baseline{CellularLifeIntent{life_id, {}}};
|
|
const std::array reservations{reservation};
|
|
CHECK(builder->append(action_tick, baseline, {}, {}, reservations));
|
|
const CellularMutationActionRecord expected_action{
|
|
live.account, reservation.action_id, action_tick,
|
|
{life_id, live.mutation.event_index, live.mutation.offer_tick, candidate.operator_id}};
|
|
CHECK(builder->batch().ticks.back().mutations ==
|
|
std::vector{CellularMutationSelection{life_id, live.mutation.event_index,
|
|
live.mutation.offer_tick,
|
|
reservation.successor_identity,
|
|
candidate.operator_id}} &&
|
|
builder->mutation_actions().size() == 1 &&
|
|
builder->mutation_actions().front() == expected_action &&
|
|
match_cellular_mutation_actions_to_trace(**revision_owner, builder->batch(),
|
|
builder->mutation_actions()));
|
|
const auto replayed = replay_cellular_batch(**revision_owner, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
|
|
auto stale_builder = CellularSessionBatchBuilder::create(**revision_owner, head);
|
|
CHECK(stale_builder);
|
|
auto stale = reservation;
|
|
stale.input[24] ^= 1U;
|
|
const std::array stale_reservations{stale};
|
|
CHECK(stale_builder->append(action_tick, baseline, {}, {}, stale_reservations).error() ==
|
|
CellularSessionBatchError::mutation);
|
|
CHECK(stale_builder->candidate().snapshot() == (*revision_owner)->snapshot());
|
|
}
|
|
|
|
void builder_batches_reserved_birth_after_empty_tick() {
|
|
auto primitive = PrimitiveLives::create({93, 1, 1, 17, founder_price(1), {{0, 0}}});
|
|
CHECK(primitive);
|
|
auto habitat = biology::CellularHabitat::create({93, 1, 1, 1'000, 1'000, {}});
|
|
CHECK(habitat);
|
|
auto state =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
|
|
CHECK(state && (*state)->lives().empty());
|
|
persistence::RegionHead head{};
|
|
head.frame = 1;
|
|
head.commit.fill(1);
|
|
head.digest.fill(2);
|
|
auto builder = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(builder);
|
|
|
|
CellularTickIntents::Birth birth{};
|
|
birth.account.back() = 8;
|
|
birth.request = 13;
|
|
birth.generation = 4;
|
|
birth.identity = 901;
|
|
const std::array births{birth};
|
|
const std::span<const CellularLifeIntent> no_lives{};
|
|
CHECK(builder->append(1, no_lives, {}, births));
|
|
CHECK(builder->candidate().tick() == 1 && builder->candidate().lives().size() == 1 &&
|
|
builder->batch().ticks[0].births == std::vector{birth} && (*state)->lives().empty());
|
|
const auto replayed = replay_cellular_batch(**state, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
const auto snapshot = builder->candidate().snapshot();
|
|
const std::array next_lives{CellularLifeIntent{901, {}}};
|
|
CHECK(builder->append(2, next_lives, {}, births).error() ==
|
|
CellularSessionBatchError::duplicate_birth);
|
|
CHECK(builder->candidate().snapshot() == snapshot && builder->batch().ticks.size() == 1);
|
|
}
|
|
} // namespace
|
|
|
|
int main() try {
|
|
actions_bind_to_owned_life_and_preserve_other_inputs();
|
|
durable_mutation_reservations_bind_to_the_exact_offer();
|
|
builder_batches_reserved_birth_after_empty_tick();
|
|
std::puts("cellular session batch: ok");
|
|
} catch (const std::exception& e) {
|
|
std::fprintf(stderr, "%s\n", e.what());
|
|
return 1;
|
|
}
|