h::ws_upgrade_options options;

options.subprotocols = {"chat", "binary"};

options.allowed_origins = {"https://example.com"};

options.allow_absent_origin = true;

options.limits.max_message_bytes = 1048576;

options.limits.incoming_bytes = 1048576;

options.limits.incoming_messages = 1;

options.limits.output_bytes = 1048586;

options.limits.outgoing_messages = 1;

auto result = co_await x.upgrade(options);

if (!result.status.ok()) {

result.rejection_fields.append("Content-Length", "0");

result.rejection_fields.append("Connection", "close");

x.respond(result.rejection_status, result.rejection_fields);

event("REFUSED " + std::to_string(result.rejection_status.code()) + " " + result.status.message());

co_return;

}

++accepted; event("ACCEPT " + result.selected_subprotocol);

auto session = std::move(*result.session);

h::resume_signal close_gate;

auto notified = std::make_shared<std::atomic<bool>>(false);

session.on_close([close_gate, notified](auto info) mutable {

if (notified->exchange(true)) failed = true;

++closed;

close_gate.signal();

event("CLOSE " + std::to_string(info.clean) + " " + std::to_string(static_cast<int>(info.status.code())));

});

if (x.head().route_path == "/drain-handler") {

h::server::drain_ticket ticket;

auto begun = fixture_server->begin_drain(std::chrono::milliseconds(500), ticket);

h::server::drain_result report;

if (!begun.ok() || ticket.wait(report).code() != h::http::outcome_code::would_deadlock) throw std::runtime_error("handler drain contract");

event("DRAIN HANDLER would_deadlock");

}

if (x.head().route_path == "/app-close") session.close(1000, "local");

if (x.head().route_path == "/return") co_return;

if (x.head().route_path == "/throw") throw std::runtime_error("upgraded handler failure");

if (x.head().route_path == "/idle") {

event("IDLE");

co_await send_gate.wait_for(std::chrono::seconds(5));

const std::string text = "unsolicited";

session.try_send(h::websocket::message_kind::text,

{reinterpret_cast<const std::byte*>(text.data()), text.size()});

}

if (x.head().route_path == "/flood" || x.head().route_path == "/reject-send") {

std::vector<std::byte> payload(x.head().route_path == "/reject-send" ? 1048577 : 1048576);

for (unsigned i = 0; i < 64; ++i) {

std::fill(payload.begin(), payload.end(), std::byte(i));

for (;;) {

auto sent = session.try_send(h::websocket::message_kind::binary, payload);

if (sent.disposition == h::websocket::send_disposition::accepted) break;

if (sent.disposition == h::websocket::send_disposition::closed) {

event("SEND CLOSED");

co_await close_gate.wait_for(std::chrono::seconds(5));

co_return;

}

if (sent.disposition == h::websocket::send_disposition::rejected) {

event("SEND REJECTED " + sent.status.message());

if (x.head().route_path != "/reject-send") {

failed = true;

co_return;

}

session.close(1000, "rejected");

break;

}

event("BLOCKED " + std::to_string(i));

auto room = co_await session.writable();

if (!room.ok()) {

event("WRITABLE CLOSED");

co_await close_gate.wait_for(std::chrono::seconds(5));

co_return;

}

event("RESUMED " + std::to_string(i));

}

if (x.head().route_path == "/reject-send") break;

}

event(x.head().route_path == "/reject-send" ? "REJECTION HANDLED" : "SENT 64");

}

for (;;) {

auto message = co_await session.receive();

if (!message.value) {

// Retain the owning handle through the peer-close reply.

// Application close callback is separate from transport wake.

co_await close_gate.wait_for(std::chrono::seconds(5));

co_return;

}

auto& incoming = *message.value;

for (;;) {

auto sent = session.try_send(incoming.kind, incoming.data);

if (sent.disposition == h::websocket::send_disposition::accepted) break;

if (sent.disposition != h::websocket::send_disposition::backpressured) co_return;

if (!(co_await session.writable()).ok()) co_return;

}

}

h::server::server_options options;

h::server::listener_options listener; listener.address = "127.0.0.1";

options.add_listener(listener); options.concurrency().workers = 2;

// Four live sessions cover the three-peer isolation case and one retiring

// predecessor. These are storage charges, not logical queue allowances.

