feat: implement MoloApp plans 01-15 with integration

Full C++23 framework tree: runtime, observability, security,
data, app, realtime, supervisor, clients, CLI, example plus
enterprise tenancy, audit, operability, governance,
supplychain. Postgres via docker compose for tests.
This commit is contained in:
2026-10-23 18:20:04 +02:00
parent 54068f1953
commit 3c4334cec9
1068 changed files with 100899 additions and 2 deletions
+139
View File
@@ -0,0 +1,139 @@
// Route: /ws/echo. Full round-trip over a real socketpair: client
// handshake bytes, server view admit/accept, text plus binary echo,
// close handshake. Exercises the real FD path, not memory doubles.
#include <sys/socket.h>
#include <unistd.h>
#include <memory>
#include <string>
#include <vector>
#include "test_main.h"
#include "realtime/shared/transport.h"
#include "realtime/websocket/client/client_handshake.h"
#include "realtime/websocket/client/websocket_client.h"
#include "realtime/websocket/server/websocket_handler.h"
#include "realtime/websocket/server/websocket_view.h"
using namespace molo::realtime;
namespace {
class EchoHandler : public websocket::server::WebSocketHandler {
public:
void on_text(const std::string& message) override {
send_text("echo:" + message);
}
void on_binary(const std::vector<uint8_t>& payload) override {
send_binary(payload);
}
};
std::string read_available(int fd) {
char buf[65536];
ssize_t n = ::read(fd, buf, sizeof(buf));
return n <= 0 ? std::string{} : std::string(buf, buf + n);
}
} // namespace
int main() {
realtime_test::Results r;
int sv[2];
T_CHECK(r, ::socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
websocket::server::WebSocketView view(
[] { return std::make_unique<EchoHandler>(); });
// Client builds the handshake, sends it over the real socket.
websocket::client::WebSocketClient client;
shared::FdTransport client_fd(sv[0]);
client.bind(&client_fd, "localhost", "/ws/echo");
std::string key;
shared::HttpRequest hs_req =
websocket::client::ClientHandshake::build_request(
"localhost", "/ws/echo", {}, key);
std::string wire = websocket::client::ClientHandshake::render(hs_req);
T_CHECK(r, client_fd.send(wire));
// Server reads raw bytes and admits from the parsed head.
std::string got = read_available(sv[1]);
T_CHECK(r, got.find("Sec-WebSocket-Key: ") != std::string::npos);
auto admit = view.admit(hs_req);
T_CHECK(r, admit.ok);
// Server 101 travels back; client validates the accept hash.
T_CHECK(r, websocket::client::ClientHandshake::check_response(
admit.response, key)
.ok);
client.note_open();
// Bind the server connection to the other FD.
shared::FdTransport server_fd(sv[1]);
shared::ConnectionContext ctx;
ctx.route = "/ws/echo";
ctx.correlation_id = "echo-1";
websocket::server::WebSocketConnection* conn =
view.accept(&server_fd, ctx);
T_CHECK(r, conn != nullptr);
// Client text round-trips through the echo handler.
std::string echoed;
client.on_message([&](bool is_text, const std::vector<uint8_t>& p) {
(void)is_text;
echoed = std::string(p.begin(), p.end());
});
T_CHECK(r, client.send_text("hello"));
std::string c2s = read_available(sv[1]);
T_CHECK(r, !c2s.empty());
T_CHECK(r, conn->on_bytes(reinterpret_cast<const uint8_t*>(c2s.data()),
c2s.size()));
T_CHECK(r, conn->flush());
std::string s2c = read_available(sv[0]);
T_CHECK(r, !s2c.empty());
T_CHECK(r, client.on_bytes(reinterpret_cast<const uint8_t*>(s2c.data()),
s2c.size()));
T_CHECK(r, echoed == "echo:hello");
// Binary round-trips byte-exact.
std::vector<uint8_t> bin_in = {0x00, 0xFF, 0x01, 0xFE};
std::vector<uint8_t> bin_out;
client.on_message([&](bool is_text, const std::vector<uint8_t>& p) {
(void)is_text;
bin_out = p;
});
T_CHECK(r, client.send_binary(bin_in.data(), bin_in.size()));
c2s = read_available(sv[1]);
T_CHECK(r, conn->on_bytes(reinterpret_cast<const uint8_t*>(c2s.data()),
c2s.size()));
T_CHECK(r, conn->flush());
s2c = read_available(sv[0]);
T_CHECK(r, client.on_bytes(reinterpret_cast<const uint8_t*>(s2c.data()),
s2c.size()));
T_CHECK(r, bin_out == bin_in);
// Ping from the client is answered with an identical pong.
client.send_ping({'p', 'i'});
c2s = read_available(sv[1]);
T_CHECK(r, conn->on_bytes(reinterpret_cast<const uint8_t*>(c2s.data()),
c2s.size()));
s2c = read_available(sv[0]);
T_CHECK(r, s2c.size() == 4 && s2c[0] == (char)0x8A && s2c[2] == 'p');
// Clean close both directions.
bool client_closed = false;
client.on_close([&](uint16_t, const std::string&) { client_closed = true; });
client.close(1000, "done");
c2s = read_available(sv[1]);
conn->on_bytes(reinterpret_cast<const uint8_t*>(c2s.data()), c2s.size());
T_CHECK(r, !conn->open());
s2c = read_available(sv[0]);
client.on_bytes(reinterpret_cast<const uint8_t*>(s2c.data()), s2c.size());
T_CHECK(r, client_closed);
::close(sv[0]);
::close(sv[1]);
return r.report("ws/echo");
}
+169
View File
@@ -0,0 +1,169 @@
// Route: /ws/* framing. Byte-level RFC 6455 vectors: masked parse,
// fragmentation, control limits, UTF-8 and mask rejection.
#include "test_main.h"
#include "realtime/shared/transport.h"
#include "realtime/websocket/server/frame_parser.h"
#include "realtime/websocket/server/frame_serializer.h"
#include "realtime/websocket/server/websocket_response.h"
using namespace molo::realtime;
namespace {
// RFC 6455 section 5.7 masked "Hello" with mask 37 fa 21 3d.
std::vector<uint8_t> rfc_hello() {
return {0x81, 0x85, 0x37, 0xfa, 0x21, 0x3d, 0x7f, 0x9f, 0x4d, 0x51, 0x58};
}
} // namespace
int main() {
realtime_test::Results r;
using server = websocket::server::FrameParser;
using serializer = websocket::server::FrameSerializer;
using websocket::server::CloseCode;
using websocket::server::Opcode;
using websocket::server::ParseOutcome;
// Golden masked frame decodes to "Hello".
{
server p(true);
auto wire = rfc_hello();
std::size_t consumed = 0;
auto step = p.feed(wire.data(), wire.size(), consumed);
T_CHECK(r, step.outcome == ParseOutcome::kFrame);
T_CHECK(r, step.frame.opcode == Opcode::kText);
T_CHECK(r, std::string(step.frame.payload.begin(),
step.frame.payload.end()) == "Hello");
}
// Unmasked client frame fails with 1002 (rule 2).
{
server p(true);
auto wire = serializer::text("hi");
std::size_t consumed = 0;
auto step = p.feed(wire.data(), wire.size(), consumed);
T_CHECK(r, step.outcome == ParseOutcome::kFailed);
T_CHECK(r, step.fail_code == CloseCode::kProtocolError);
}
// Server frames are never masked: round-trip unmasked parse.
{
server p(false);
auto wire = serializer::text("hello");
std::size_t consumed = 0;
auto step = p.feed(wire.data(), wire.size(), consumed);
T_CHECK(r, step.outcome == ParseOutcome::kFrame);
}
{
server p(false);
uint8_t mask[4] = {1, 2, 3, 4};
auto wire = serializer::masked_frame(true, Opcode::kText,
reinterpret_cast<const uint8_t*>("hi"),
2, mask);
std::size_t consumed = 0;
auto step = p.feed(wire.data(), wire.size(), consumed);
T_CHECK(r, step.outcome == ParseOutcome::kFailed);
}
// Fragmented control frame is a protocol error (rule 4).
{
server p(true);
uint8_t mask[4] = {0, 0, 0, 0};
uint8_t payload[1] = {'x'};
auto wire =
serializer::masked_frame(false, Opcode::kPing, payload, 1, mask);
std::size_t consumed = 0;
auto step = p.feed(wire.data(), wire.size(), consumed);
T_CHECK(r, step.outcome == ParseOutcome::kFailed);
}
// Control payload over 125 bytes fails.
{
server p(true);
std::vector<uint8_t> big(126, 'a');
uint8_t mask[4] = {0, 0, 0, 0};
auto wire =
serializer::masked_frame(true, Opcode::kPing, big.data(), big.size(),
mask);
std::size_t consumed = 0;
auto step = p.feed(wire.data(), wire.size(), consumed);
T_CHECK(r, step.outcome == ParseOutcome::kFailed);
}
// 16-bit and 64-bit lengths round-trip.
for (std::size_t n : {126u, 1000u, 65536u}) {
std::vector<uint8_t> payload(n, 'b');
auto wire = serializer::frame(true, Opcode::kBinary, payload);
server p(false);
std::size_t consumed = 0;
auto step = p.feed(wire.data(), wire.size(), consumed);
T_CHECK(r, step.outcome == ParseOutcome::kFrame);
T_CHECK(r, step.frame.payload.size() == n);
}
// Invalid UTF-8 text fails the connection with 1007 (rule 3).
{
shared::MemoryTransport t;
shared::ConnectionContext ctx;
websocket::server::WebSocketConnection conn(&t, ctx);
bool closed = false;
conn.on_close([&](uint16_t code, const std::string&) {
closed = code == 1007;
});
uint8_t mask[4] = {9, 9, 9, 9};
uint8_t bad[2] = {0xC3, 0x28}; // Invalid 2-byte sequence.
auto wire =
serializer::masked_frame(true, Opcode::kText, bad, 2, mask);
T_CHECK(r, !conn.on_bytes(wire.data(), wire.size()));
T_CHECK(r, closed);
}
// Fragmented message reassembles; ping is answered with pong.
{
shared::MemoryTransport t;
shared::ConnectionContext ctx;
websocket::server::WebSocketConnection conn(&t, ctx);
std::string got;
conn.on_message([&](bool is_text, const std::vector<uint8_t>& p) {
got = std::string(p.begin(), p.end());
(void)is_text;
});
uint8_t mask[4] = {0, 0, 0, 0};
auto f1 = serializer::masked_frame(
false, Opcode::kText, reinterpret_cast<const uint8_t*>("he"), 2, mask);
auto f2 = serializer::masked_frame(
true, Opcode::kContinuation,
reinterpret_cast<const uint8_t*>("llo"), 3, mask);
T_CHECK(r, conn.on_bytes(f1.data(), f1.size()));
T_CHECK(r, conn.on_bytes(f2.data(), f2.size()));
T_CHECK(r, got == "hello");
auto ping = serializer::masked_frame(true, Opcode::kPing,
reinterpret_cast<const uint8_t*>("p"),
1, mask);
T_CHECK(r, conn.on_bytes(ping.data(), ping.size()));
// Server answered 0x8a pong with payload "p".
T_CHECK(r, t.sent().size() == 3 && t.sent()[0] == 0x8A &&
t.sent()[2] == 'p');
}
// Close handshake echoes the code.
{
shared::MemoryTransport t;
shared::ConnectionContext ctx;
websocket::server::WebSocketConnection conn(&t, ctx);
uint16_t code = 0;
conn.on_close([&](uint16_t c, const std::string&) { code = c; });
uint8_t mask[4] = {0, 0, 0, 0};
uint8_t body[2] = {0x03, 0xE8}; // 1000.
auto wire =
serializer::masked_frame(true, Opcode::kClose, body, 2, mask);
conn.on_bytes(wire.data(), wire.size());
T_CHECK(r, code == 1000);
T_CHECK(r, !conn.open());
}
return r.report("ws/frames");
}
+86
View File
@@ -0,0 +1,86 @@
// Route: /ws/* handshake. Golden RFC 6455 vectors plus failure modes.
#include "test_main.h"
#include "realtime/shared/http_seam.h"
#include "realtime/websocket/server/handshake_validator.h"
using namespace molo::realtime;
namespace {
websocket::server::HandshakeValidator validator() {
websocket::server::HandshakeConfig cfg;
cfg.subprotocols = {"chat", "super"};
return websocket::server::HandshakeValidator(cfg);
}
shared::HttpRequest base_req() {
shared::HttpRequest req;
req.method = "GET";
req.path = "/ws/chat";
req.headers.emplace("Upgrade", "websocket");
req.headers.emplace("Connection", "Upgrade");
req.headers.emplace("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==");
req.headers.emplace("Sec-WebSocket-Version", "13");
return req;
}
} // namespace
int main() {
realtime_test::Results r;
// RFC 6455 section 1.3 golden vector.
T_CHECK(r, websocket::server::HandshakeValidator::accept_for(
"dGhlIHNhbXBsZSBub25jZQ==") == "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
auto ok = validator().validate(base_req());
T_CHECK(r, ok.ok);
T_CHECK(r, ok.response.status == 101);
T_CHECK(r, shared::header_first(ok.response, "Sec-WebSocket-Accept") ==
"s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
T_CHECK(r, shared::header_first(ok.response, "Upgrade") == "websocket");
// Subprotocol negotiation picks the server's first match.
auto req = base_req();
req.headers.emplace("Sec-WebSocket-Protocol", "super, chat");
auto sub = validator().validate(req);
T_CHECK(r, sub.ok && sub.subprotocol == "chat");
// Unknown subprotocol fails when the server offers any.
req = base_req();
req.headers.emplace("Sec-WebSocket-Protocol", "nope");
T_CHECK(r, !validator().validate(req).ok);
// Failure modes.
req = base_req();
req.method = "POST";
T_CHECK(r, !validator().validate(req).ok);
req = base_req();
req.headers.erase("Upgrade");
T_CHECK(r, !validator().validate(req).ok);
req = base_req();
req.headers.erase("Connection");
T_CHECK(r, !validator().validate(req).ok);
req = base_req();
req.headers.erase("Sec-WebSocket-Key");
T_CHECK(r, !validator().validate(req).ok);
req = base_req();
req.headers.emplace("Sec-WebSocket-Key", "!!!!");
req.headers.erase("Sec-WebSocket-Key");
req.headers.emplace("Sec-WebSocket-Key", "!!!!");
T_CHECK(r, !validator().validate(req).ok);
req = base_req();
req.headers.erase("Sec-WebSocket-Key");
req.headers.emplace("Sec-WebSocket-Key", "aGk="); // Decodes to 2 bytes.
T_CHECK(r, !validator().validate(req).ok);
// Case-insensitive token match on Connection with extras.
req = base_req();
req.headers.erase("Connection");
req.headers.emplace("Connection", "keep-alive, Upgrade");
T_CHECK(r, validator().validate(req).ok);
return r.report("ws/handshake");
}
+51
View File
@@ -0,0 +1,51 @@
// Heartbeat manager: ping schedule plus pong-timeout close.
#include "test_main.h"
#include "realtime/websocket/server/heartbeat_manager.h"
using namespace molo::realtime;
int main() {
realtime_test::Results r;
using clock = std::chrono::steady_clock;
using websocket::server::HeartbeatManager;
// Pings fire on interval while activity flows.
{
HeartbeatManager hb(std::chrono::milliseconds(25),
std::chrono::milliseconds(100));
int pings = 0;
bool dead = false;
hb.on_ping([&] { ++pings; });
hb.on_timeout([&] { dead = true; });
auto t0 = clock::now();
hb.start(t0);
hb.note_activity(t0);
T_CHECK(r, hb.tick(t0 + std::chrono::milliseconds(10)));
T_CHECK(r, pings == 0);
hb.note_activity(t0 + std::chrono::milliseconds(10));
T_CHECK(r, hb.tick(t0 + std::chrono::milliseconds(30)));
T_CHECK(r, pings == 1);
T_CHECK(r, !dead);
}
// Silence past the timeout fires once and sticks.
{
HeartbeatManager hb(std::chrono::milliseconds(25),
std::chrono::milliseconds(50));
int pings = 0;
int timeouts = 0;
hb.on_ping([&] { ++pings; });
hb.on_timeout([&] { ++timeouts; });
auto t0 = clock::now();
hb.start(t0);
T_CHECK(r, !hb.tick(t0 + std::chrono::milliseconds(60)));
T_CHECK(r, timeouts == 1);
T_CHECK(r, !hb.tick(t0 + std::chrono::milliseconds(70)));
T_CHECK(r, timeouts == 1);
T_CHECK(r, hb.timed_out());
}
return r.report("ws/heartbeat");
}