Implement M9.7 dev region sessions with durable no-effect intentions
Run a non-blocking TLS 1.3 session server inside evo-server's loop: environment views come from the region's own field/terrain stores with an explicitly empty organism presentation; admitted intentions ride the next synthetic input (content unchanged) and return a durable no-effect outcome from the host's final acknowledgement, or not_committed when dropped. Sessions are bound to their connection, epochs close stale sessions, and connections have bounded output, input rate and deadlines. SessionClient and evo-client --connect consume one single-use grant per Hello (refusals before admission keep it), reset to a fresh baseline on every session, keep stale views visible and report in-flight intentions as unknown after loss. evo-dev-session generates dev credentials, grant bundles and runs a restart probe. The dev deployment gains a drill-time, loopback-only listener with an optional Secret, enforced by the policy check, and tools/ops/session-drill.sh. Protocol v1 gains IntentOutcome and the capacity close reason before any deployment. ADR-0083 records the maintainer-confirmed decisions; M8-dev/stage remains not passed and no cluster change was made. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,257 @@
|
||||
// Real process tests for M9.7 dev sessions (ADR-0083): evo-server with PostgreSQL,
|
||||
// synthetic inputs and the TLS session listener, driven by the real SessionClient.
|
||||
// Run by tools/ci/postgres-check.sh when the build has EVO_BUILD_NETWORK.
|
||||
#include "evo/network/dev_credentials.hpp"
|
||||
#include "evo/network/session_client.hpp"
|
||||
#include "fixtures/server_process.hpp"
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <fcntl.h>
|
||||
#include <functional>
|
||||
#include <source_location>
|
||||
#include <thread>
|
||||
#include <unistd.h>
|
||||
|
||||
void run_region_session_tests();
|
||||
|
||||
namespace {
|
||||
using namespace evo::test::process;
|
||||
using namespace evo;
|
||||
using evo::test::region_identity;
|
||||
using network::ClientEvent;
|
||||
void check(bool value, std::source_location at = std::source_location::current()) {
|
||||
if (!value)
|
||||
throw std::runtime_error("region 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 session missing value line " + std::to_string(at.line()));
|
||||
return *o;
|
||||
}
|
||||
constexpr const char* name = "dev-region.evolution.test";
|
||||
|
||||
void write_secret(const fs::path& path, const std::string& text) {
|
||||
const int fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0600);
|
||||
expect(fd >= 0 && ::write(fd, text.data(), text.size()) == static_cast<ssize_t>(text.size()) &&
|
||||
::close(fd) == 0,
|
||||
"write secret");
|
||||
}
|
||||
struct Credentials {
|
||||
network::DevCredentials made;
|
||||
std::vector<std::string> args(const ServerRegion& r, std::uint16_t port,
|
||||
const char* environment = "dev") const {
|
||||
write_secret(r.root / "server.pem", made.server_certificate_pem);
|
||||
write_secret(r.root / "server.key", made.server_key_pem);
|
||||
write_secret(r.root / "grant.key", network::format_grant_key(made.grant_key));
|
||||
return server_args(r,
|
||||
{"--synthetic-inputs", "development-v1", "--session-listen",
|
||||
"127.0.0.1:" + std::to_string(port), "--session-cert",
|
||||
(r.root / "server.pem").string(), "--session-key",
|
||||
(r.root / "server.key").string(), "--session-grant-key",
|
||||
(r.root / "grant.key").string(), "--session-environment", environment});
|
||||
}
|
||||
std::vector<network::DevGrant> grants(const ServerRegion& r, std::uint64_t subject,
|
||||
std::size_t count, std::uint64_t first) const {
|
||||
const auto key =
|
||||
network::DevGrantKey::import(network::DeploymentEnvironment::dev, made.grant_key);
|
||||
expect(key.has_value(), "grant key");
|
||||
const auto now =
|
||||
static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
|
||||
std::chrono::system_clock::now().time_since_epoch())
|
||||
.count());
|
||||
std::vector<network::DevGrant> out;
|
||||
for (std::size_t i = 0; i < count; ++i) {
|
||||
const auto g = key->issue(
|
||||
{first + i, subject, region_identity_of(r), r.key.region, now - 5, now + 900});
|
||||
expect(g.has_value(), "issue grant");
|
||||
out.push_back(*g);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
static world::WorldIdentity region_identity_of(const ServerRegion& r) {
|
||||
return {r.key.world, region_identity.frame};
|
||||
}
|
||||
};
|
||||
std::unique_ptr<network::SessionClient> client(const Credentials& c, std::uint16_t port,
|
||||
std::vector<network::DevGrant> grants) {
|
||||
network::SessionClientConfig config;
|
||||
config.host = "127.0.0.1";
|
||||
config.port = port;
|
||||
config.trust = {c.made.authority_pem, name};
|
||||
config.grants = std::move(grants);
|
||||
config.first_retry = 100ms;
|
||||
config.max_retry = 1000ms;
|
||||
auto made = network::SessionClient::create(std::move(config));
|
||||
expect(made.has_value(), "client");
|
||||
return std::move(*made);
|
||||
}
|
||||
std::uint16_t listening_port(Child& server) {
|
||||
std::uint16_t port = 0;
|
||||
CHECK(server.wait_for(
|
||||
[&](const std::string& l) {
|
||||
unsigned p = 0;
|
||||
if (std::sscanf(l.c_str(), "session listening %u", &p) != 1)
|
||||
return false;
|
||||
port = static_cast<std::uint16_t>(p);
|
||||
return true;
|
||||
},
|
||||
15s));
|
||||
return port;
|
||||
}
|
||||
// Pumps the client while draining the server's output (it must never block on a pipe).
|
||||
bool pump(Child& server, std::vector<network::SessionClient*> clients,
|
||||
std::vector<ClientEvent>& events, const std::function<bool()>& done,
|
||||
std::chrono::milliseconds limit = 20s) {
|
||||
const auto end = Clock::now() + limit;
|
||||
while (Clock::now() < end) {
|
||||
for (auto* c : clients) {
|
||||
c->poll(Clock::now());
|
||||
auto e = c->take_events();
|
||||
if (c == clients.front())
|
||||
events.insert(events.end(), e.begin(), e.end());
|
||||
}
|
||||
if (done())
|
||||
return true;
|
||||
(void)server.wait_for([](const std::string&) { return false; }, 2ms);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool has(const std::vector<ClientEvent>& e, ClientEvent::Kind k) {
|
||||
return std::ranges::any_of(e, [&](const ClientEvent& x) { return x.kind == k; });
|
||||
}
|
||||
const ClientEvent* last(const std::vector<ClientEvent>& e, ClientEvent::Kind k) {
|
||||
const auto it = std::ranges::find_if(e.rbegin(), e.rend(),
|
||||
[&](const ClientEvent& x) { return x.kind == k; });
|
||||
return it == e.rend() ? nullptr : &*it;
|
||||
}
|
||||
std::string hex(const std::array<std::uint8_t, 4>& b) {
|
||||
char out[9]{};
|
||||
std::snprintf(out, sizeof out, "%02x%02x%02x%02x", b[0], b[1], b[2], b[3]);
|
||||
return out;
|
||||
}
|
||||
|
||||
void refuses_unsafe_configurations(const Credentials& c) {
|
||||
const auto r = provision(141, 0x52);
|
||||
// The dev identity is refused outside dev, before anything is served.
|
||||
Child stage{c.args(r, 0, "stage")};
|
||||
CHECK(stage.wait_exit(15s) == 2 && stage.printed("error session-environment"));
|
||||
// Sessions without the synthetic carrier are a usage error.
|
||||
auto args = c.args(r, 0);
|
||||
args.erase(std::ranges::find(args, "--synthetic-inputs"),
|
||||
std::ranges::find(args, "--synthetic-inputs") + 2);
|
||||
Child usage{args};
|
||||
CHECK(usage.wait_exit(15s) == 2);
|
||||
}
|
||||
|
||||
void connects_acknowledges_and_recovers(const Credentials& c) {
|
||||
const auto r = provision(140, 0x51);
|
||||
std::uint16_t port = 0;
|
||||
auto client_grants = c.grants(r, 7, 6, 1000);
|
||||
std::vector<ClientEvent> events;
|
||||
std::uint64_t first_commit = 0;
|
||||
std::unique_ptr<network::SessionClient> session;
|
||||
{
|
||||
Child server{c.args(r, 0)};
|
||||
port = listening_port(server);
|
||||
CHECK(server.wait_for([](const std::string& l) { return l == "ready 1"; }, 15s));
|
||||
session = client(c, port, client_grants);
|
||||
CHECK(pump(server, {session.get()}, events,
|
||||
[&] { return session->latest_view().has_value(); }));
|
||||
const auto w = must(session->welcome()); // Copy: welcome() returns by value.
|
||||
CHECK(w.epoch == 1 && w.world == r.key.world && w.region == r.key.region);
|
||||
// Snapshot display: the region's real field stores, explicitly no individuals.
|
||||
CHECK(session->environment().freshness() == client::Freshness::current);
|
||||
CHECK(!session->environment().current()->cells().empty());
|
||||
CHECK(pump(server, {session.get()}, events,
|
||||
[&] { return session->organisms().current() != nullptr; }));
|
||||
CHECK(session->organisms().current()->cells().empty());
|
||||
CHECK(server.printed("session opened 1 subject=7"));
|
||||
|
||||
// Minimal admitted intention: durable acknowledgement, no biological effect.
|
||||
CHECK(session->send({1, 0, 1000, 0}));
|
||||
CHECK(pump(server, {session.get()}, events,
|
||||
[&] { return has(events, ClientEvent::Kind::outcome); }));
|
||||
CHECK(last(events, ClientEvent::Kind::result)->result.status ==
|
||||
network::IntentStatus::admitted);
|
||||
const auto* outcome = last(events, ClientEvent::Kind::outcome);
|
||||
CHECK(outcome->outcome.finality == network::IntentFinality::committed_no_effect);
|
||||
first_commit = outcome->outcome.commit_sequence;
|
||||
// The host acknowledged exactly that request ("INT1...") at that tick and commit.
|
||||
const std::string prefix = "ack " + hex({'I', 'N', 'T', '1'});
|
||||
const auto ack = std::ranges::find_if(
|
||||
server.lines(), [&](const std::string& l) { return starts(l, prefix); });
|
||||
CHECK(ack != server.lines().end());
|
||||
CHECK(ack->ends_with(" " + std::to_string(outcome->outcome.tick) + " " +
|
||||
std::to_string(outcome->outcome.commit_sequence)));
|
||||
// Rejected: a replay is never scheduled.
|
||||
events.clear();
|
||||
CHECK(session->send({1, 0, 0, 1000}));
|
||||
CHECK(pump(server, {session.get()}, events,
|
||||
[&] { return has(events, ClientEvent::Kind::result); }));
|
||||
CHECK(last(events, ClientEvent::Kind::result)->result.status ==
|
||||
network::IntentStatus::replayed);
|
||||
// Duplicate session for the same subject is refused; the first stays.
|
||||
auto twin = client(c, port, c.grants(r, 7, 1, 2000));
|
||||
std::vector<ClientEvent> twin_events;
|
||||
CHECK(pump(server, {twin.get(), session.get()}, twin_events,
|
||||
[&] { return has(twin_events, ClientEvent::Kind::closed); }));
|
||||
CHECK(last(twin_events, ClientEvent::Kind::closed)->reason ==
|
||||
network::CloseReason::duplicate_session);
|
||||
CHECK(session->phase() == network::SessionPhase::established);
|
||||
|
||||
// Pod restart analogue: SIGKILL. The client loses the session; any admitted
|
||||
// intention without a final outcome is reported unknown, never assumed.
|
||||
events.clear();
|
||||
CHECK(session->send({2, 0, -1000, 0}));
|
||||
server.signal(SIGKILL);
|
||||
CHECK(server.wait_exit(10s) == 128 + SIGKILL);
|
||||
}
|
||||
{
|
||||
const auto end = Clock::now() + 5s;
|
||||
while (Clock::now() < end && !has(events, ClientEvent::Kind::lost)) {
|
||||
session->poll(Clock::now());
|
||||
auto e = session->take_events();
|
||||
events.insert(events.end(), e.begin(), e.end());
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
CHECK(has(events, ClientEvent::Kind::lost));
|
||||
CHECK(session->environment().freshness() == client::Freshness::stale);
|
||||
}
|
||||
// Successor on the same port: ready only after the lease expires; the client
|
||||
// reconnects with a fresh grant and a fresh baseline at the new epoch.
|
||||
Child successor{c.args(r, port)};
|
||||
CHECK(listening_port(successor) == port);
|
||||
CHECK(pump(
|
||||
successor, {session.get()}, events,
|
||||
[&] {
|
||||
return session->phase() == network::SessionPhase::established &&
|
||||
session->latest_view().has_value();
|
||||
},
|
||||
30s));
|
||||
CHECK(must(session->welcome()).epoch == 2 && must(session->welcome()).session == 1);
|
||||
CHECK(session->environment().freshness() == client::Freshness::current);
|
||||
events.clear();
|
||||
CHECK(session->send({3, 0, 0, -1000}));
|
||||
CHECK(pump(successor, {session.get()}, events,
|
||||
[&] { return has(events, ClientEvent::Kind::outcome); }));
|
||||
CHECK(last(events, ClientEvent::Kind::outcome)->outcome.commit_sequence > first_commit);
|
||||
successor.signal(SIGTERM);
|
||||
CHECK(successor.wait_exit(20s) == 0);
|
||||
std::printf("region_session port=%u first_commit=%llu grants_left=%zu\n",
|
||||
static_cast<unsigned>(port), static_cast<unsigned long long>(first_commit),
|
||||
session->grants_left());
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void run_region_session_tests() {
|
||||
Credentials c;
|
||||
auto made = network::generate_dev_credentials(network::DeploymentEnvironment::dev, name, 1,
|
||||
std::chrono::system_clock::now());
|
||||
expect(made.has_value(), "credentials");
|
||||
c.made = std::move(*made);
|
||||
refuses_unsafe_configurations(c);
|
||||
connects_acknowledges_and_recovers(c);
|
||||
}
|
||||
Reference in New Issue
Block a user