constexpr std::size_t sessions = 4, message = 1048576, output = message + 10;

constexpr std::size_t input_storage = 5 * message + 16384 + 4096 + 256;

constexpr std::size_t output_storage = 4 * output + 4096 + (8192 + 256) * 4;

options.budgets().set(h::server::resource::body_buffer_bytes, sessions * input_storage);

options.budgets().set(h::server::resource::response_queue_bytes,

sessions * (output_storage + 256) + 4096);

options.budgets().set(h::server::resource::ws_message_bytes, sessions * message);

if (std::getenv("LHS_WS_EXTERNAL")) options.loop() = h::server::loop_mode::external;

if (std::getenv("LHS_WS_LOW_BUDGET")) {

options.budgets().set(h::server::resource::body_buffer_bytes, 16384);

}

options.timeouts().header = std::chrono::milliseconds(100);

options.timeouts().ws_close = std::chrono::seconds(2);

if (!options.validate().ok()) return 2;

const auto mode = options.loop();

h::server::native_server server(std::move(options));

h::http::method_set get; get.set(h::http::method_id::get);

fixture_server = &server;

server.route(h::http::method::known(h::http::method_id::get), "/health", [](h::exchange& x) -> h::task<void> {

h::http::fields fields; fields.append("Content-Length", "4"); fields.append("Connection", "close");

x.start_response(h::http::status::from_code(200), fields);

const std::string body = "okay";

co_await x.writer().write({reinterpret_cast<const std::byte*>(body.data()), body.size()});

co_await x.writer().finish();

});

server.route(h::http::method::known(h::http::method_id::get), "/slow", [](h::exchange& x) -> h::task<void> {

h::http::fields fields; fields.append("Content-Length", "7"); fields.append("Connection", "close");

x.start_response(h::http::status::from_code(200), fields);

const std::string first = "old", last = "body";

co_await x.writer().write({reinterpret_cast<const std::byte*>(first.data()), first.size()});

h::resume_signal delay;

co_await delay.wait_for(std::chrono::milliseconds(100));

co_await x.writer().write({reinterpret_cast<const std::byte*>(last.data()), last.size()});

co_await x.writer().finish();

});

server.route(h::http::method::known(h::http::method_id::get), "/stop-handler", [](h::exchange&) -> h::task<void> {

fixture_server->request_stop();

event("STOP HANDLER returned");

co_return;

});

server.route_prefix(get, "/", route);

if (!server.listen().ok()) return 2;

std::thread host;

if (mode == h::server::loop_mode::external) {

host = std::thread([&] {

try {

auto* driver = server.readiness();

auto snapshot = driver->interests();

while (server.is_running()) {

auto events = v3_host::wait(snapshot);

if (!driver->dispatch(events, v3_host::clock_type::now()).ok()) {

failed = true;

break;

}

snapshot = driver->interests();

}

} catch (...) { failed = true; }

});

}

event("READY " + std::to_string(server.get_bound_port(0)));

h::server::drain_ticket ticket;

std::string command;

while (std::getline(std::cin, command)) {

if (command == "STOP") break;

if (command == "DRAIN" || command == "DRAIN-DROP" || command == "DRAIN-LATE") {

auto begun = server.begin_drain(std::chrono::milliseconds(250), ticket);

if (!begun.ok()) {

failed = true;

break;

}

event("DRAIN START");

if (command == "DRAIN-DROP") {

ticket = h::server::drain_ticket{};

continue;

}

if (command == "DRAIN-LATE") std::this_thread::sleep_for(std::chrono::milliseconds(400));

h::server::drain_result result;

if (!ticket.wait(result).ok()) {

failed = true;

break;

}

event(std::string("DRAIN RESULT ") +

(result.status == h::server::drain_status::completed ? "completed" : "expired") +

" " + std::to_string(result.remaining));

}

if (command == "SEND") send_gate.signal();

if (command == "STATS") event("STATS " + std::to_string(accepted.load()) + " " + std::to_string(closed.load()));

}

server.request_stop();

if (host.joinable()) host.join();

server.stop();

event("STATS " + std::to_string(accepted.load()) + " " + std::to_string(closed.load()));

event("STOPPED");

return failed || accepted != closed ? 1 : 0;