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
+672
View File
@@ -0,0 +1,672 @@
// Spec: plans/01-runtime.md 6.2. Connection and request lifecycle.
#include "connection.h"
#include <errno.h>
#include <unistd.h>
#ifdef __linux__
#include <sys/sendfile.h>
#endif
#include "runtime/observability_hooks.h"
#include "v1/serializer.h"
#include "v2/connection.h"
namespace molo::runtime::http {
namespace {
std::size_t SaturateToSize(uint64_t v) {
return v > (uint64_t)SIZE_MAX ? SIZE_MAX : (std::size_t)v;
}
} // namespace
std::shared_ptr<Connection> Connection::Create(
EventLoop& loop, std::unique_ptr<Transport> transport,
std::unique_ptr<tls::ITlsHandle> tls, Handler handler,
ConnectionConfig config) {
if (!transport || !handler) return nullptr;
if (config.body_cap > caps::kBodyMaxCeiling) {
config.body_cap = caps::kBodyMaxCeiling;
}
auto c = std::shared_ptr<Connection>(
new Connection(loop, std::move(transport), std::move(tls),
std::move(handler), config));
c->waiter_ = std::make_unique<FdWaiter>(loop, c->transport_->fd());
return c;
}
Connection::Connection(EventLoop& loop, std::unique_ptr<Transport> transport,
std::unique_ptr<tls::ITlsHandle> tls, Handler handler,
ConnectionConfig config)
: loop_(loop),
transport_(std::move(transport)),
tls_(std::move(tls)),
handler_(std::move(handler)),
config_(config) {}
Connection::~Connection() { close(); }
std::string Connection::protocol() const {
if (protocol_ == Protocol::H2PriorKnowledge) return "HTTP/2";
if (protocol_ == Protocol::Http1) return "HTTP/1.1";
return "detecting";
}
bool Connection::is_tls() const { return tls_ && tls_->is_tls(); }
std::string Connection::peer() const {
return transport_ ? transport_->peer() : "";
}
void Connection::start() {
auto self = shared_from_this();
obs::OnAccept(transport_->peer());
MOLO_RUNTIME_COUNT("runtime.accept");
loop_.post(Runner(std::move(self)));
}
Task<void> Connection::Runner(std::shared_ptr<Connection> self) {
co_await self->Run();
}
void Connection::drain() {
// Thread-safe: the flag flip and waiter poke run on the loop thread so a
// parked coroutine never resumes on a foreign thread.
std::weak_ptr<Connection> weak = weak_from_this();
loop_.defer([weak] {
auto self = weak.lock();
if (!self || self->closed_) return;
self->draining_ = true;
if (self->active_h2_) {
self->active_h2_->drain();
} else if (self->waiter_) {
self->waiter_->Wake();
}
});
}
void Connection::InterruptRead() {
if (waiter_) waiter_->Wake();
}
void Connection::close() {
// Pin via weak_ptr: shared_from_this() would throw in the destructor.
// In the dtor the pin is null, which is safe because Run (the only parked
// coroutine) holds a shared ref and is therefore already finished.
std::shared_ptr<Connection> pin = weak_from_this().lock();
if (closed_) return;
closed_ = true;
if (waiter_) waiter_->cancel();
if (transport_) {
obs::OnClose(transport_->peer(), transport_->bytes_read(),
transport_->bytes_written());
transport_->close();
}
}
Task<Connection::ReadResult> Connection::PumpRead(
std::chrono::milliseconds timeout) {
if (closed_) co_return ReadResult::Closed;
// Drain interrupts idle waits but lets the in-flight request finish.
if (draining_ && !in_request_) co_return ReadResult::Closed;
auto deadline = std::chrono::steady_clock::now() + timeout;
char tmp[caps::kReadChunkSize];
for (;;) {
if (closed_) co_return ReadResult::Closed;
if (tls_ && tls_->is_tls() && tls_done_ && !raw_.empty()) {
// Drain stashed ciphertext through decrypt first.
char plain[caps::kReadChunkSize];
std::size_t used = 0;
ssize_t p = tls_->decrypt(raw_.data(), raw_.size(), plain,
sizeof(plain), used);
if (p < 0) co_return ReadResult::Error;
if (p > 0 || used > 0) {
in_.append(plain, (std::size_t)(p > 0 ? p : 0));
raw_.erase(0, used);
if (p > 0) co_return ReadResult::Ok;
}
}
ssize_t n = transport_->recv(tmp, sizeof(tmp));
if (n > 0) {
if (tls_ && tls_->is_tls() && tls_done_) {
raw_.append(tmp, (std::size_t)n);
continue; // loop back into the decrypt drain above
}
in_.append(tmp, (std::size_t)n);
co_return ReadResult::Ok;
}
if (n == 0) co_return ReadResult::Eof;
if (errno != EAGAIN && errno != EWOULDBLOCK) {
co_return ReadResult::Error;
}
auto now = std::chrono::steady_clock::now();
if (now >= deadline) co_return ReadResult::Timeout;
auto left =
std::chrono::duration_cast<std::chrono::milliseconds>(deadline - now);
bool fired = false;
TimerWheel::TimerId timer = loop_.schedule_after(left, [this, &fired] {
fired = true;
if (waiter_) waiter_->Wake();
});
bool alive = co_await waiter_->readable();
loop_.cancel_timer(timer);
if (!alive || closed_) co_return ReadResult::Closed;
if (draining_ && !in_request_) co_return ReadResult::Closed;
if (fired) {
// One last non-blocking attempt before declaring the timeout.
n = transport_->recv(tmp, sizeof(tmp));
if (n > 0) {
if (tls_ && tls_->is_tls() && tls_done_) {
raw_.append(tmp, (std::size_t)n);
continue;
}
in_.append(tmp, (std::size_t)n);
co_return ReadResult::Ok;
}
co_return ReadResult::Timeout;
}
// Woken without data or timeout: drain poke or readiness race. Surface
// it so the caller re-checks exit conditions instead of sleeping past
// them. No data is lost: the next call tries recv first.
co_return ReadResult::Interrupted;
}
}
Task<bool> Connection::Flush(std::chrono::milliseconds timeout) {
std::string send_buf;
if (tls_ && tls_->is_tls() && tls_done_) {
send_buf.resize(out_.size() + 512);
ssize_t n = tls_->encrypt(out_.data(), out_.size(), send_buf.data(),
send_buf.size());
if (n < 0) co_return false;
send_buf.resize((std::size_t)n);
out_.clear();
} else {
send_buf.swap(out_);
}
std::size_t off = 0;
while (off < send_buf.size()) {
if (closed_) co_return false;
ssize_t n = transport_->send(send_buf.data() + off,
send_buf.size() - off);
if (n > 0) {
off += (std::size_t)n;
continue;
}
if (n == 0) co_return false;
if (errno != EAGAIN && errno != EWOULDBLOCK) co_return false;
bool fired = false;
TimerWheel::TimerId timer = 0;
if (timeout.count() > 0) {
timer = loop_.schedule_after(timeout, [this, &fired] {
fired = true;
if (waiter_) waiter_->Wake();
});
}
bool alive = co_await waiter_->writable();
if (timer != 0) loop_.cancel_timer(timer);
if (!alive || closed_) co_return false;
if (fired) co_return false;
}
co_return true;
}
Task<bool> Connection::AwaitWritable(std::chrono::milliseconds timeout) {
bool fired = false;
TimerWheel::TimerId timer = 0;
if (timeout.count() > 0) {
timer = loop_.schedule_after(timeout, [this, &fired] {
fired = true;
if (waiter_) waiter_->Wake();
});
}
bool alive = co_await waiter_->writable();
if (timer != 0) loop_.cancel_timer(timer);
if (!alive || closed_) co_return false;
co_return !fired;
}
Task<bool> Connection::SendFileBody(FileBody fb,
std::chrono::milliseconds timeout) {
struct Closer {
int fd;
~Closer() {
if (fd >= 0) ::close(fd);
}
} closer{fb.fd};
if (!ClampFileBody(fb)) co_return false;
uint64_t start = fb.offset;
uint64_t length = fb.length;
bool use_tls = tls_ && tls_->is_tls() && tls_done_;
#ifdef __linux__
if (!use_tls) {
// Zero-copy path: one sendfile call per 64 KB chunk with writable waits
// for backpressure. The socket is non-blocking, so EAGAIN just parks.
off_t off = (off_t)start;
uint64_t left = length;
while (left > 0) {
if (closed_) co_return false;
std::size_t n = left > caps::kFileChunkSize
? caps::kFileChunkSize
: (std::size_t)left;
ssize_t w = ::sendfile(transport_->fd(), fb.fd, &off, n);
if (w > 0) {
left -= (uint64_t)w;
continue;
}
if (w == 0) co_return false; // truncated under us: fail closed
if (errno != EAGAIN && errno != EWOULDBLOCK) co_return false;
if (!co_await AwaitWritable(timeout)) co_return false;
}
co_return true;
}
#else
(void)use_tls;
#endif
// TLS or non-Linux: bounded pread streaming through the outbox, one Flush
// per chunk so the write ceiling always holds.
uint64_t pos = start;
uint64_t left = length;
char buf[caps::kFileChunkSize];
while (left > 0) {
if (closed_) co_return false;
std::size_t n =
left > sizeof(buf) ? sizeof(buf) : (std::size_t)left;
ssize_t r = ::pread(fb.fd, buf, n, (off_t)pos);
if (r <= 0) co_return false;
pos += (uint64_t)r;
left -= (uint64_t)r;
out_.append(buf, (std::size_t)r);
if (!co_await Flush(timeout)) co_return false;
}
co_return true;
}
Task<bool> Connection::DoHandshake() {
if (!tls_ || !tls_->is_tls()) {
tls_done_ = true;
co_return true;
}
auto deadline =
std::chrono::steady_clock::now() + config_.tls_handshake_timeout;
for (;;) {
if (closed_) co_return false;
const char* in_ptr = raw_.data();
std::size_t in_len = raw_.size();
std::size_t before = in_len;
std::string hs_out;
tls::HandshakeState st =
tls_->handshake_step(in_ptr, in_len, hs_out);
raw_.erase(0, before - in_len);
if (!hs_out.empty()) {
out_.append(hs_out);
auto now = std::chrono::steady_clock::now();
if (now >= deadline) co_return false;
auto left =
std::chrono::duration_cast<std::chrono::milliseconds>(deadline - now);
if (!co_await Flush(left)) co_return false;
}
if (st == tls::HandshakeState::Done) {
tls_done_ = true;
co_return true;
}
if (st == tls::HandshakeState::Failed) co_return false;
auto now = std::chrono::steady_clock::now();
if (now >= deadline) co_return false;
auto left =
std::chrono::duration_cast<std::chrono::milliseconds>(deadline - now);
// Handshake bytes bypass the plaintext buffer: read raw directly.
char tmp[caps::kReadChunkSize];
for (;;) {
ssize_t n = transport_->recv(tmp, sizeof(tmp));
if (n > 0) {
raw_.append(tmp, (std::size_t)n);
break;
}
if (n == 0) co_return false;
if (errno != EAGAIN && errno != EWOULDBLOCK) co_return false;
auto hs_now = std::chrono::steady_clock::now();
if (hs_now >= deadline) co_return false;
auto hs_left = std::chrono::duration_cast<std::chrono::milliseconds>(
deadline - hs_now);
bool fired = false;
TimerWheel::TimerId timer =
loop_.schedule_after(hs_left, [this, &fired] {
fired = true;
if (waiter_) waiter_->Wake();
});
bool alive = co_await waiter_->readable();
loop_.cancel_timer(timer);
if (!alive || closed_ || fired) co_return false;
}
}
}
bool Connection::IsH2cUpgrade(const RequestHead& head) const {
if (!config_.allow_h2c_upgrade) return false;
if (head.version != "HTTP/1.1") return false;
std::string conn = ToLower(head.headers.get("connection"));
if (conn.find("upgrade") == std::string::npos) return false;
std::string up = ToLower(head.headers.get("upgrade"));
if (up.find("h2c") == std::string::npos) return false;
return head.headers.has("http2-settings");
}
Task<void> Connection::SendError(int status, bool close_after) {
ResponseHead head;
head.status = status;
std::string body = std::to_string(status) + " " + StatusReason(status) + "\n";
head.headers.set("content-type", "text/plain; charset=utf-8");
out_.append(v1::Serializer::SerializeHead(head, "HTTP/1.1", false,
body.size(), false, close_after));
out_.append(body);
co_await Flush(config_.idle_timeout);
if (close_after) close();
}
Task<void> Connection::Run() {
auto self = shared_from_this();
if (!co_await DoHandshake()) {
close();
co_return;
}
if (tls_ && tls_->is_tls()) {
protocol_ = ProtocolDetector::from_alpn(tls_->alpn_protocol());
} else {
ProtocolDetector detector;
std::size_t det_fed = 0;
auto start = std::chrono::steady_clock::now();
auto idle_deadline = start + config_.idle_timeout;
auto head_deadline = start + config_.header_timeout;
bool det_got_any = false;
for (;;) {
if (det_fed < in_.size()) {
// Feed only new bytes; the detector keeps match progress.
protocol_ =
detector.feed(in_.data() + det_fed, in_.size() - det_fed);
det_fed = in_.size();
if (protocol_ != Protocol::NeedMore) break;
}
// First byte races the idle timeout (silent close); completing
// detection races the header timeout (408).
auto limit = det_got_any ? head_deadline : idle_deadline;
auto now = std::chrono::steady_clock::now();
if (now >= limit) {
if (!det_got_any) {
close();
co_return;
}
co_await SendError(408, true);
co_return;
}
auto left =
std::chrono::duration_cast<std::chrono::milliseconds>(limit - now);
ReadResult r = co_await PumpRead(left);
if (r == ReadResult::Ok) {
det_got_any = true;
continue;
}
if (r == ReadResult::Interrupted) continue;
if (r == ReadResult::Timeout) {
if (!det_got_any) {
close();
co_return;
}
co_await SendError(408, true);
co_return;
}
close();
co_return;
}
}
if (protocol_ == Protocol::H2PriorKnowledge) {
bool expect_magic = !(tls_ && tls_->is_tls());
co_await RunH2(expect_magic, false, RequestHead{}, "");
co_return;
}
co_await RunH1();
}
Task<void> Connection::RunH1() {
auto self = shared_from_this();
v1::Parser parser(config_.body_cap);
while (!closed_ && requests_ < config_.max_requests) {
if (draining_) {
close();
co_return;
}
parser.reset();
auto head_deadline =
std::chrono::steady_clock::now() + config_.header_timeout;
auto body_deadline = head_deadline;
bool body_phase = false;
v1::ParseResult pr = v1::ParseResult::NeedMore;
bool got_any = false;
bool head_seen = false;
for (;;) {
if (!in_.empty()) {
// Bytes already here (detection or pipelining) count as activity:
// the idle timeout must not apply.
got_any = true;
in_request_ = true;
// The parser owns its pending buffer; hand over everything.
pr = parser.feed(in_.data(), in_.size());
in_.clear();
if (!head_seen && parser.head_done()) {
head_seen = true;
body_phase = true;
body_deadline =
std::chrono::steady_clock::now() + config_.body_timeout;
if (parser.expect_continue() &&
pr == v1::ParseResult::NeedMore) {
// Head is in, body still coming: release the client.
out_.append("HTTP/1.1 100 Continue\r\n\r\n");
if (!co_await Flush(config_.idle_timeout)) {
close();
co_return;
}
}
}
if (pr != v1::ParseResult::NeedMore) break;
}
auto now = std::chrono::steady_clock::now();
auto limit = body_phase ? body_deadline : head_deadline;
if (!got_any) limit = std::chrono::steady_clock::now() +
config_.idle_timeout;
if (now >= limit) {
if (!got_any) {
// Idle keep-alive expiry: silent close, no error page.
close();
co_return;
}
co_await SendError(408, true);
co_return;
}
auto left =
std::chrono::duration_cast<std::chrono::milliseconds>(limit - now);
ReadResult r = co_await PumpRead(left);
if (r == ReadResult::Ok) {
got_any = true;
in_request_ = true;
continue;
}
if (r == ReadResult::Interrupted) continue;
if (r == ReadResult::Eof || r == ReadResult::Closed) {
close();
co_return;
}
if (r == ReadResult::Timeout) {
if (!got_any) {
close();
co_return;
}
co_await SendError(408, true);
co_return;
}
close();
co_return;
}
// Pipelined bytes after this message return to the input buffer.
in_ = parser.take_pending();
if (pr == v1::ParseResult::Error400) {
obs::OnParseError(400);
co_await SendError(400, true);
co_return;
}
if (pr == v1::ParseResult::Error413) {
obs::OnParseError(413);
co_await SendError(413, true);
co_return;
}
if (pr == v1::ParseResult::Error431) {
obs::OnParseError(431);
co_await SendError(431, true);
co_return;
}
if (pr == v1::ParseResult::Error501) {
obs::OnParseError(501);
co_await SendError(501, true);
co_return;
}
if (pr != v1::ParseResult::Complete) {
close();
co_return;
}
const RequestHead& head = parser.head();
if (IsH2cUpgrade(head)) {
std::string body = parser.body();
out_.append(
"HTTP/1.1 101 Switching Protocols\r\nconnection: Upgrade\r\n"
"upgrade: h2c\r\ncontent-length: 0\r\n\r\n");
if (!co_await Flush(config_.idle_timeout)) {
close();
co_return;
}
++requests_;
protocol_ = Protocol::H2PriorKnowledge;
co_await RunH2(false, true, head, body);
co_return;
}
FullRequest req;
req.head = head;
req.body = parser.body();
req.trailers = parser.trailers();
req.is_tls = tls_ && tls_->is_tls();
req.peer = transport_->peer();
req.protocol = "HTTP/1.1";
bool keep = parser.keep_alive() && !draining_;
// Handler soft budget: the timer closes the transport so stuck handlers
// fail fast; the result is discarded when over budget.
budget_exceeded_ = false;
TimerWheel::TimerId budget = loop_.schedule_after(
config_.handler_budget, [self] {
self->budget_exceeded_ = true;
if (self->waiter_) self->waiter_->Wake();
if (self->transport_) self->transport_->close();
});
FullResponse resp;
bool handler_ok = true;
try {
resp = co_await handler_(req);
} catch (...) {
handler_ok = false;
}
loop_.cancel_timer(budget);
if (closed_ || budget_exceeded_) {
close();
co_return;
}
if (!handler_ok) {
co_await SendError(500, true);
co_return;
}
++requests_;
bool head_only = (head.method == "HEAD");
bool no_body_status = resp.head.status == 204 || resp.head.status == 304 ||
(resp.head.status >= 100 && resp.head.status < 200);
bool have_file = resp.file.has_value() && resp.file->fd >= 0;
if (have_file && !resp.body.empty()) {
// Contract violation: file and string body at once. Fail closed.
::close(resp.file->fd);
resp.file.reset();
co_await SendError(500, true);
co_return;
}
uint64_t file_len = 0;
bool send_file = false;
if (have_file) {
// Clamp before serializing so Content-Length always matches the bytes.
if (!ClampFileBody(*resp.file)) {
::close(resp.file->fd);
resp.file.reset();
co_await SendError(500, true);
co_return;
}
file_len = resp.file->length;
if (head_only || no_body_status) {
::close(resp.file->fd); // HEAD keeps the length, drops the bytes
resp.file.reset();
} else {
send_file = true;
}
}
std::size_t body_len =
have_file ? SaturateToSize(file_len) : resp.body.size();
out_.append(v1::Serializer::SerializeHead(resp.head, head.version, false,
body_len, head_only, !keep));
if (send_file) {
FileBody fb = *resp.file;
resp.file.reset();
if (out_.size() > config_.write_ceiling) {
::close(fb.fd);
close();
co_return;
}
if (!co_await Flush(config_.idle_timeout)) {
::close(fb.fd);
close();
co_return;
}
if (!co_await SendFileBody(fb, config_.idle_timeout)) {
close();
co_return;
}
} else {
if (!head_only) out_.append(resp.body);
if (out_.size() > config_.write_ceiling) {
close();
co_return;
}
if (!co_await Flush(config_.idle_timeout)) {
close();
co_return;
}
}
in_request_ = false;
if (!keep || requests_ >= config_.max_requests) {
close();
co_return;
}
}
close();
}
Task<void> Connection::RunH2(bool expect_magic, bool from_upgrade,
const RequestHead& upgrade_head,
const std::string& upgrade_body) {
auto self = shared_from_this();
v2::H2Config cfg;
cfg.body_cap = config_.body_cap;
cfg.idle_timeout = config_.idle_timeout;
cfg.handler_budget = config_.handler_budget;
auto h2 = std::make_shared<v2::H2Connection>(*this, cfg);
set_in_request(true);
set_active_h2(h2.get());
if (draining_) h2->drain();
co_await h2->Run(expect_magic, from_upgrade, upgrade_head, upgrade_body);
requests_ += h2->requests_served();
set_active_h2(nullptr);
set_in_request(false);
close();
}
} // namespace molo::runtime::http