Add M10.4c evo-server QUIC listener and headless session client
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m46s
Foundation / checks (postgres) (push) Canceled after 0s
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 (checks) (push) Canceled after 3m44s
Foundation / checks (client) (push) Canceled after 3m49s
Foundation / checks (network) (push) Canceled after 1m59s
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m46s
Foundation / checks (postgres) (push) Canceled after 0s
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 (checks) (push) Canceled after 3m44s
Foundation / checks (client) (push) Canceled after 3m49s
Foundation / checks (network) (push) Canceled after 1m59s
evo-server gains an opt-in M10 listener (--m10-*, QUIC builds only): RegionSessions with the PostgreSQL control and action ledgers on their own connection under the host's lease, carried actions submitted to the host and its acknowledgements and drops turned into outcomes. evo-session-probe is a dev-only headless client. Real process tests cover intentions, durable action outcomes, SIGKILL before and after an action's commit, duplicate retries and the probe. The simulated watermark now reaches every session every tick, so clients always know the server tick. ADR-0092. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -208,7 +208,15 @@ void serials_takeover_and_fencing() {
|
||||
#ifdef EVO_POSTGRES_SESSIONS
|
||||
// The session layer's ledger over these functions.
|
||||
std::optional<LeaseGrant> current = restarted;
|
||||
evo::server::PostgresControlLedger ledger{*db, a, [&] { return current; }};
|
||||
evo::server::PgSlot slot{PgOptions{env("PGHOST"),
|
||||
{},
|
||||
env("PGPORT"),
|
||||
env("PGDATABASE"),
|
||||
env("EVO_PG_RUNTIME_USER"),
|
||||
{},
|
||||
{}},
|
||||
5s};
|
||||
evo::server::PostgresControlLedger ledger{slot, a, [&] { return current; }};
|
||||
evo::network::AccountId dave;
|
||||
dave.bytes = id(0x35);
|
||||
auto claimed = ledger.claim(dave, 1, 9);
|
||||
|
||||
@@ -491,8 +491,19 @@ void durable_actions() {
|
||||
CHECK(b.query(1, {99}, f).result == ActionResult::unknown);
|
||||
}
|
||||
|
||||
// The watermark sent to one session, if any.
|
||||
std::optional<SimulatedThrough>
|
||||
mark_of(const std::vector<std::pair<std::uint64_t, SimulatedThrough>>& marks,
|
||||
std::uint64_t session) {
|
||||
for (const auto& [s, m] : marks)
|
||||
if (s == session)
|
||||
return m;
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
void intent_admission() {
|
||||
IntentLimits limits;
|
||||
limits.watermark_every = 20; // Exercise the repeat interval.
|
||||
limits.max_unresolved = 6;
|
||||
limits.max_finals = 4;
|
||||
CHECK(refused(IntentAdmission::create(IntentLimits{0}), IntentConfigError::invalid));
|
||||
@@ -526,15 +537,23 @@ void intent_admission() {
|
||||
// Simulated watermark: only intentions whose tick ran, cumulatively.
|
||||
f.server_tick = 109;
|
||||
auto marks = a.simulated(f);
|
||||
CHECK(marks.size() == 1 && marks[0].first == 1 &&
|
||||
marks[0].second == SimulatedThrough{5, 2, 109});
|
||||
CHECK(a.simulated(f).empty()); // Unchanged: not repeated yet.
|
||||
CHECK(mark_of(marks, 1) == SimulatedThrough{5, 2, 109});
|
||||
CHECK(mark_of(marks, 2) == SimulatedThrough{5, 0, 109}); // Bob: the tick, no intention.
|
||||
CHECK(a.simulated(f).empty()); // Unchanged: not repeated yet.
|
||||
f.server_tick = 110;
|
||||
marks = a.simulated(f);
|
||||
CHECK(marks.size() == 1 && marks[0].second.sequence == 3);
|
||||
CHECK(marks.size() == 1 && mark_of(marks, 1) == SimulatedThrough{5, 3, 110}); // Bob: not
|
||||
// repeated.
|
||||
f.server_tick = 130;
|
||||
marks = a.simulated(f); // Repeated after 20 ticks so a lost datagram is covered.
|
||||
CHECK(marks.size() == 1 && marks[0].second == SimulatedThrough{5, 3, 130});
|
||||
CHECK(mark_of(marks, 1) == SimulatedThrough{5, 3, 130} &&
|
||||
mark_of(marks, 2) == SimulatedThrough{5, 0, 130});
|
||||
// By default every session hears every simulated tick.
|
||||
auto every = *IntentAdmission::create(IntentLimits{});
|
||||
CHECK(every.open(7, alice));
|
||||
for (std::uint64_t tick = 1; tick <= 3; ++tick)
|
||||
CHECK(mark_of(every.simulated({true, 5, tick}), 7) == SimulatedThrough{5, 0, tick});
|
||||
CHECK(every.simulated({true, 5, 3}).empty());
|
||||
|
||||
// Actions: receipt, carried with its tick's batch, final after the commit.
|
||||
const auto action = [&](std::uint64_t session, std::uint64_t id, std::uint64_t tick,
|
||||
|
||||
@@ -12,6 +12,9 @@ void run_region_server_process_tests();
|
||||
#ifdef EVO_POSTGRES_SESSIONS
|
||||
void run_region_session_tests();
|
||||
#endif
|
||||
#ifdef EVO_POSTGRES_M10
|
||||
void run_region_m10_session_tests();
|
||||
#endif
|
||||
void run_region_recovery_tests();
|
||||
void run_region_ops_tests();
|
||||
void run_region_clone_tests();
|
||||
@@ -130,6 +133,9 @@ int main() {
|
||||
#ifdef EVO_POSTGRES_SESSIONS
|
||||
run_region_session_tests();
|
||||
std::puts("region dev session integration passed");
|
||||
#endif
|
||||
#ifdef EVO_POSTGRES_M10
|
||||
run_region_m10_session_tests();
|
||||
#endif
|
||||
run_region_recovery_tests();
|
||||
std::puts("region recovery integration passed");
|
||||
|
||||
@@ -378,11 +378,14 @@ void intentions_and_actions(const Files& f) {
|
||||
auto a = h.connect(h.issuer.grant(alice, 1));
|
||||
CHECK(h.settled(*a) && must(a->welcome()).server_tick == 100 && a->server_tick() == 100);
|
||||
// Intention: a receipt, then the simulated watermark once its tick runs.
|
||||
CHECK(a->send_intention(101, 10, -10) == 1u);
|
||||
// Datagrams may be refused until the QUIC datagram extension is negotiated: retry.
|
||||
std::optional<std::uint64_t> first;
|
||||
CHECK(h.until([&] { return (first = a->send_intention(101, 10, -10)).has_value(); }));
|
||||
CHECK(first == 1u);
|
||||
std::vector<IntentionReceipt> receipts;
|
||||
CHECK(h.until([&] { return !(receipts = a->take_intention_receipts()).empty(); }));
|
||||
CHECK(receipts[0] == IntentionReceipt{1, AdmitStatus::admitted, 100});
|
||||
CHECK(!a->simulated());
|
||||
CHECK(a->simulated().value_or(SimulatedThrough{}).sequence == 0); // Ticks only, so far.
|
||||
CHECK(a->send_intention(150, 0, 0) == 2u);
|
||||
CHECK(h.until([&] { return !(receipts = a->take_intention_receipts()).empty(); }));
|
||||
CHECK(receipts[0].status == AdmitStatus::outside_window);
|
||||
@@ -434,7 +437,7 @@ void intentions_and_actions(const Files& f) {
|
||||
CHECK(h.until([&] { return !(outcomes = c->take_action_outcomes()).empty(); }));
|
||||
CHECK(outcomes[0].result == ActionResult::not_committed);
|
||||
// Intentions of an old epoch are refused.
|
||||
CHECK(c->send_intention(h.tick + 1, 0, 0));
|
||||
CHECK(h.until([&] { return c->send_intention(h.tick + 1, 0, 0).has_value(); }));
|
||||
CHECK(h.until([&] { return !(receipts = c->take_intention_receipts()).empty(); }));
|
||||
CHECK(receipts[0].status == AdmitStatus::admitted); // c is in epoch 6.
|
||||
|
||||
|
||||
@@ -228,7 +228,8 @@ void store_rules() {
|
||||
#ifdef EVO_POSTGRES_SESSIONS
|
||||
// The session layer's ledger over the same lookup.
|
||||
std::optional<LeaseGrant> current = *later;
|
||||
PostgresActionLedger ledger{*db, r.key, [&] { return current; }};
|
||||
PgSlot slot{options(env("EVO_PG_RUNTIME_USER")), 5s};
|
||||
PostgresActionLedger ledger{slot, r.key, [&] { return current; }};
|
||||
evo::network::AccountId who;
|
||||
who.bytes = alice;
|
||||
CHECK(holds(ledger.find(who, 3),
|
||||
|
||||
@@ -0,0 +1,308 @@
|
||||
// Real process tests for M10.4c (ADR-0091, ADR-0092): evo-server with PostgreSQL, synthetic
|
||||
// ticks and the QUIC session listener; in-process RegionSessionClients and the headless
|
||||
// probe. Intentions get receipts and the simulated watermark; actions get durable outcomes
|
||||
// that survive SIGKILL after their commit, and resolve as "no record" (then commit once on
|
||||
// retry) after SIGKILL before it. Region 7/151. Run by tools/ci/postgres-check.sh
|
||||
// when the build has EVO_BUILD_QUIC.
|
||||
#include "evo/client/region_session.hpp"
|
||||
#include "evo/network/dev_credentials.hpp"
|
||||
#include "evo/network/session_grant.hpp"
|
||||
#include "fixtures/server_process.hpp"
|
||||
#include <fcntl.h>
|
||||
#include <functional>
|
||||
#include <optional>
|
||||
#include <source_location>
|
||||
#include <thread>
|
||||
#include <unistd.h>
|
||||
|
||||
void run_region_m10_session_tests();
|
||||
|
||||
namespace {
|
||||
using namespace evo::test::process;
|
||||
using namespace evo;
|
||||
using namespace evo::network;
|
||||
using client::RegionSessionClient;
|
||||
using client::RegionSessionState;
|
||||
using evo::test::region_identity;
|
||||
void check(bool value, std::source_location at = std::source_location::current()) {
|
||||
if (!value)
|
||||
throw std::runtime_error("region m10 session test line " + std::to_string(at.line()));
|
||||
}
|
||||
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
||||
template <typename T>
|
||||
const T& must(const std::optional<T>& o,
|
||||
std::source_location at = std::source_location::current()) {
|
||||
if (!o)
|
||||
throw std::runtime_error("region m10 session missing value line " +
|
||||
std::to_string(at.line()));
|
||||
return *o;
|
||||
}
|
||||
constexpr const char* name = "dev-region.evolution.test";
|
||||
|
||||
void write_file(const fs::path& path, std::span<const std::uint8_t> bytes) {
|
||||
const int fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0600);
|
||||
expect(fd >= 0 &&
|
||||
::write(fd, bytes.data(), bytes.size()) == static_cast<ssize_t>(bytes.size()) &&
|
||||
::close(fd) == 0,
|
||||
"write file");
|
||||
}
|
||||
void write_text(const fs::path& path, const std::string& text) {
|
||||
write_file(path, {reinterpret_cast<const std::uint8_t*>(text.data()), text.size()});
|
||||
}
|
||||
AccountId account(std::uint8_t tag) {
|
||||
AccountId a;
|
||||
a.bytes.fill(tag);
|
||||
return a;
|
||||
}
|
||||
std::string hex(const AccountId& a) {
|
||||
constexpr char digits[] = "0123456789abcdef";
|
||||
std::string out;
|
||||
for (const auto b : a.bytes) {
|
||||
out.push_back(digits[b >> 4U]);
|
||||
out.push_back(digits[b & 0xFU]);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// One region's credentials, issuer key and server process arguments.
|
||||
struct Setup {
|
||||
ServerRegion region;
|
||||
std::string ca_pem;
|
||||
std::optional<GrantSigningKey> issuer;
|
||||
explicit Setup(std::uint64_t r, std::uint8_t genesis) : region{provision(r, genesis)} {
|
||||
const auto made = generate_dev_credentials(DeploymentEnvironment::dev, name, 1,
|
||||
std::chrono::system_clock::now());
|
||||
expect(made.has_value(), "credentials");
|
||||
ca_pem = made->authority_pem;
|
||||
write_text(region.root / "ca.pem", made->authority_pem);
|
||||
write_text(region.root / "server.pem", made->server_certificate_pem);
|
||||
write_text(region.root / "server.key", made->server_key_pem);
|
||||
for (int attempt = 0; attempt < 8 && !issuer; ++attempt) {
|
||||
std::array<std::uint8_t, grant_private_key_bytes> scalar{};
|
||||
expect(random_bytes(scalar).has_value(), "random");
|
||||
if (auto key = GrantSigningKey::import(DeploymentEnvironment::dev, 1, scalar)) {
|
||||
write_file(region.root / "issuer.key", scalar);
|
||||
write_file(region.root / "issuer.pub", *key->public_key());
|
||||
issuer.emplace(std::move(*key));
|
||||
}
|
||||
}
|
||||
expect(issuer.has_value(), "issuer key");
|
||||
}
|
||||
[[nodiscard]] std::vector<std::string> args() const {
|
||||
return server_args(region,
|
||||
{"--synthetic-inputs", "development-v1", "--m10-listen", "127.0.0.1:0",
|
||||
"--m10-cert", (region.root / "server.pem").string(), "--m10-key",
|
||||
(region.root / "server.key").string(), "--m10-issuer",
|
||||
(region.root / "issuer.pub").string(), "--m10-environment", "dev"});
|
||||
}
|
||||
[[nodiscard]] WireGrant grant(const AccountId& who, std::uint64_t serial) const {
|
||||
GrantClaims c;
|
||||
c.grant_id = 9000 + serial;
|
||||
c.account = who;
|
||||
c.serial = serial;
|
||||
c.world = {region.key.world, region_identity.frame};
|
||||
c.region = region.key.region;
|
||||
c.issued_at =
|
||||
static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
|
||||
std::chrono::system_clock::now().time_since_epoch())
|
||||
.count());
|
||||
c.expires_at = c.issued_at + 120;
|
||||
const auto g = must(issuer).sign(c);
|
||||
expect(g.has_value(), "grant");
|
||||
return *g;
|
||||
}
|
||||
};
|
||||
|
||||
// A running evo-server and its QUIC port, its output drained while waiting.
|
||||
struct Server {
|
||||
std::unique_ptr<Child> child;
|
||||
std::uint16_t port{};
|
||||
explicit Server(const Setup& s) : child{std::make_unique<Child>(s.args())} {
|
||||
CHECK(child->wait_line("m10 listening ", 30s));
|
||||
for (const auto& l : child->lines())
|
||||
if (starts(l, "m10 listening "))
|
||||
port = static_cast<std::uint16_t>(std::stoul(l.substr(14)));
|
||||
CHECK(port != 0 && child->wait_line("ready 1", 30s));
|
||||
}
|
||||
void pump() {
|
||||
child->pump(1ms);
|
||||
}
|
||||
void kill() {
|
||||
child->signal(SIGKILL);
|
||||
CHECK(child->wait_exit(30s) == 128 + SIGKILL);
|
||||
}
|
||||
};
|
||||
|
||||
std::unique_ptr<RegionSessionClient> connect(const Setup& s, Server& server,
|
||||
const WireGrant& grant) {
|
||||
client::RegionSessionClientConfig c;
|
||||
c.transport.port = server.port;
|
||||
c.transport.server_name = name;
|
||||
c.transport.authority_pem = s.ca_pem;
|
||||
c.transport.authority_pem_file = (s.region.root / "ca.pem").string();
|
||||
c.grant = grant;
|
||||
auto made = RegionSessionClient::connect(std::move(c), std::chrono::steady_clock::now());
|
||||
CHECK(made.has_value());
|
||||
return std::move(*made);
|
||||
}
|
||||
// Polls client and server until `done`, at most `limit`.
|
||||
bool until(Server& server, RegionSessionClient& c, const std::function<bool()>& done,
|
||||
std::chrono::milliseconds limit = 20s) {
|
||||
const auto end = Clock::now() + limit;
|
||||
while (Clock::now() < end) {
|
||||
c.poll(Clock::now());
|
||||
server.pump();
|
||||
if (done())
|
||||
return true;
|
||||
}
|
||||
return done();
|
||||
}
|
||||
bool established(Server& server, RegionSessionClient& c) {
|
||||
return until(server, c,
|
||||
[&] {
|
||||
return c.state() == RegionSessionState::established ||
|
||||
c.state() == RegionSessionState::closed;
|
||||
}) &&
|
||||
c.state() == RegionSessionState::established;
|
||||
}
|
||||
std::optional<ActionOutcome> outcome_of(Server& server, RegionSessionClient& c, std::uint64_t id,
|
||||
bool final_only) {
|
||||
std::optional<ActionOutcome> found;
|
||||
until(server, c, [&] {
|
||||
for (const auto& o : c.take_action_outcomes())
|
||||
if (o.action_id == id &&
|
||||
(!final_only || o.result == ActionResult::committed_no_effect ||
|
||||
o.result == ActionResult::not_committed))
|
||||
found = o;
|
||||
return found.has_value();
|
||||
});
|
||||
return found;
|
||||
}
|
||||
std::optional<ActionReceipt> receipt_of(Server& server, RegionSessionClient& c, std::uint64_t id) {
|
||||
std::optional<ActionReceipt> found;
|
||||
until(server, c, [&] {
|
||||
for (const auto& r : c.take_action_receipts())
|
||||
if (r.action_id == id)
|
||||
found = r;
|
||||
return found.has_value();
|
||||
});
|
||||
return found;
|
||||
}
|
||||
// "tick:commit" of the durable record of (account, id) in world 7, or empty.
|
||||
std::string record(const AccountId& who, std::uint64_t id) {
|
||||
const std::array<std::string, 2> p{hex(who), std::to_string(id)};
|
||||
auto rows =
|
||||
owner()->query("SELECT tick || ':' || commit_sequence FROM evolution.region_actions "
|
||||
"WHERE world_id = 7 AND account_id = $1::uuid AND "
|
||||
"action_id = $2::evolution.u64",
|
||||
p, 5s);
|
||||
CHECK(rows.has_value());
|
||||
return rows->empty() ? std::string{} : (*rows)[0][0].value_or("");
|
||||
}
|
||||
|
||||
void end_to_end() {
|
||||
Setup s{151, 0xC5};
|
||||
const auto alice = account(0x51), bob = account(0x52);
|
||||
auto server = std::make_unique<Server>(s);
|
||||
auto a = connect(s, *server, s.grant(alice, 1));
|
||||
CHECK(established(*server, *a));
|
||||
// Intentions: receipts, then the watermark.
|
||||
// Datagrams may be refused until the QUIC datagram extension is negotiated: retry.
|
||||
std::optional<std::uint64_t> sequence;
|
||||
CHECK(until(*server, *a, [&] {
|
||||
return a->server_tick() > 0 &&
|
||||
(sequence = a->send_intention(a->server_tick() + 2, 100, 0)).has_value();
|
||||
}));
|
||||
CHECK(sequence == 1u);
|
||||
std::vector<IntentionReceipt> receipts;
|
||||
CHECK(until(*server, *a, [&] { return !(receipts = a->take_intention_receipts()).empty(); }));
|
||||
CHECK(receipts[0].sequence == 1 && receipts[0].status == AdmitStatus::admitted);
|
||||
CHECK(until(*server, *a, [&] { return a->simulated() && a->simulated()->sequence >= 1; }));
|
||||
// Action: receipt, then a final outcome naming the durable commit.
|
||||
CHECK(a->send_action(1, ActionKind::probe, a->server_tick() + 3));
|
||||
const auto r1 = receipt_of(*server, *a, 1);
|
||||
CHECK(r1 && must(r1).status == AdmitStatus::admitted);
|
||||
const auto o1 = outcome_of(*server, *a, 1, true);
|
||||
CHECK(o1 && must(o1).result == ActionResult::committed_no_effect &&
|
||||
must(o1).tick == must(r1).tick && must(o1).commit_sequence > 0);
|
||||
CHECK(record(alice, 1) ==
|
||||
std::to_string(must(o1).tick) + ":" + std::to_string(must(o1).commit_sequence));
|
||||
|
||||
// SIGKILL after the commit (the record exists), whether or not the outcome was sent.
|
||||
CHECK(a->send_action(2, ActionKind::probe, a->server_tick() + 3));
|
||||
const auto r2 = receipt_of(*server, *a, 2);
|
||||
CHECK(r2 && must(r2).status == AdmitStatus::admitted);
|
||||
const bool recorded = until(*server, *a, [&] { return !record(alice, 2).empty(); });
|
||||
if (!recorded)
|
||||
for (const auto& line : server->child->lines())
|
||||
if (starts(line, "m10") || starts(line, "phase") || starts(line, "dropped"))
|
||||
std::printf("server: %s\n", line.c_str());
|
||||
CHECK(recorded);
|
||||
server->kill();
|
||||
server = std::make_unique<Server>(s); // Waits out the old lease.
|
||||
auto b = connect(s, *server, s.grant(alice, 2));
|
||||
CHECK(established(*server, *b));
|
||||
CHECK(b->query_action(2));
|
||||
const auto o2 = outcome_of(*server, *b, 2, false);
|
||||
CHECK(o2 && must(o2).result == ActionResult::committed_no_effect &&
|
||||
record(alice, 2) ==
|
||||
std::to_string(must(o2).tick) + ":" + std::to_string(must(o2).commit_sequence));
|
||||
// A retry of a committed action on the new process: duplicate, same outcome.
|
||||
CHECK(b->send_action(1, ActionKind::probe, b->server_tick() + 3));
|
||||
const auto d1 = receipt_of(*server, *b, 1);
|
||||
CHECK(d1 && must(d1).status == AdmitStatus::duplicate && must(d1).tick == must(o1).tick);
|
||||
CHECK(outcome_of(*server, *b, 1, true) == o1);
|
||||
|
||||
// SIGKILL before the commit: the action's tick has not run when the process dies.
|
||||
CHECK(b->send_action(3, ActionKind::probe, b->server_tick() + 8));
|
||||
const auto r3 = receipt_of(*server, *b, 3);
|
||||
CHECK(r3 && must(r3).status == AdmitStatus::admitted);
|
||||
server->kill();
|
||||
CHECK(record(alice, 3).empty());
|
||||
server = std::make_unique<Server>(s);
|
||||
auto c = connect(s, *server, s.grant(alice, 3));
|
||||
CHECK(established(*server, *c));
|
||||
CHECK(c->query_action(3));
|
||||
const auto unknown = outcome_of(*server, *c, 3, false);
|
||||
CHECK(unknown && unknown->result == ActionResult::unknown); // No record: never committed.
|
||||
CHECK(c->send_action(3, ActionKind::probe, c->server_tick() + 3)); // Safe to retry.
|
||||
CHECK(must(receipt_of(*server, *c, 3)).status == AdmitStatus::admitted);
|
||||
const auto o3 = outcome_of(*server, *c, 3, true);
|
||||
CHECK(o3 && must(o3).result == ActionResult::committed_no_effect && !record(alice, 3).empty());
|
||||
|
||||
// The headless probe: login, intentions, actions and a query, then a clean exit.
|
||||
const auto probe = fs::path(env("EVO_SERVER_BIN")).parent_path() / "evo-session-probe";
|
||||
Child p{{probe.string(), "run",
|
||||
"--connect", "127.0.0.1:" + std::to_string(server->port),
|
||||
"--server-name", name,
|
||||
"--ca", (s.region.root / "ca.pem").string(),
|
||||
"--issuer-key", (s.region.root / "issuer.key").string(),
|
||||
"--world", "7",
|
||||
"--frame", std::to_string(region_identity.frame),
|
||||
"--region", "151",
|
||||
"--account", hex(bob),
|
||||
"--serial", "1",
|
||||
"--intents", "3",
|
||||
"--actions", "2",
|
||||
"--action-base", "10",
|
||||
"--query", "10"}};
|
||||
int code = -1;
|
||||
for (const auto end = Clock::now() + 30s; Clock::now() < end && code < 0;) {
|
||||
server->pump();
|
||||
p.pump(5ms);
|
||||
if (p.printed("done") || p.printed("timeout") || p.printed("closed"))
|
||||
code = p.wait_exit(10s);
|
||||
}
|
||||
CHECK(code == 0 && p.printed("welcome ") && p.printed("intention 1 0") &&
|
||||
p.printed("outcome 10 1 ") && p.printed("outcome 11 1 "));
|
||||
CHECK(!record(bob, 10).empty() && !record(bob, 11).empty());
|
||||
server->child->signal(SIGTERM);
|
||||
CHECK(server->child->wait_exit(30s) == 0);
|
||||
CHECK(server->child->printed("m10 opened ") && server->child->printed("m10 committed "));
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void run_region_m10_session_tests() {
|
||||
end_to_end();
|
||||
std::puts("region m10 session integration passed");
|
||||
}
|
||||
Reference in New Issue
Block a user