Files
aevolution/include/evo/server/ops_http.hpp
T
dingoandClaude Opus 5.5 7aec68db8e Complete M7.8 operations endpoints and region server image
ADR-0066: evo-server --ops-listen serves /livez (loop responding, never
authority), /readyz (200 only while the host holds the lease with a
verified recovered head) and /metrics (Prometheus text: 30 fixed
series for readiness, phase, lease epoch/remaining, simulated/committed
ticks, commit lag, checkpoint age, tick debt, queue use and bounds, and
counters; the only labels are a 6-value phase and 4-value drop reason).

The dependency-free OpsServer runs on the host loop with no thread:
GET on exact paths, 405/404/400/431 responses, 8 connections with excess
refused on accept, 4 KiB requests, 1 s deadlines, 16 KiB responses.
HostStatus/phase types moved to the portable evo::ops library with a
Windows-tested renderer. evo-server now refuses to start without its
required identity and connection settings.

Adds the server-runtime Docker target (evo-server + pinned libpq,
UID 10001, no credentials), a CI server-image job with smoke script and
optional publishing, and a Kubernetes example outside Argo.

Validated: Windows CTest 59/59; Linux Debug/Release/clang-tidy/ASan
CTest 59/59; PostgreSQL suites under Release, clang-tidy and ASan with
real process probes; two ops mutations caught. Docker build/smoke and
Gitea CI not executed locally.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-28 23:09:28 -04:00

68 lines
2.4 KiB
C++

#pragma once
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <expected>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
// Minimal operational HTTP/1.1 responder for probes and metrics (M7.8, ADR-0066).
// Linux. Not a general web server: GET only, one request per connection
// (Connection: close), bounded connections, request bytes, response bytes and
// per-connection time. serve() never blocks; it runs on the host's own loop so
// answers always describe the current state and no thread is added.
namespace evo::server {
struct OpsResponse {
int status{200};
std::string body;
std::string content_type{"text/plain; charset=utf-8"};
};
// Receives the request path (no query handling: probes use exact paths).
using OpsHandler = std::function<OpsResponse(std::string_view path)>;
enum class OpsError : std::uint8_t { address, socket };
class OpsServer {
public:
static constexpr std::size_t max_connections = 8;
static constexpr std::size_t max_request_bytes = 4096;
static constexpr std::size_t max_response_bytes = 16384;
static constexpr std::chrono::milliseconds connection_deadline{1000};
// Numeric address only ("127.0.0.1:9100" or "[::1]:9100"); port 0 picks one.
[[nodiscard]] static std::expected<std::unique_ptr<OpsServer>, OpsError>
listen(std::string_view address);
OpsServer(const OpsServer&) = delete;
OpsServer& operator=(const OpsServer&) = delete;
OpsServer(OpsServer&&) = delete;
OpsServer& operator=(OpsServer&&) = delete;
~OpsServer();
[[nodiscard]] std::uint16_t port() const noexcept {
return port_;
}
// Accepts, reads, answers and expires connections without waiting. Connections
// beyond the bound are closed at once; slow or oversized ones are answered or
// dropped without delaying others.
void serve(const OpsHandler& handler);
[[nodiscard]] std::uint64_t refused() const noexcept {
return refused_;
}
private:
struct Connection {
int fd{-1};
std::string in, out;
std::size_t sent{};
std::chrono::steady_clock::time_point deadline{};
};
OpsServer(int fd, std::uint16_t port) : fd_(fd), port_(port) {}
void respond(Connection& c, const OpsHandler& handler);
int fd_;
std::uint16_t port_;
std::vector<Connection> connections_;
std::uint64_t refused_{};
};
} // namespace evo::server