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:
@@ -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");
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
Reference in New Issue
Block a user