From 10b32cb382b981f606bab412293c9e6bd0cef188 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 06:56:04 +0900 Subject: [PATCH 01/13] fix(observability): Correct memory usage PromQL in Grafana dashboard The memory usage percentage panel divided mygramdb_memory_used_bytes by mygramdb_memory_system_total_bytes without reconciling the differing label sets: the numerator has a type="total" label that the denominator lacks, causing the Prometheus query engine to return no samples. Use `ignoring(type)` on the division so the two vectors match on the remaining labels. --- examples/grafana-dashboard.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/grafana-dashboard.json b/examples/grafana-dashboard.json index 3bef8bf..2a99b7b 100644 --- a/examples/grafana-dashboard.json +++ b/examples/grafana-dashboard.json @@ -149,7 +149,7 @@ "targets": [ { "datasource": "${DS_PROMETHEUS}", - "expr": "mygramdb_memory_used_bytes{instance=~\"$instance\", type=\"total\"} / mygramdb_memory_system_total_bytes{instance=~\"$instance\"} * 100", + "expr": "mygramdb_memory_used_bytes{instance=~\"$instance\", type=\"total\"} / ignoring(type) mygramdb_memory_system_total_bytes{instance=~\"$instance\"} * 100", "legendFormat": "{{instance}}" } ], From c66e8b13ebc3c93b543aeab9b7d19f84794f2e1c Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 06:56:52 +0900 Subject: [PATCH 02/13] feat(server): Add reactor I/O model as the default TCP path Replace the blocking one-thread-per-connection model with an event-driven reactor that uses epoll (Linux) or kqueue (macOS) for readiness notification and a bounded per-connection write queue with inline fast-path plus EPOLLOUT fallback for output. The blocking path stays available behind api.tcp.io_model="blocking" so the feature flag can gate rollout, but the default is now "reactor". Core components - src/server/reactor/event_multiplexer.{h,cpp}: platform-agnostic interface for readiness events - src/server/reactor/epoll_multiplexer.{h,cpp}: level-triggered epoll implementation (Linux) - src/server/reactor/kqueue_multiplexer.{h,cpp}: kqueue implementation (macOS/BSD) - src/server/io_reactor.{h,cpp}: single-threaded event loop owning the multiplexer, connection registration, arm/disarm-write, graceful shutdown, and per-fd close callbacks - src/server/reactor_connection.{h,cpp}: per-connection state with a drain-task pattern, non-blocking write queue (std::deque plus front_offset tracking for partial head sends), the "clear-then-recheck" reschedule idiom, and per-connection max_write_queue_bytes cap for slow-reader backpressure Integration - ConnectionAcceptor now dispatches accepted fds to a reactor handler when io_model="reactor"; the existing connection_handler_ callback stays in place for the blocking fallback (to be removed later after an observation window) - TcpServer wires IoReactor lifecycle into Start/Stop, propagates max_write_queue_bytes, and increments/decrements active_connections from the reactor accept and close callbacks so ServerStats remains accurate under the new default - ServerLifecycleManager drains the reactor ahead of the thread pool on shutdown - config.h/config.cpp/config-schema.json/config_help.cpp/ runtime_variable_manager.cpp add api.tcp.max_write_queue_bytes (default 16 MiB, immutable at runtime) and flip io_model default to "reactor" - src/utils/error.h adds 6016-6023 for reactor init/poll/register/modify/ remove/queue-full/already-open failure modes Thread pool auto-size floor revert - src/server/thread_pool.cpp: drop the emergency hw*4/64-worker floor that was added to mitigate blocking-mode starvation. With the reactor default a single event-loop thread plus a small worker pool can serve thousands of persistent connections, so the original max(hw*2, 4) formula is restored. --- src/app/server_orchestrator.cpp | 9 + src/config/config-schema.json | 74 ++++ src/config/config.cpp | 33 ++ src/config/config.h | 63 ++++ src/config/config_help.cpp | 13 + src/config/runtime_variable_manager.cpp | 36 ++ src/server/CMakeLists.txt | 5 + src/server/connection_acceptor.cpp | 91 +++++ src/server/connection_acceptor.h | 53 ++- src/server/io_reactor.cpp | 270 +++++++++++++++ src/server/io_reactor.h | 231 +++++++++++++ src/server/reactor/epoll_multiplexer.cpp | 185 ++++++++++ src/server/reactor/epoll_multiplexer.h | 62 ++++ src/server/reactor/event_multiplexer.cpp | 31 ++ src/server/reactor/event_multiplexer.h | 158 +++++++++ src/server/reactor/kqueue_multiplexer.cpp | 315 +++++++++++++++++ src/server/reactor/kqueue_multiplexer.h | 127 +++++++ src/server/reactor_connection.cpp | 400 ++++++++++++++++++++++ src/server/reactor_connection.h | 299 ++++++++++++++++ src/server/server_lifecycle_manager.cpp | 12 +- src/server/server_types.h | 16 + src/server/tcp_server.cpp | 112 +++++- src/server/tcp_server.h | 12 + src/server/thread_pool.cpp | 24 +- src/utils/error.h | 24 ++ 25 files changed, 2630 insertions(+), 25 deletions(-) create mode 100644 src/server/io_reactor.cpp create mode 100644 src/server/io_reactor.h create mode 100644 src/server/reactor/epoll_multiplexer.cpp create mode 100644 src/server/reactor/epoll_multiplexer.h create mode 100644 src/server/reactor/event_multiplexer.cpp create mode 100644 src/server/reactor/event_multiplexer.h create mode 100644 src/server/reactor/kqueue_multiplexer.cpp create mode 100644 src/server/reactor/kqueue_multiplexer.h create mode 100644 src/server/reactor_connection.cpp create mode 100644 src/server/reactor_connection.h diff --git a/src/app/server_orchestrator.cpp b/src/app/server_orchestrator.cpp index b423eac..f9737e9 100644 --- a/src/app/server_orchestrator.cpp +++ b/src/app/server_orchestrator.cpp @@ -418,6 +418,15 @@ mygram::utils::Expected ServerOrchestrator::Initiali server_config.host = deps_.config.api.tcp.bind; server_config.port = deps_.config.api.tcp.port; server_config.max_connections = deps_.config.api.tcp.max_connections; + server_config.worker_threads = deps_.config.api.tcp.worker_threads; + server_config.recv_timeout_sec = deps_.config.api.tcp.recv_timeout_sec; + server_config.thread_pool_queue_size = deps_.config.api.tcp.thread_pool_queue_size; + server_config.keepalive.enabled = deps_.config.api.tcp.keepalive.enabled; + server_config.keepalive.idle_sec = deps_.config.api.tcp.keepalive.idle_sec; + server_config.keepalive.interval_sec = deps_.config.api.tcp.keepalive.interval_sec; + server_config.keepalive.probe_count = deps_.config.api.tcp.keepalive.probe_count; + server_config.io_model = deps_.config.api.tcp.io_model; + server_config.max_write_queue_bytes = deps_.config.api.tcp.max_write_queue_bytes; server_config.default_limit = deps_.config.api.default_limit; server_config.max_query_length = deps_.config.api.max_query_length; server_config.allow_cidrs = deps_.config.network.allow_cidrs; diff --git a/src/config/config-schema.json b/src/config/config-schema.json index f5361f7..69883d3 100644 --- a/src/config/config-schema.json +++ b/src/config/config-schema.json @@ -509,6 +509,80 @@ "default": 11016, "minimum": 1, "maximum": 65535 + }, + "max_connections": { + "type": "integer", + "description": "Maximum number of concurrent TCP connections accepted by the server.", + "default": 10000, + "minimum": 1, + "maximum": 1000000 + }, + "worker_threads": { + "type": "integer", + "description": "Number of worker threads in the TCP thread pool. In the blocking I/O model each persistent client holds one worker for its entire lifetime (blocking recv loop with 60s idle keepalive), so this is also the cap on concurrent persistent clients. 0 = auto (max(hardware_concurrency() * 4, 64)). Set explicitly when you know your client concurrency.", + "default": 0, + "minimum": 0, + "maximum": 16384 + }, + "recv_timeout_sec": { + "type": "integer", + "description": "SO_RCVTIMEO applied to accepted client connections. With the current blocking-recv I/O model, this also bounds how long a worker stays parked on an idle or half-dead client. 0 disables the timeout.", + "default": 60, + "minimum": 0, + "maximum": 86400 + }, + "thread_pool_queue_size": { + "type": "integer", + "description": "Maximum number of connection tasks that can be queued waiting for a worker. When this is exceeded, the acceptor sends SERVER_BUSY and closes the connection. 0 = unbounded (not recommended in production).", + "default": 1000, + "minimum": 0, + "maximum": 1000000 + }, + "keepalive": { + "type": "object", + "description": "Per-connection TCP keepalive settings applied to accepted client sockets. Tightens Linux's multi-hour defaults so half-open connections (dead peer host) are detected within a few minutes. See docs/ja/design/reactor-io-refactor.md §1.1.", + "additionalProperties": false, + "properties": { + "enabled": { + "type": "boolean", + "description": "Enable SO_KEEPALIVE on accepted client sockets.", + "default": true + }, + "idle_sec": { + "type": "integer", + "description": "TCP_KEEPIDLE: seconds of idle before the first keepalive probe is sent.", + "default": 60, + "minimum": 1, + "maximum": 86400 + }, + "interval_sec": { + "type": "integer", + "description": "TCP_KEEPINTVL: seconds between keepalive probes.", + "default": 20, + "minimum": 1, + "maximum": 3600 + }, + "probe_count": { + "type": "integer", + "description": "TCP_KEEPCNT: number of unanswered probes before declaring the peer dead.", + "default": 3, + "minimum": 1, + "maximum": 32 + } + } + }, + "io_model": { + "type": "string", + "description": "I/O model for persistent TCP connections. \"reactor\" (default): epoll/kqueue event loop with drain-task-per-connection workers; decouples the concurrent-client cap from worker_threads. \"blocking\": legacy one-worker-per-connection recv loop, retained as fallback and emergency rollback lever. \"reactor\" falls back to \"blocking\" on platforms without a supported event multiplexer.", + "enum": ["blocking", "reactor"], + "default": "reactor" + }, + "max_write_queue_bytes": { + "type": "integer", + "description": "Per-connection soft cap on unsent response bytes under the reactor I/O model. When a single connection's write queue exceeds this cap, the reactor forcibly closes the connection to protect the server from slow-reader OOM. Default: 16 MiB (16777216 bytes). Only meaningful when io_model=\"reactor\".", + "default": 16777216, + "minimum": 4096, + "maximum": 1073741824 } } }, diff --git a/src/config/config.cpp b/src/config/config.cpp index 71548dc..6224b74 100644 --- a/src/config/config.cpp +++ b/src/config/config.cpp @@ -704,6 +704,39 @@ Config ParseConfigFromJson(const json& root) { if (tcp.contains("port")) { config.api.tcp.port = tcp["port"].get(); } + if (tcp.contains("max_connections")) { + config.api.tcp.max_connections = tcp["max_connections"].get(); + } + if (tcp.contains("worker_threads")) { + config.api.tcp.worker_threads = tcp["worker_threads"].get(); + } + if (tcp.contains("recv_timeout_sec")) { + config.api.tcp.recv_timeout_sec = tcp["recv_timeout_sec"].get(); + } + if (tcp.contains("thread_pool_queue_size")) { + config.api.tcp.thread_pool_queue_size = tcp["thread_pool_queue_size"].get(); + } + if (tcp.contains("keepalive")) { + const auto& ka = tcp["keepalive"]; + if (ka.contains("enabled")) { + config.api.tcp.keepalive.enabled = ka["enabled"].get(); + } + if (ka.contains("idle_sec")) { + config.api.tcp.keepalive.idle_sec = ka["idle_sec"].get(); + } + if (ka.contains("interval_sec")) { + config.api.tcp.keepalive.interval_sec = ka["interval_sec"].get(); + } + if (ka.contains("probe_count")) { + config.api.tcp.keepalive.probe_count = ka["probe_count"].get(); + } + } + if (tcp.contains("io_model")) { + config.api.tcp.io_model = tcp["io_model"].get(); + } + if (tcp.contains("max_write_queue_bytes")) { + config.api.tcp.max_write_queue_bytes = tcp["max_write_queue_bytes"].get(); + } } if (api.contains("http")) { const auto& http = api["http"]; diff --git a/src/config/config.h b/src/config/config.h index eb3dbe5..7185fed 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -232,6 +232,69 @@ struct ApiConfig { std::string bind = "127.0.0.1"; int port = defaults::kTcpPort; int max_connections = kDefaultMaxConnections; ///< Maximum concurrent connections + /// Number of worker threads in the TCP thread pool. + /// Architecture note: each persistent client holds one worker for its entire + /// lifetime (blocking recv loop with 60s idle timeout), so this cap is also + /// the maximum number of concurrent persistent clients the server can serve. + /// 0 = auto (see ThreadPool: max(hardware_concurrency() * 4, 64)) + int worker_threads = 0; + + /// SO_RCVTIMEO (seconds) applied to each client connection. + /// Drives the blocking recv() idle watchdog; also bounds the worst-case + /// time a worker remains stuck on a dead peer before Linux's own TCP + /// keepalive probes expire. Default: 60. + int recv_timeout_sec = 60; // NOLINT(readability-magic-numbers) + + /// Thread pool task queue size. Once a connection is accepted but cannot + /// be dispatched (all workers busy, queue full), the server responds with + /// SERVER_BUSY and closes. Default: 1000. + int thread_pool_queue_size = 1000; // NOLINT(readability-magic-numbers) + + /// Per-connection soft cap on unsent response bytes under the reactor + /// I/O model (design doc §7 R3). When a single connection's write queue + /// exceeds this cap, the reactor forcibly closes the connection to + /// protect the server from slow-reader OOM. Only meaningful when + /// `io_model == "reactor"`. Default: 16 MiB. A production operator who + /// sees `reactor_write_queue_overflow` warnings in steady state should + /// either raise this cap (if the responses are legitimately large) or + /// investigate the client(s) that are failing to drain their socket. + int64_t max_write_queue_bytes = 16LL * 1024 * 1024; // 16 MiB + + /// Per-connection TCP keepalive (applied to accepted client sockets). + /// + /// Under the blocking-recv I/O model, a half-open TCP connection (peer's + /// host died but the socket was never closed) keeps a worker thread parked + /// in recv() until either `recv_timeout_sec` fires or TCP keepalive probes + /// expire. The Linux defaults (2 hour idle + 75s interval * 9 probes) are + /// too permissive for a latency-sensitive server, so we tighten them here. + /// This is kept as a defense-in-depth measure even after the reactor + /// refactor switches away from blocking recv. + struct { + bool enabled = true; + int idle_sec = 60; ///< TCP_KEEPIDLE: start probing after N seconds idle + int interval_sec = 20; ///< TCP_KEEPINTVL: seconds between probes + int probe_count = 3; ///< TCP_KEEPCNT: probes before declaring dead + } keepalive; + + /// I/O model for persistent TCP connections. + /// + /// "reactor" (default): epoll/kqueue-based non-blocking event loop with a + /// drain-task-per-connection worker pattern. The event loop thread reads + /// complete command frames off each fd and hands them to the thread pool; + /// workers do not block on recv. This decouples the maximum number of + /// concurrent persistent clients from `worker_threads` and is the Phase 3 + /// default (design doc §5 Phase 3.3). + /// + /// "blocking": legacy 1-worker-per-connection recv loop. Retained as a + /// fallback for platforms with no supported event multiplexer and as an + /// emergency rollback lever. Under this model each accepted client parks + /// one thread pool worker until the peer closes or `recv_timeout_sec` + /// fires, which makes the server vulnerable to starvation once the number + /// of persistent clients exceeds `worker_threads`. + /// + /// On platforms with no supported event multiplexer (neither epoll nor + /// kqueue), "reactor" falls back to "blocking" at startup with a warning. + std::string io_model = "reactor"; } tcp; struct { diff --git a/src/config/config_help.cpp b/src/config/config_help.cpp index 926f47a..26ffe5b 100644 --- a/src/config/config_help.cpp +++ b/src/config/config_help.cpp @@ -183,6 +183,19 @@ nlohmann::json ConfigToJson(const Config& config) { { {"bind", config.api.tcp.bind}, {"port", config.api.tcp.port}, + {"max_connections", config.api.tcp.max_connections}, + {"worker_threads", config.api.tcp.worker_threads}, + {"recv_timeout_sec", config.api.tcp.recv_timeout_sec}, + {"thread_pool_queue_size", config.api.tcp.thread_pool_queue_size}, + {"keepalive", + { + {"enabled", config.api.tcp.keepalive.enabled}, + {"idle_sec", config.api.tcp.keepalive.idle_sec}, + {"interval_sec", config.api.tcp.keepalive.interval_sec}, + {"probe_count", config.api.tcp.keepalive.probe_count}, + }}, + {"io_model", config.api.tcp.io_model}, + {"max_write_queue_bytes", config.api.tcp.max_write_queue_bytes}, }}, {"http", { diff --git a/src/config/runtime_variable_manager.cpp b/src/config/runtime_variable_manager.cpp index 60d820e..5eb6992 100644 --- a/src/config/runtime_variable_manager.cpp +++ b/src/config/runtime_variable_manager.cpp @@ -58,6 +58,15 @@ static const std::map kVariableMutability = { {"api.tcp.bind", false}, // Immutable (requires socket rebind) {"api.tcp.port", false}, // Immutable {"api.tcp.max_connections", false}, // Immutable + {"api.tcp.worker_threads", false}, // Immutable (thread pool is bound at startup) + {"api.tcp.recv_timeout_sec", false}, // Immutable (applied per connection at accept) + {"api.tcp.thread_pool_queue_size", false}, // Immutable (thread pool queue sized at startup) + {"api.tcp.keepalive.enabled", false}, // Immutable (applied per connection at accept) + {"api.tcp.keepalive.idle_sec", false}, // Immutable + {"api.tcp.keepalive.interval_sec", false}, // Immutable + {"api.tcp.keepalive.probe_count", false}, // Immutable + {"api.tcp.io_model", false}, // Immutable (selects reactor vs blocking at startup) + {"api.tcp.max_write_queue_bytes", false}, // Immutable (per-connection cap set at accept) {"api.http.enable", false}, // Immutable {"api.http.bind", false}, // Immutable {"api.http.port", false}, // Immutable @@ -615,6 +624,33 @@ std::string RuntimeVariableManager::GetVariableInternal(const std::string& varia if (variable_name == "api.tcp.max_connections") { return std::to_string(base_config_.api.tcp.max_connections); } + if (variable_name == "api.tcp.worker_threads") { + return std::to_string(base_config_.api.tcp.worker_threads); + } + if (variable_name == "api.tcp.recv_timeout_sec") { + return std::to_string(base_config_.api.tcp.recv_timeout_sec); + } + if (variable_name == "api.tcp.thread_pool_queue_size") { + return std::to_string(base_config_.api.tcp.thread_pool_queue_size); + } + if (variable_name == "api.tcp.keepalive.enabled") { + return base_config_.api.tcp.keepalive.enabled ? "true" : "false"; + } + if (variable_name == "api.tcp.keepalive.idle_sec") { + return std::to_string(base_config_.api.tcp.keepalive.idle_sec); + } + if (variable_name == "api.tcp.keepalive.interval_sec") { + return std::to_string(base_config_.api.tcp.keepalive.interval_sec); + } + if (variable_name == "api.tcp.keepalive.probe_count") { + return std::to_string(base_config_.api.tcp.keepalive.probe_count); + } + if (variable_name == "api.tcp.io_model") { + return base_config_.api.tcp.io_model; + } + if (variable_name == "api.tcp.max_write_queue_bytes") { + return std::to_string(base_config_.api.tcp.max_write_queue_bytes); + } if (variable_name == "api.http.enable") { return base_config_.api.http.enable ? "true" : "false"; } diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt index 8ff8d4a..d789e8c 100644 --- a/src/server/CMakeLists.txt +++ b/src/server/CMakeLists.txt @@ -12,6 +12,11 @@ add_library(mygramdb_server STATIC request_dispatcher.cpp snapshot_scheduler.cpp connection_io_handler.cpp + reactor_connection.cpp + io_reactor.cpp + reactor/event_multiplexer.cpp + reactor/epoll_multiplexer.cpp + reactor/kqueue_multiplexer.cpp sync_operation_manager.cpp rate_limiter.cpp handlers/command_handler.cpp diff --git a/src/server/connection_acceptor.cpp b/src/server/connection_acceptor.cpp index 184e8a6..4d88e27 100644 --- a/src/server/connection_acceptor.cpp +++ b/src/server/connection_acceptor.cpp @@ -7,6 +7,7 @@ #include #include +#include #include #include #include @@ -354,6 +355,10 @@ void ConnectionAcceptor::SetConnectionHandler(ConnectionHandler handler) { connection_handler_ = std::move(handler); } +void ConnectionAcceptor::SetReactorHandler(ReactorHandler handler) { + reactor_handler_ = std::move(handler); +} + void ConnectionAcceptor::AcceptLoop() { if (IsUnixSocket()) { mygram::utils::StructuredLog().Event("accept_loop_started").Field("unix_socket", unix_socket_path_).Debug(); @@ -450,6 +455,70 @@ void ConnectionAcceptor::AcceptLoop() { .Warn(); } + // Apply per-connection TCP keepalive on TCP sockets only (not UDS). + // + // Background: under the blocking-recv I/O model a half-open connection + // parks a worker thread in recv() until either SO_RCVTIMEO elapses or + // Linux's TCP keepalive declares the peer dead. The stock Linux defaults + // (2h idle + 9 probes * 75s) are useless here, so we tighten them per + // YAML config. This is the Phase 1 mitigation from + // docs/ja/design/reactor-io-refactor.md §1.1. + if (!IsUnixSocket() && config_.keepalive.enabled) { + int keepalive_on = 1; + if (setsockopt(client_fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive_on, sizeof(keepalive_on)) < 0) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "setsockopt_failed") + .Field("option", "SO_KEEPALIVE") + .Field("error", strerror(errno)) + .Warn(); + } +#if defined(__linux__) + // Linux exposes TCP_KEEPIDLE/TCP_KEEPINTVL/TCP_KEEPCNT. These are our + // production target and where this mitigation actually matters. + int idle_sec = config_.keepalive.idle_sec; + int intvl_sec = config_.keepalive.interval_sec; + int probe_cnt = config_.keepalive.probe_count; + if (setsockopt(client_fd, IPPROTO_TCP, TCP_KEEPIDLE, &idle_sec, sizeof(idle_sec)) < 0) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "setsockopt_failed") + .Field("option", "TCP_KEEPIDLE") + .Field("error", strerror(errno)) + .Warn(); + } + if (setsockopt(client_fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl_sec, sizeof(intvl_sec)) < 0) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "setsockopt_failed") + .Field("option", "TCP_KEEPINTVL") + .Field("error", strerror(errno)) + .Warn(); + } + if (setsockopt(client_fd, IPPROTO_TCP, TCP_KEEPCNT, &probe_cnt, sizeof(probe_cnt)) < 0) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "setsockopt_failed") + .Field("option", "TCP_KEEPCNT") + .Field("error", strerror(errno)) + .Warn(); + } +#elif defined(__APPLE__) && defined(TCP_KEEPALIVE) + // macOS/BSD only exposes TCP_KEEPALIVE (equivalent to Linux TCP_KEEPIDLE). + // Interval/count fall back to system defaults. production target is + // Linux; this branch only keeps dev/CI on macOS functional. + int idle_sec = config_.keepalive.idle_sec; + if (setsockopt(client_fd, IPPROTO_TCP, TCP_KEEPALIVE, &idle_sec, sizeof(idle_sec)) < 0) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "setsockopt_failed") + .Field("option", "TCP_KEEPALIVE") + .Field("error", strerror(errno)) + .Warn(); + } +#endif + } + #ifdef __APPLE__ // On macOS, set SO_NOSIGPIPE to prevent SIGPIPE when writing to closed connections // Linux uses MSG_NOSIGNAL flag instead, but writev() doesn't support flags @@ -470,6 +539,28 @@ void ConnectionAcceptor::AcceptLoop() { active_fds_.insert(client_fd); } + // Reactor I/O model: hand off inline on the accept thread. The reactor + // takes ownership of the fd on success; on failure the acceptor emits + // SERVER_BUSY and closes the fd itself. The active_fds_ entry stays + // until IoReactor's close callback invokes RemoveConnection. + if (reactor_handler_) { + const bool accepted = reactor_handler_(client_fd); + if (!accepted) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "reactor_register_rejected") + .Field("client_fd", static_cast(client_fd)) + .Warn(); + static constexpr std::string_view kBusyResponse = + "ERR SERVER_BUSY Server is too busy, please try again later\r\n"; + // NOLINTNEXTLINE(bugprone-unused-return-value,cert-err33-c) + write(client_fd, kBusyResponse.data(), kBusyResponse.size()); + close(client_fd); + RemoveConnection(client_fd); + } + continue; // next accept() + } + // Submit to thread pool if (thread_pool_ != nullptr && connection_handler_) { bool submitted = thread_pool_->Submit([this, client_fd]() { diff --git a/src/server/connection_acceptor.h b/src/server/connection_acceptor.h index 22babc5..77cd47e 100644 --- a/src/server/connection_acceptor.h +++ b/src/server/connection_acceptor.h @@ -44,13 +44,31 @@ class ThreadPool; class ConnectionAcceptor { public: /** - * @brief Connection handler callback type + * @brief Connection handler callback type (blocking I/O model). * - * This callback is invoked for each accepted connection. - * The handler should process the connection and close the file descriptor. + * Invoked for each accepted connection when `SetConnectionHandler` has been + * installed. The handler runs on a thread pool worker and is responsible for + * processing the connection and closing the file descriptor. */ using ConnectionHandler = std::function; + /** + * @brief Reactor handler callback type (reactor I/O model). + * + * Invoked **inline** on the accept thread for each accepted connection when + * `SetReactorHandler` has been installed. The handler must take ownership of + * `client_fd` and return true, or return false to reject the connection + * (the acceptor will then emit `ERR SERVER_BUSY` and close the fd). + * + * No thread pool hop: the reactor's `IoReactor::Register` is cheap (map + * insert + one epoll_ctl/kevent) and latency-sensitive, so bouncing through + * a worker would add a context switch for no gain. + * + * When a reactor handler is installed, the blocking `ConnectionHandler` path + * is NOT used even if it was also set. + */ + using ReactorHandler = std::function; + /** * @brief Construct a ConnectionAcceptor * @param config Server configuration @@ -80,11 +98,31 @@ class ConnectionAcceptor { void Stop(); /** - * @brief Set connection handler callback + * @brief Set connection handler callback (blocking model). * @param handler Callback to handle accepted connections */ void SetConnectionHandler(ConnectionHandler handler); + /** + * @brief Set reactor handler callback (reactor model). + * + * Installing a reactor handler switches the accept path from "submit to + * thread pool" to "hand off to reactor inline". Used in conjunction with + * `api.tcp.io_model = "reactor"`. + * + * @param handler Callback that takes ownership of the fd on true return. + */ + void SetReactorHandler(ReactorHandler handler); + + /** + * @brief Remove a connection from the active set. + * + * Exposed publicly so that `IoReactor`'s close callback can decrement the + * `max_connections` gate when it tears down a reactor connection. Safe to + * call from any thread. + */ + void RemoveConnection(int socket_fd); + /** * @brief Get actual port being listened on * @return Port number (useful when config.port = 0) @@ -116,15 +154,10 @@ class ConnectionAcceptor { */ bool SetSocketOptions(int socket_fd) const; - /** - * @brief Remove connection from active list - * @param socket_fd Socket file descriptor - */ - void RemoveConnection(int socket_fd); - ServerConfig config_; ThreadPool* thread_pool_; ConnectionHandler connection_handler_; + ReactorHandler reactor_handler_; int server_fd_ = -1; uint16_t actual_port_ = 0; diff --git a/src/server/io_reactor.cpp b/src/server/io_reactor.cpp new file mode 100644 index 0000000..57dfdc9 --- /dev/null +++ b/src/server/io_reactor.cpp @@ -0,0 +1,270 @@ +/** + * @file io_reactor.cpp + * @brief Phase 2 IoReactor implementation — single-threaded event loop. + */ + +#include "server/io_reactor.h" + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "server/reactor/event_multiplexer.h" +#include "utils/error.h" +#include "utils/expected.h" +#include "utils/structured_log.h" + +namespace mygramdb::server { + +using mygram::utils::Error; +using mygram::utils::ErrorCode; +using mygram::utils::Expected; +using mygram::utils::MakeError; +using mygram::utils::MakeUnexpected; + +namespace { +constexpr size_t kReadyEventReserve = 64; +} + +IoReactor::IoReactor(ThreadPool* pool, RequestDispatcher* dispatcher, ReactorConfig cfg) + : pool_(pool), dispatcher_(dispatcher), config_(std::move(cfg)) {} + +IoReactor::~IoReactor() { + Stop(); +} + +Expected IoReactor::Start() { + if (running_.load(std::memory_order_acquire)) { + return {}; + } + + // In tests, mux_factory_ is set via SetMultiplexerFactoryForTest() to + // inject a MockEventMultiplexer. In production this branch is never taken. + auto mux = mux_factory_ ? mux_factory_() : reactor::CreateEventMultiplexer(); + if (!mux) { + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorUnsupported, "No event multiplexer available on this platform")); + } + if (auto r = mux->Open(); !r) { + return MakeUnexpected(r.error()); + } + + mux_ = std::move(mux); + running_.store(true, std::memory_order_release); + event_loop_thread_ = std::thread([this]() { EventLoop(); }); + + mygram::utils::StructuredLog() + .Event("reactor_started") + .Field("backend", mux_->Name()) + .Field("poll_timeout_ms", static_cast(config_.poll_timeout_ms)) + .Info(); + return {}; +} + +void IoReactor::Stop() { + if (!running_.exchange(false, std::memory_order_acq_rel)) { + // Never started, or already stopped. + if (event_loop_thread_.joinable()) { + event_loop_thread_.join(); + } + return; + } + + if (event_loop_thread_.joinable()) { + event_loop_thread_.join(); + } + + // Drop all registered connections. Drain tasks that still hold a + // shared_ptr copy will keep their connection alive until they finish. + { + std::unique_lock lock(connections_mutex_); + connections_.clear(); + } + { + // Exclusive lock: wait for any in-flight Register/Unregister/ArmWrite to + // finish before destroying the multiplexer. The event-loop thread has + // already been joined, so the only contenders are other threads. + std::unique_lock lock(mux_lifecycle_); + mux_.reset(); + } + + mygram::utils::StructuredLog().Event("reactor_stopped").Info(); +} + +Expected IoReactor::Register(std::shared_ptr conn) { + if (!conn) { + return MakeUnexpected(MakeError(ErrorCode::kInvalidArgument, "Register called with null connection")); + } + if (!running_.load(std::memory_order_acquire)) { + return MakeUnexpected(MakeError(ErrorCode::kNetworkServerNotStarted, "IoReactor::Register before Start")); + } + + const int fd = conn->Fd(); + if (fd < 0) { + return MakeUnexpected(MakeError(ErrorCode::kInvalidArgument, "Register called with negative fd")); + } + + // Put the socket in non-blocking mode before handing it to the event loop. + // Without this, a recv() inside OnReadable would block the entire reactor. + const int flags = ::fcntl(fd, F_GETFL, 0); + if (flags < 0) { + return MakeUnexpected(MakeError(ErrorCode::kNetworkSocketCreationFailed, + std::string("fcntl(F_GETFL) failed: ") + std::strerror(errno))); + } + if ((flags & O_NONBLOCK) == 0) { + if (::fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) { + return MakeUnexpected(MakeError(ErrorCode::kNetworkSocketCreationFailed, + std::string("fcntl(F_SETFL, O_NONBLOCK) failed: ") + std::strerror(errno))); + } + } + + { + std::unique_lock lock(connections_mutex_); + if (connections_.count(fd) != 0U) { + return MakeUnexpected(MakeError(ErrorCode::kInternalError, "IoReactor::Register duplicate fd")); + } + connections_.emplace(fd, conn); + } + + { + std::shared_lock mux_lock(mux_lifecycle_); + if (!mux_) { + // Racing with Stop(): undo the insert. + std::unique_lock lock(connections_mutex_); + connections_.erase(fd); + return MakeUnexpected(MakeError(ErrorCode::kNetworkServerNotStarted, "IoReactor::Register during shutdown")); + } + auto r = mux_->Add(fd, reactor::event::kReadable); + if (!r) { + std::unique_lock lock(connections_mutex_); + connections_.erase(fd); + return MakeUnexpected(r.error()); + } + } + + return {}; +} + +void IoReactor::Unregister(int fd) { + // Remove from the multiplexer first so the event loop stops reporting + // events for this fd, then drop the shared_ptr from the map. Drain tasks + // that captured a copy keep the ReactorConnection alive until they + // finish, and only then does the destructor close(2) the socket. + bool was_registered = false; + { + std::shared_lock mux_lock(mux_lifecycle_); + if (mux_) { + // Remove() is idempotent from the caller's perspective. + (void)mux_->Remove(fd); + } + } + { + std::unique_lock lock(connections_mutex_); + was_registered = connections_.erase(fd) > 0; + } + // Close callback runs outside all locks so callers cannot deadlock the + // reactor by taking their own mutexes inside the callback. + if (was_registered && close_callback_) { + close_callback_(fd); + } +} + +void IoReactor::SetCloseCallback(std::function cb) { close_callback_ = std::move(cb); } + +void IoReactor::SetMultiplexerFactoryForTest(MultiplexerFactory f) { mux_factory_ = std::move(f); } + +Expected IoReactor::ArmWrite(int fd) { + std::shared_lock mux_lock(mux_lifecycle_); + if (!mux_) { + return MakeUnexpected(MakeError(ErrorCode::kNetworkServerNotStarted, "ArmWrite while reactor stopped")); + } + return mux_->Modify(fd, reactor::event::kReadable | reactor::event::kWritable); +} + +Expected IoReactor::DisarmWrite(int fd) { + std::shared_lock mux_lock(mux_lifecycle_); + if (!mux_) { + return MakeUnexpected(MakeError(ErrorCode::kNetworkServerNotStarted, "DisarmWrite while reactor stopped")); + } + return mux_->Modify(fd, reactor::event::kReadable); +} + +size_t IoReactor::ConnectionCount() const { + std::shared_lock lock(connections_mutex_); + return connections_.size(); +} + +const char* IoReactor::BackendName() const { + std::shared_lock lock(mux_lifecycle_); + return mux_ ? mux_->Name() : "unavailable"; +} + +std::shared_ptr IoReactor::Lookup(int fd) const { + std::shared_lock lock(connections_mutex_); + auto it = connections_.find(fd); + if (it == connections_.end()) { + return nullptr; + } + return it->second; +} + +void IoReactor::EventLoop() { + std::vector ready; + ready.reserve(kReadyEventReserve); + + while (running_.load(std::memory_order_acquire)) { + Expected poll_result; + { + // Hold the mux mutex for the duration of Poll so that concurrent + // Add/Modify/Remove calls do not race with the backend's internal + // state. The shared EventMultiplexer contract is single-threaded. + std::shared_lock mux_lock(mux_lifecycle_); + if (!mux_) { + break; + } + poll_result = mux_->Poll(config_.poll_timeout_ms, ready); + } + if (!poll_result) { + mygram::utils::StructuredLog() + .Event("reactor_poll_failed") + .Field("error", poll_result.error().to_string()) + .Warn(); + continue; + } + for (const auto& ev : ready) { + DispatchEvent(ev); + } + } +} + +void IoReactor::DispatchEvent(const reactor::ReadyEvent& ev) { + auto conn = Lookup(ev.fd); + if (!conn) { + // Stale event (connection was unregistered between Poll and dispatch). + return; + } + + bool keep = true; + if ((ev.events & (reactor::event::kError | reactor::event::kHangup)) != 0) { + keep = conn->OnError(); + } else { + if ((ev.events & reactor::event::kReadable) != 0 && keep) { + keep = conn->OnReadable(); + } + if ((ev.events & reactor::event::kWritable) != 0 && keep) { + keep = conn->OnWritable(); + } + } + + if (!keep) { + Unregister(ev.fd); + } +} + +} // namespace mygramdb::server diff --git a/src/server/io_reactor.h b/src/server/io_reactor.h new file mode 100644 index 0000000..bf11045 --- /dev/null +++ b/src/server/io_reactor.h @@ -0,0 +1,231 @@ +/** + * @file io_reactor.h + * @brief Single-threaded reactor event loop built on `EventMultiplexer`. + * + * Phase 2 implementation of docs/ja/design/reactor-io-refactor.md §4.4. + * + * Responsibilities: + * 1. Own one `reactor::EventMultiplexer` instance (epoll on Linux, kqueue + * on macOS/BSD, mock in tests). + * 2. Run a single event-loop thread that repeatedly calls `Poll()` and + * dispatches readable/writable/error events to the matching + * `ReactorConnection`. + * 3. Own the connection map keyed by fd. The map holds + * `std::shared_ptr` because worker drain tasks may + * capture a shared_ptr copy and keep the connection alive while writing + * the response (design doc §7 R5). + * 4. Provide thread-safe `Register`/`Unregister`/`ArmWrite`/`DisarmWrite` + * callable from the accept thread or from worker threads. + * + * Sharding across multiple event-loop threads is a Phase 3.5 optimisation; + * Phase 2 ships a single loop and measures first. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "server/reactor/event_multiplexer.h" +#include "server/reactor_connection.h" +#include "utils/error.h" +#include "utils/expected.h" + +namespace mygramdb::server { + +class ThreadPool; +class RequestDispatcher; + +/** + * @brief Runtime-tunable reactor settings. + * + * Additional fields for sharding count, event-loop CPU affinity, and write + * queue tuning will land alongside Phase 3 work. Values plumbed from YAML + * (`api.tcp.*`) feed into this struct. + */ +struct ReactorConfig { + /// Number of event-loop threads. Phase 2 hard-codes 1 regardless of this + /// value; sharding is Phase 3.5 (design doc §7 R2). + int event_loop_threads = 1; + + /// Per-connection soft cap on pending write bytes before the reactor + /// forcibly closes a slow reader. + size_t max_write_queue_bytes = ReactorConnection::kDefaultMaxWriteQueueBytes; + + /// Poll timeout in milliseconds. Short enough to react to `Stop()` + /// promptly, long enough to keep the event loop idle-efficient. + int poll_timeout_ms = 100; +}; + +/** + * @brief Single-threaded I/O reactor. + */ +class IoReactor { + public: + /** + * @param pool Non-owning thread pool used to run drain tasks. Must + * outlive this reactor. + * @param dispatcher Non-owning request dispatcher used by drain tasks. + * May be null if no connections are ever registered + * (e.g. reactor-parity unit tests with a mock mux). + * @param cfg Reactor tuning parameters. + */ + IoReactor(ThreadPool* pool, RequestDispatcher* dispatcher, ReactorConfig cfg); + ~IoReactor(); + + IoReactor(const IoReactor&) = delete; + IoReactor& operator=(const IoReactor&) = delete; + IoReactor(IoReactor&&) = delete; + IoReactor& operator=(IoReactor&&) = delete; + + /** + * @brief Create the multiplexer and start the event-loop thread. + * Idempotent: a second call while already running is a no-op success. + * + * Failure modes: + * - `kNetworkReactorUnsupported` if no multiplexer is available on this + * platform (CreateEventMultiplexer returned nullptr). + * - `kNetworkReactorInitFailed` propagated from `EventMultiplexer::Open`. + */ + mygram::utils::Expected Start(); + + /** + * @brief Stop the event-loop thread, close the multiplexer, and drop all + * registered connections. Idempotent. + * + * Drain tasks in flight keep their own shared_ptr copies, so the actual + * socket close happens when the last shared_ptr drops (typically after + * the drain task finishes writing its final response). + */ + void Stop(); + + /** + * @brief Register a freshly accepted connection with the reactor. + * + * On success the reactor inserts the shared_ptr into its map, sets the fd + * non-blocking, and arms `kReadable` on the multiplexer. On failure the + * caller retains the shared_ptr and is responsible for closing it. + * + * Failure modes: + * - `kNetworkServerNotStarted` if `Start()` has not been called. + * - `kInternalError` if the fd is already registered. + * - `kNetworkSocketCreationFailed` if fcntl(O_NONBLOCK) fails. + * - `kNetworkReactorRegisterFailed` propagated from `Add`. + */ + mygram::utils::Expected Register(std::shared_ptr conn); + + /** + * @brief Remove a connection from the reactor and the multiplexer. + * + * Safe to call from any thread. Idempotent: unknown fd is a silent no-op + * because Unregister races with drain-task teardown. + * + * If a close callback is installed via `SetCloseCallback`, it is invoked + * AFTER the connection is removed from the multiplexer and the map but + * BEFORE this function returns. The callback runs with no locks held. + */ + void Unregister(int fd); + + /** + * @brief Install a callback invoked from `Unregister` after a connection + * has been successfully removed. + * + * Used by `ConnectionAcceptor` to decrement its `active_fds_` set when the + * reactor tears down a connection, preserving the `max_connections` gate. + * Called at most once per fd and never while holding internal locks. + * Must be set before `Start()` and not mutated afterwards. + */ + void SetCloseCallback(std::function cb); + + /** + * @brief Factory type for creating an `EventMultiplexer` instance. + * + * Used by `SetMultiplexerFactoryForTest` to override the default + * `reactor::CreateEventMultiplexer()` backend in unit tests. + */ + using MultiplexerFactory = std::function()>; + + /** + * @brief Override the multiplexer factory used by `Start()`. TEST-ONLY. + * + * Must be called before `Start()`. In production code, `Start()` always + * calls `reactor::CreateEventMultiplexer()`. In tests, inject a factory + * that returns a `MockEventMultiplexer` instead. + * + * @warning Do not call this from production code. It exists solely to + * provide a dependency-injection seam for unit tests. + */ + void SetMultiplexerFactoryForTest(MultiplexerFactory f); + + /** + * @brief Arm `kWritable` on an already-registered fd. Phase 3 will use + * this when a drain task can no longer write synchronously. + * + * Phase 2 never calls this from production paths; it exists so the API + * stays stable across phases. + */ + mygram::utils::Expected ArmWrite(int fd); + + /** + * @brief Disarm `kWritable` on an already-registered fd. + */ + mygram::utils::Expected DisarmWrite(int fd); + + /// Number of connections currently registered (for metrics). + [[nodiscard]] size_t ConnectionCount() const; + + /// Whether the event loop is currently running. + [[nodiscard]] bool IsRunning() const { return running_.load(std::memory_order_acquire); } + + /// Backend identifier string (forwarded from `EventMultiplexer::Name`). + /// Returns "unavailable" if the reactor has not been started. + [[nodiscard]] const char* BackendName() const; + + private: + void EventLoop(); + void DispatchEvent(const reactor::ReadyEvent& ev); + + /// Look up a connection under a shared lock and return a shared_ptr copy + /// (or nullptr). The copy is released outside the lock so user code runs + /// without holding the connections_mutex_. + std::shared_ptr Lookup(int fd) const; + + ThreadPool* pool_; // non-owning + RequestDispatcher* dispatcher_; // non-owning + ReactorConfig config_; + + std::unique_ptr mux_; + // shared_mutex around mux_: + // - Event loop holds `shared_lock` across Poll. + // - Register/Unregister/ArmWrite/DisarmWrite hold `shared_lock` while + // calling Add/Modify/Remove. Multiple shared locks coexist, so the + // loop's steady-state polling does NOT block connection registration. + // - Stop holds `unique_lock` to destroy mux_ after the event-loop thread + // has been joined; the exclusive wait is bounded by any in-flight + // Register call, not by the 100ms Poll interval. + // The backends (epoll/kqueue) are kernel-level thread-safe for concurrent + // poll + ctl/kevent from different threads; KqueueMultiplexer uses its own + // internal mutex to protect its interest_ map. + mutable std::shared_mutex mux_lifecycle_; + std::thread event_loop_thread_; + std::atomic running_{false}; + + mutable std::shared_mutex connections_mutex_; + std::unordered_map> connections_; + + // Optional teardown callback (see SetCloseCallback). Set-once before Start. + std::function close_callback_; + + // TEST-ONLY: overrides reactor::CreateEventMultiplexer() when set. + // Null in production; set by SetMultiplexerFactoryForTest() before Start(). + MultiplexerFactory mux_factory_; +}; + +} // namespace mygramdb::server diff --git a/src/server/reactor/epoll_multiplexer.cpp b/src/server/reactor/epoll_multiplexer.cpp new file mode 100644 index 0000000..33a06a9 --- /dev/null +++ b/src/server/reactor/epoll_multiplexer.cpp @@ -0,0 +1,185 @@ +/** + * @file epoll_multiplexer.cpp + * @brief Linux epoll backend implementation. + */ + +#include "server/reactor/epoll_multiplexer.h" + +#if defined(__linux__) + +#include +#include + +#include +#include +#include +#include + +#include "utils/error.h" +#include "utils/expected.h" + +namespace mygramdb::server::reactor { + +namespace { + +using mygram::utils::Error; +using mygram::utils::ErrorCode; +using mygram::utils::Expected; +using mygram::utils::MakeError; +using mygram::utils::MakeUnexpected; + +/// Steady-state batch size for `epoll_wait`. Matches the reactor's expected +/// worst-case concurrency per tick; the buffer only ever grows, never shrinks. +constexpr std::size_t kInitialEventsCapacity = 64; + +/// Build the `errno`-decorated error message suffix used everywhere in this +/// translation unit. Captures `errno` by value to avoid TOCTOU between the +/// failing syscall and the `strerror` call. +std::string FormatErrno(const char* syscall_label, int captured_errno) { + std::string msg = syscall_label; + msg += " failed: "; + msg += std::strerror(captured_errno); + msg += " (errno="; + msg += std::to_string(captured_errno); + msg += ")"; + return msg; +} + +/// Translate the reactor-level interest bitmask to an `epoll_event.events` +/// mask. `EPOLLRDHUP | EPOLLERR | EPOLLHUP` are always armed so the reactor +/// can observe peer-initiated shutdowns even when neither read nor write +/// interest is set (e.g. a fully idle connection that the peer closes). +/// Explicitly level-triggered — no `EPOLLET`. +uint32_t InterestToEpollEvents(uint8_t interest) { + uint32_t events = EPOLLRDHUP | EPOLLERR | EPOLLHUP; + if ((interest & event::kReadable) != 0U) { + events |= EPOLLIN; + } + if ((interest & event::kWritable) != 0U) { + events |= EPOLLOUT; + } + return events; +} + +/// Translate an `epoll_event.events` mask back to the reactor's bitmask. +uint8_t EpollEventsToReady(uint32_t events) { + uint8_t ready = event::kNone; + if ((events & EPOLLIN) != 0U) { + ready |= event::kReadable; + } + if ((events & EPOLLOUT) != 0U) { + ready |= event::kWritable; + } + if ((events & EPOLLERR) != 0U) { + ready |= event::kError; + } + if ((events & (EPOLLHUP | EPOLLRDHUP)) != 0U) { + ready |= event::kHangup; + } + return ready; +} + +} // namespace + +EpollMultiplexer::EpollMultiplexer() { + // Reserve once up front so the Poll() hot path does not allocate. We size + // the buffer via resize() (not reserve()) because epoll_wait() writes into + // [data(), data() + size()); the actual returned count is what we iterate. + events_.resize(kInitialEventsCapacity); +} + +EpollMultiplexer::~EpollMultiplexer() { + if (epoll_fd_ >= 0) { + // Best-effort close; we are in a destructor and must not throw. + ::close(epoll_fd_); + epoll_fd_ = -1; + } +} + +Expected EpollMultiplexer::Open() { + if (epoll_fd_ >= 0) { + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorAlreadyOpen, + "EpollMultiplexer::Open called on already-open multiplexer")); + } + + const int fd = ::epoll_create1(EPOLL_CLOEXEC); + if (fd < 0) { + const int en = errno; + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorInitFailed, FormatErrno("epoll_create1", en))); + } + epoll_fd_ = fd; + return {}; +} + +Expected EpollMultiplexer::Add(int fd, uint8_t interest) { + struct epoll_event ev {}; + ev.events = InterestToEpollEvents(interest); + ev.data.fd = fd; + + if (::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &ev) != 0) { + const int en = errno; + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorRegisterFailed, FormatErrno("epoll_ctl(ADD)", en))); + } + return {}; +} + +Expected EpollMultiplexer::Modify(int fd, uint8_t interest) { + struct epoll_event ev {}; + ev.events = InterestToEpollEvents(interest); + ev.data.fd = fd; + + if (::epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &ev) != 0) { + const int en = errno; + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorModifyFailed, FormatErrno("epoll_ctl(MOD)", en))); + } + return {}; +} + +Expected EpollMultiplexer::Remove(int fd) { + if (::epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, nullptr) != 0) { + const int en = errno; + // Idempotent teardown race: the fd may have been closed (EBADF) or never + // actually registered (ENOENT) by the time IoReactor::Stop() reaches us. + // Swallow those two cases; everything else is a real failure. + if (en == ENOENT || en == EBADF) { + return {}; + } + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorRemoveFailed, FormatErrno("epoll_ctl(DEL)", en))); + } + return {}; +} + +Expected EpollMultiplexer::Poll(int timeout_ms, std::vector& out) { + out.clear(); + + const int n = + ::epoll_wait(epoll_fd_, events_.data(), static_cast(events_.size()), timeout_ms); + if (n < 0) { + const int en = errno; + // EINTR is not an error condition: a signal interrupted the wait and the + // reactor loop will simply call us again. Report success with empty `out`. + if (en == EINTR) { + return {}; + } + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorPollFailed, FormatErrno("epoll_wait", en))); + } + + out.reserve(static_cast(n)); + for (int i = 0; i < n; ++i) { + const auto& ev = events_[static_cast(i)]; + out.push_back(ReadyEvent{ev.data.fd, EpollEventsToReady(ev.events)}); + } + return {}; +} + +const char* EpollMultiplexer::Name() const { return "epoll"; } + +} // namespace mygramdb::server::reactor + +#endif // defined(__linux__) diff --git a/src/server/reactor/epoll_multiplexer.h b/src/server/reactor/epoll_multiplexer.h new file mode 100644 index 0000000..5df319c --- /dev/null +++ b/src/server/reactor/epoll_multiplexer.h @@ -0,0 +1,62 @@ +/** + * @file epoll_multiplexer.h + * @brief Linux epoll backend for the reactor I/O event multiplexer. + * + * This backend is compiled in only on Linux builds. On all other platforms + * the entire translation unit collapses to nothing, and the factory in + * `event_multiplexer.cpp` selects a different backend (kqueue on BSD/macOS) + * or returns nullptr. + * + * The epoll backend is deliberately level-triggered (no `EPOLLET`): workers + * drain socket buffers on their own schedule, and the event loop re-reports + * readiness on each `Poll()` until the interest bit is cleared. This matches + * the contract documented in `event_multiplexer.h`. + */ + +#pragma once + +#if defined(__linux__) + +#include + +#include + +#include "server/reactor/event_multiplexer.h" + +namespace mygramdb::server::reactor { + +/** + * @brief `EventMultiplexer` implementation backed by Linux `epoll(7)`. + * + * Not thread-safe: the reactor's event-loop thread is the sole owner. + */ +class EpollMultiplexer : public EventMultiplexer { + public: + EpollMultiplexer(); + ~EpollMultiplexer() override; + + EpollMultiplexer(const EpollMultiplexer&) = delete; + EpollMultiplexer& operator=(const EpollMultiplexer&) = delete; + EpollMultiplexer(EpollMultiplexer&&) = delete; + EpollMultiplexer& operator=(EpollMultiplexer&&) = delete; + + mygram::utils::Expected Open() override; + mygram::utils::Expected Add(int fd, uint8_t interest) override; + mygram::utils::Expected Modify(int fd, uint8_t interest) override; + mygram::utils::Expected Remove(int fd) override; + mygram::utils::Expected Poll(int timeout_ms, std::vector& out) override; + const char* Name() const override; + + private: + /// File descriptor returned by `epoll_create1`. -1 until `Open()` succeeds. + int epoll_fd_{-1}; + + /// Reusable scratch buffer for `epoll_wait`. Sized once in the constructor + /// so the hot path never allocates. Grows only if callers supply a bigger + /// output vector (currently they do not). + std::vector events_; +}; + +} // namespace mygramdb::server::reactor + +#endif // defined(__linux__) diff --git a/src/server/reactor/event_multiplexer.cpp b/src/server/reactor/event_multiplexer.cpp new file mode 100644 index 0000000..24a055e --- /dev/null +++ b/src/server/reactor/event_multiplexer.cpp @@ -0,0 +1,31 @@ +/** + * @file event_multiplexer.cpp + * @brief Factory for the platform-appropriate EventMultiplexer backend. + * + * The individual backend implementations live next to this file + * (`epoll_multiplexer.cpp`, `kqueue_multiplexer.cpp`). Each one is compiled + * only on its target platform; this factory picks the right one at + * compile time. + */ + +#include "server/reactor/event_multiplexer.h" + +#if defined(__linux__) +#include "server/reactor/epoll_multiplexer.h" +#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) +#include "server/reactor/kqueue_multiplexer.h" +#endif + +namespace mygramdb::server::reactor { + +std::unique_ptr CreateEventMultiplexer() { +#if defined(__linux__) + return std::make_unique(); +#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) + return std::make_unique(); +#else + return nullptr; +#endif +} + +} // namespace mygramdb::server::reactor diff --git a/src/server/reactor/event_multiplexer.h b/src/server/reactor/event_multiplexer.h new file mode 100644 index 0000000..97fa04d --- /dev/null +++ b/src/server/reactor/event_multiplexer.h @@ -0,0 +1,158 @@ +/** + * @file event_multiplexer.h + * @brief Platform-agnostic level-triggered event multiplexer. + * + * Inspired by Redis's `ae.c`, this module provides a minimal abstraction over + * platform-specific polling primitives (epoll on Linux, kqueue on BSD/macOS, + * and a deterministic mock for tests). `IoReactor` is written against this + * interface so that the event loop itself is portable and the same test suite + * can exercise every backend in parity. + * + * Design contracts: + * + * - **Level-triggered semantics.** If a registered fd is still readable or + * writable and the interest bit is armed, the next `Poll()` must re-report + * the event. The reactor and `ReactorConnection` rely on this to decouple + * event notification from consumption (a worker thread may drain the fd on + * its own schedule without starving the event loop). + * + * - **`Expected` for all mutating operations.** Syscalls map to + * `ErrorCode::kNetworkReactor*`. The `errno` captured at failure time is + * copied into the error message. + * + * - **Caller-owned output buffer.** `Poll()` takes a reusable + * `std::vector&` so the event-loop hot path allocates nothing + * steady-state. + * + * - **Fd ownership.** The multiplexer never closes fds it is given; that + * remains `IoReactor`'s job. `Remove()` only unregisters. + */ + +#pragma once + +#include +#include +#include +#include + +#include "utils/error.h" +#include "utils/expected.h" + +namespace mygramdb::server::reactor { + +/** + * @brief Interest / ready-event bitmask values. + * + * Stored as a plain `uint8_t` so callers can `|` them together without + * enum-class ceremony. The set is intentionally tiny; sharding or edge- + * triggered modes are deliberately out of scope and would be a separate + * abstraction if ever needed. + */ +namespace event { +constexpr uint8_t kNone = 0; +constexpr uint8_t kReadable = 1U << 0; ///< EPOLLIN / EVFILT_READ +constexpr uint8_t kWritable = 1U << 1; ///< EPOLLOUT / EVFILT_WRITE +constexpr uint8_t kError = 1U << 2; ///< EPOLLERR / EV_ERROR +constexpr uint8_t kHangup = 1U << 3; ///< EPOLLHUP|EPOLLRDHUP / EV_EOF +} // namespace event + +/** + * @brief One fd's ready events as produced by `Poll`. + * + * `events` is a bit-OR of `event::k*` values. `kReadable`/`kWritable` only + * appear if the corresponding interest bit was armed. + */ +struct ReadyEvent { + int fd; + uint8_t events; +}; + +/** + * @brief Abstract interface for backend-specific polling primitives. + * + * Thread-safety: instances are NOT thread-safe on their own. `IoReactor` owns + * the multiplexer from a single event-loop thread and serializes any + * cross-thread invocations (e.g. `ArmWrite` from a worker) via its own + * synchronisation before calling into the multiplexer. + */ +class EventMultiplexer { + public: + virtual ~EventMultiplexer() = default; + + EventMultiplexer(const EventMultiplexer&) = delete; + EventMultiplexer& operator=(const EventMultiplexer&) = delete; + EventMultiplexer(EventMultiplexer&&) = delete; + EventMultiplexer& operator=(EventMultiplexer&&) = delete; + + /** + * @brief Create the underlying poller fd (`epoll_create1`, `kqueue`, ...). + * + * Must be called exactly once before `Add`/`Poll`. Returns + * `kNetworkReactorInitFailed` on syscall failure, or + * `kNetworkReactorAlreadyOpen` if called twice. + */ + virtual mygram::utils::Expected Open() = 0; + + /** + * @brief Register a new fd with the given interest set. + * + * The multiplexer does NOT take ownership of the fd. `interest` is a bit-OR + * of `event::kReadable` and `event::kWritable`; `kError` and `kHangup` are + * always reported and cannot be masked. Returns + * `kNetworkReactorRegisterFailed` on syscall failure. + */ + virtual mygram::utils::Expected Add(int fd, uint8_t interest) = 0; + + /** + * @brief Update the interest set for an already-registered fd. + * + * This is the hot-path primitive for `ArmWrite`/`DisarmWrite`: flipping + * `kWritable` on or off without recreating registration state. + */ + virtual mygram::utils::Expected Modify(int fd, uint8_t interest) = 0; + + /** + * @brief Remove a previously-registered fd. + * + * Idempotent from the caller's perspective: removing an unknown fd returns + * success because `IoReactor::Stop()` may race with connection teardown. + */ + virtual mygram::utils::Expected Remove(int fd) = 0; + + /** + * @brief Block until at least one event is ready, or `timeout_ms` elapses. + * + * @param timeout_ms -1 for infinite wait, 0 for non-blocking probe, >0 for + * relative milliseconds. + * @param out Output buffer. Cleared and appended to; capacity is + * preserved so the hot path does not allocate steady-state. + * On error, `out` is left empty. + */ + virtual mygram::utils::Expected Poll(int timeout_ms, + std::vector& out) = 0; + + /** + * @brief Backend identifier for metrics and log fields. + * + * Must return a stable string literal: "epoll", "kqueue", "mock". + */ + virtual const char* Name() const = 0; + + protected: + EventMultiplexer() = default; +}; + +/** + * @brief Factory: return the best multiplexer available on this build. + * + * Selection order (compile-time): + * 1. Linux -> `EpollMultiplexer` + * 2. Apple / {Free,Net,Open}BSD -> `KqueueMultiplexer` + * 3. Otherwise -> `nullptr` + * + * A nullptr return is how `TcpServer` decides to emit the "reactor mode not + * supported on this platform, falling back to blocking" warning at startup. + */ +std::unique_ptr CreateEventMultiplexer(); + +} // namespace mygramdb::server::reactor diff --git a/src/server/reactor/kqueue_multiplexer.cpp b/src/server/reactor/kqueue_multiplexer.cpp new file mode 100644 index 0000000..9b4c0d5 --- /dev/null +++ b/src/server/reactor/kqueue_multiplexer.cpp @@ -0,0 +1,315 @@ +/** + * @file kqueue_multiplexer.cpp + * @brief kqueue implementation of `EventMultiplexer` for BSD/macOS. + */ + +#include "server/reactor/kqueue_multiplexer.h" + +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "utils/error.h" +#include "utils/expected.h" + +namespace mygramdb::server::reactor { + +namespace { + +using mygram::utils::Error; +using mygram::utils::ErrorCode; +using mygram::utils::Expected; +using mygram::utils::MakeError; +using mygram::utils::MakeUnexpected; + +/// Default size of the `kevent()` output buffer. Sized to match the reactor's +/// expected worst-case concurrency per tick; anything beyond this cap simply +/// rolls over to the next `Poll()` call because kqueue is level-triggered. +constexpr std::size_t kDefaultEventBufferSize = 64; + +/// Number of milliseconds in a second (kept as a named constant to keep the +/// timespec conversion below readable under clang-tidy's magic-number rule). +constexpr long kNanosPerMilli = 1'000'000L; +constexpr int kMillisPerSecond = 1000; + +/// Build an errno-decorated error message suffix. Captures `captured_errno` by +/// value to avoid TOCTOU between the failing syscall and the `strerror` call. +std::string FormatErrno(const char* syscall_label, int captured_errno) { + std::string msg = syscall_label; + msg += " failed: "; + msg += std::strerror(captured_errno); + msg += " (errno="; + msg += std::to_string(captured_errno); + msg += ")"; + return msg; +} + +} // namespace + +KqueueMultiplexer::KqueueMultiplexer() { + // Size the output buffer once up front so the steady-state Poll() path does + // not allocate. We use resize() (not reserve()) because kevent() writes into + // [data(), data() + size()); the actual returned count is what we iterate. + events_.resize(kDefaultEventBufferSize); +} + +KqueueMultiplexer::~KqueueMultiplexer() { + if (kqueue_fd_ >= 0) { + // Best-effort close; we are in a destructor and must not throw. + ::close(kqueue_fd_); + kqueue_fd_ = -1; + } +} + +Expected KqueueMultiplexer::Open() { + if (kqueue_fd_ >= 0) { + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorAlreadyOpen, "KqueueMultiplexer::Open called on already-open multiplexer")); + } + + const int kq = ::kqueue(); + if (kq < 0) { + const int en = errno; + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorInitFailed, FormatErrno("kqueue", en))); + } + + // Darwin / BSD `kqueue()` does not atomically set FD_CLOEXEC the way Linux's + // `epoll_create1(EPOLL_CLOEXEC)` does. Apply it now so that any fork/exec + // performed by the host process does not leak the poller fd to children. + if (::fcntl(kq, F_SETFD, FD_CLOEXEC) < 0) { + const int en = errno; + ::close(kq); + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorInitFailed, FormatErrno("fcntl(F_SETFD, FD_CLOEXEC)", en))); + } + + kqueue_fd_ = kq; + return {}; +} + +Expected KqueueMultiplexer::ApplyInterest(int fd, uint8_t new_interest, uint8_t old_interest, + bool is_add) { + // kqueue has no single-call "set the interest set of this fd to X" primitive + // the way `epoll_ctl(MOD)` does, so we diff the new interest against the + // previously-armed interest and emit at most two change records: one per + // filter (EVFILT_READ, EVFILT_WRITE). + std::array changes{}; + int nchanges = 0; + + // --- EVFILT_READ --- + const bool want_read = (new_interest & event::kReadable) != 0U; + const bool had_read = (old_interest & event::kReadable) != 0U; + if (want_read && (is_add || !had_read)) { + EV_SET(&changes[nchanges], static_cast(fd), EVFILT_READ, EV_ADD, 0, 0, nullptr); + ++nchanges; + } else if (!want_read && !is_add && had_read) { + EV_SET(&changes[nchanges], static_cast(fd), EVFILT_READ, EV_DELETE, 0, 0, nullptr); + ++nchanges; + } + + // --- EVFILT_WRITE --- + const bool want_write = (new_interest & event::kWritable) != 0U; + const bool had_write = (old_interest & event::kWritable) != 0U; + if (want_write && (is_add || !had_write)) { + EV_SET(&changes[nchanges], static_cast(fd), EVFILT_WRITE, EV_ADD, 0, 0, nullptr); + ++nchanges; + } else if (!want_write && !is_add && had_write) { + EV_SET(&changes[nchanges], static_cast(fd), EVFILT_WRITE, EV_DELETE, 0, 0, nullptr); + ++nchanges; + } + + // Nothing to flush is not an error: e.g. Modify() with the same interest + // set, or Add() with `kNone`. Note the deliberate absence of `EV_CLEAR` on + // every EV_SET above: kqueue defaults to level-triggered, which matches the + // EventMultiplexer contract and the reactor's expectations. + if (nchanges == 0) { + return {}; + } + + if (::kevent(kqueue_fd_, changes.data(), nchanges, nullptr, 0, nullptr) < 0) { + const int en = errno; + const ErrorCode code = + is_add ? ErrorCode::kNetworkReactorRegisterFailed : ErrorCode::kNetworkReactorModifyFailed; + return MakeUnexpected( + MakeError(code, FormatErrno(is_add ? "kevent(EV_ADD)" : "kevent(modify)", en), "fd=" + std::to_string(fd))); + } + + return {}; +} + +Expected KqueueMultiplexer::Add(int fd, uint8_t interest) { + if (kqueue_fd_ < 0) { + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorRegisterFailed, + "KqueueMultiplexer::Add called before Open", "fd=" + std::to_string(fd))); + } + + auto result = ApplyInterest(fd, interest, /*old_interest=*/0U, /*is_add=*/true); + if (!result.has_value()) { + return result; + } + { + std::lock_guard lock(interest_mutex_); + interest_[fd] = interest; + } + return {}; +} + +Expected KqueueMultiplexer::Modify(int fd, uint8_t interest) { + if (kqueue_fd_ < 0) { + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorModifyFailed, + "KqueueMultiplexer::Modify called before Open", "fd=" + std::to_string(fd))); + } + + uint8_t old_interest = 0; + { + std::lock_guard lock(interest_mutex_); + const auto it = interest_.find(fd); + if (it == interest_.end()) { + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorModifyFailed, + "KqueueMultiplexer::Modify called with unknown fd", "fd=" + std::to_string(fd))); + } + old_interest = it->second; + } + + auto result = ApplyInterest(fd, interest, old_interest, /*is_add=*/false); + if (!result.has_value()) { + return result; + } + { + std::lock_guard lock(interest_mutex_); + interest_[fd] = interest; + } + return {}; +} + +Expected KqueueMultiplexer::Remove(int fd) { + // Drop our interest-tracking entry before touching the kernel state, so + // that even if the kevent teardown syscall below races with connection + // close we leave the map consistent. + uint8_t old_interest = 0; + { + std::lock_guard lock(interest_mutex_); + const auto it = interest_.find(fd); + if (it == interest_.end()) { + // Idempotent: never-added or already-removed fds are a no-op success. + return {}; + } + old_interest = it->second; + interest_.erase(it); + } + + if (kqueue_fd_ < 0) { + // Multiplexer already torn down; nothing to unregister. + return {}; + } + + std::array changes{}; + int nchanges = 0; + if ((old_interest & event::kReadable) != 0U) { + EV_SET(&changes[nchanges], static_cast(fd), EVFILT_READ, EV_DELETE, 0, 0, nullptr); + ++nchanges; + } + if ((old_interest & event::kWritable) != 0U) { + EV_SET(&changes[nchanges], static_cast(fd), EVFILT_WRITE, EV_DELETE, 0, 0, nullptr); + ++nchanges; + } + + if (nchanges == 0) { + return {}; + } + + if (::kevent(kqueue_fd_, changes.data(), nchanges, nullptr, 0, nullptr) < 0) { + const int en = errno; + // Idempotent teardown race: kqueue auto-removes filters on close (EBADF), + // and the filter may already be gone from an earlier path (ENOENT). + // Everything else is a real failure. + if (en == ENOENT || en == EBADF) { + return {}; + } + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorRemoveFailed, FormatErrno("kevent(EV_DELETE)", en), "fd=" + std::to_string(fd))); + } + + return {}; +} + +Expected KqueueMultiplexer::Poll(int timeout_ms, std::vector& out) { + out.clear(); + + if (kqueue_fd_ < 0) { + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorPollFailed, "KqueueMultiplexer::Poll called before Open")); + } + + // Translate the reactor's integer timeout convention to the pointer-or-null + // form that `kevent` expects: + // timeout_ms < 0 => tsp == nullptr => block indefinitely + // timeout_ms == 0 => zeroed timespec => non-blocking probe + // timeout_ms > 0 => populated timespec => relative wait + struct timespec ts {}; + struct timespec* tsp = nullptr; + if (timeout_ms == 0) { + tsp = &ts; // ts is already zero-initialised. + } else if (timeout_ms > 0) { + ts.tv_sec = timeout_ms / kMillisPerSecond; + ts.tv_nsec = static_cast(timeout_ms % kMillisPerSecond) * kNanosPerMilli; + tsp = &ts; + } + + const int n = ::kevent(kqueue_fd_, nullptr, 0, events_.data(), static_cast(events_.size()), tsp); + if (n < 0) { + const int en = errno; + // EINTR is not an error condition: a signal interrupted the wait and the + // reactor loop will simply call us again. Report success with empty out. + if (en == EINTR) { + return {}; + } + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorPollFailed, FormatErrno("kevent", en))); + } + + out.reserve(static_cast(n)); + for (int i = 0; i < n; ++i) { + const struct kevent& kev = events_[static_cast(i)]; + ReadyEvent ready{}; + ready.fd = static_cast(kev.ident); + ready.events = event::kNone; + + // Per kevent(2): `EV_ERROR` signals a per-change failure and `kev.data` + // carries the errno. A zero `kev.data` with `EV_ERROR` set is used by + // some BSDs as a benign ack of a change-list entry, which we ignore. + if ((kev.flags & EV_ERROR) != 0 && kev.data != 0) { + ready.events |= event::kError; + } else if (kev.filter == EVFILT_READ) { + ready.events |= event::kReadable; + } else if (kev.filter == EVFILT_WRITE) { + ready.events |= event::kWritable; + } + + // `EV_EOF` means the peer has half-closed (or fully closed) the + // connection. Mirror the epoll backend's EPOLLHUP/EPOLLRDHUP semantics so + // the reactor can drain the read side before releasing the connection. + if ((kev.flags & EV_EOF) != 0) { + ready.events |= event::kHangup; + } + + // Multiple kevents for the same fd (e.g. readable and writable delivered + // in the same Poll) are intentionally emitted as separate ReadyEvent + // entries. IoReactor ORs them together at dispatch time. Coalescing here + // would add per-poll bookkeeping for no correctness gain. + out.push_back(ready); + } + + return {}; +} + +} // namespace mygramdb::server::reactor + +#endif // defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) diff --git a/src/server/reactor/kqueue_multiplexer.h b/src/server/reactor/kqueue_multiplexer.h new file mode 100644 index 0000000..560b2d3 --- /dev/null +++ b/src/server/reactor/kqueue_multiplexer.h @@ -0,0 +1,127 @@ +/** + * @file kqueue_multiplexer.h + * @brief kqueue-based EventMultiplexer backend for BSD and macOS. + * + * Implements the level-triggered `EventMultiplexer` abstraction on top of + * FreeBSD/macOS `kqueue(2)`. Compiled only on BSD-family platforms (including + * Darwin); on other platforms this header compiles away to nothing so that + * `event_multiplexer.cpp` can `#include` it unconditionally inside the + * factory's platform guard. + * + * Semantics: + * + * - **Level-triggered.** `EV_CLEAR` is deliberately NOT set. kqueue's default + * delivery mode matches epoll's level-triggered contract: while the fd is + * still readable/writable and the corresponding filter is armed, every + * `Poll()` re-reports the event. This preserves the decoupling between + * event notification and consumption that `ReactorConnection` depends on. + * + * - **Per-fd interest tracking.** kqueue has no single-call "set the current + * interest set of this fd to X" primitive the way `epoll_ctl(MOD)` does. + * Instead, we must diff the new interest against the previously-armed + * interest and emit `EV_ADD` for newly-armed filters and `EV_DELETE` for + * newly-disarmed ones. The mapping from fd to last-known interest lives + * in `interest_`. + * + * - **Idempotent teardown.** `Remove()` tolerates `ENOENT`/`EBADF` from + * `kevent()` because `IoReactor::Stop()` may race with connection teardown + * that already closed the fd (kqueue automatically drops filters on + * close). + */ + +#pragma once + +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) + +#include + +#include +#include +#include +#include + +#include "server/reactor/event_multiplexer.h" +#include "utils/error.h" +#include "utils/expected.h" + +namespace mygramdb::server::reactor { + +/** + * @brief kqueue-backed `EventMultiplexer` implementation. + * + * Not thread-safe. `IoReactor` owns the instance from a single event-loop + * thread and serialises any cross-thread arm/disarm requests before calling + * into this class. + */ +class KqueueMultiplexer final : public EventMultiplexer { + public: + KqueueMultiplexer(); + ~KqueueMultiplexer() override; + + KqueueMultiplexer(const KqueueMultiplexer&) = delete; + KqueueMultiplexer& operator=(const KqueueMultiplexer&) = delete; + KqueueMultiplexer(KqueueMultiplexer&&) = delete; + KqueueMultiplexer& operator=(KqueueMultiplexer&&) = delete; + + /// @copydoc EventMultiplexer::Open + mygram::utils::Expected Open() override; + + /// @copydoc EventMultiplexer::Add + mygram::utils::Expected Add(int fd, uint8_t interest) override; + + /// @copydoc EventMultiplexer::Modify + mygram::utils::Expected Modify(int fd, uint8_t interest) override; + + /// @copydoc EventMultiplexer::Remove + mygram::utils::Expected Remove(int fd) override; + + /// @copydoc EventMultiplexer::Poll + mygram::utils::Expected Poll(int timeout_ms, + std::vector& out) override; + + /// Backend identifier for metrics and logging. + const char* Name() const override { return "kqueue"; } + + private: + /** + * @brief Diff `old_interest` against `new_interest` and apply the delta. + * + * @param fd Target file descriptor. + * @param new_interest Desired interest bitmask (`event::kReadable` | + * `event::kWritable`). + * @param old_interest Previously-armed interest bitmask. Ignored when + * `is_add` is true. + * @param is_add If true, this is a fresh `Add()` and we unconditionally + * emit `EV_ADD` for every bit set in `new_interest`. + * If false, only the bits that changed are touched. + * + * Emits up to two `struct kevent` change records and flushes them in a + * single `kevent()` call. Returns `kNetworkReactorRegisterFailed` (on add) + * or `kNetworkReactorModifyFailed` (on modify) if the syscall fails. + */ + mygram::utils::Expected ApplyInterest(int fd, uint8_t new_interest, + uint8_t old_interest, bool is_add); + + int kqueue_fd_ = -1; + + /// Reusable output buffer for `kevent()`. Sized at construction so the + /// steady-state event loop never allocates. Touched only by the event-loop + /// thread via `Poll()`; no locking. + std::vector events_; + + /// Mutex protecting `interest_`. IoReactor now allows concurrent Poll (on + /// the event-loop thread) and Add/Modify/Remove (from accept / worker + /// threads) because the kqueue kernel object is thread-safe for that + /// pattern. The `interest_` map, however, is process-level state we keep + /// ourselves and therefore needs its own synchronisation. + mutable std::mutex interest_mutex_; + + /// Last-known interest mask per registered fd. Populated by `Add()`, + /// updated by `Modify()`, erased by `Remove()`. Required because kqueue + /// does not let us read back the currently-armed filter set. + std::unordered_map interest_; +}; + +} // namespace mygramdb::server::reactor + +#endif // __APPLE__ || BSD family diff --git a/src/server/reactor_connection.cpp b/src/server/reactor_connection.cpp new file mode 100644 index 0000000..5f9ee39 --- /dev/null +++ b/src/server/reactor_connection.cpp @@ -0,0 +1,400 @@ +/** + * @file reactor_connection.cpp + * @brief Per-connection state + drain-task-per-connection pattern. + * + * Implements the Phase 2 read side + Phase 3 non-blocking write queue of + * the reactor refactor described in docs/ja/design/reactor-io-refactor.md + * §4.3/§7 R3. + */ + +#include "server/reactor_connection.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "server/io_reactor.h" +#include "server/request_dispatcher.h" +#include "server/server_stats.h" +#include "server/thread_pool.h" +#include "utils/structured_log.h" + +namespace mygramdb::server { + +namespace { +constexpr size_t kRecvChunkBytes = 4096; +constexpr const char kFrameDelimiter[] = "\r\n"; +constexpr size_t kFrameDelimiterLen = 2; +constexpr const char kResponseTerminator[] = "\r\n"; +constexpr size_t kResponseTerminatorLen = 2; +} // namespace + +std::shared_ptr ReactorConnection::Create(int fd, IoReactor* reactor, RequestDispatcher* dispatcher, + ThreadPool* thread_pool, ServerStats* stats, + size_t max_write_queue_bytes) { + return std::make_shared(fd, reactor, dispatcher, thread_pool, stats, max_write_queue_bytes); +} + +ReactorConnection::ReactorConnection(int fd, IoReactor* reactor, RequestDispatcher* dispatcher, + ThreadPool* thread_pool, ServerStats* stats, size_t max_write_queue_bytes) + : fd_(fd), + max_write_queue_bytes_(max_write_queue_bytes), + reactor_(reactor), + dispatcher_(dispatcher), + thread_pool_(thread_pool), + stats_(stats) { + conn_ctx_.client_fd = fd_; + read_buf_.reserve(kDefaultReadBufferBytes); +} + +ReactorConnection::~ReactorConnection() { + if (!closed_ && fd_ >= 0) { + ::close(fd_); + closed_ = true; + } +} + +bool ReactorConnection::OnReadable() { + if (closing_.load(std::memory_order_acquire)) { + return false; + } + + // 1. Drain the socket until EAGAIN / EWOULDBLOCK. + std::array chunk{}; + while (true) { + ssize_t n = ::recv(fd_, chunk.data(), chunk.size(), 0); + if (n > 0) { + // Hard cap on the accumulation buffer — slow-reader / malformed frame + // protection. + if (read_buf_.size() + static_cast(n) > kMaxReadBufferBytes) { + mygram::utils::StructuredLog() + .Event("reactor_read_buf_overflow") + .Field("fd", static_cast(fd_)) + .Field("buf_bytes", static_cast(read_buf_.size() + static_cast(n))) + .Field("cap_bytes", static_cast(kMaxReadBufferBytes)) + .Warn(); + closing_.store(true, std::memory_order_release); + return false; + } + read_buf_.insert(read_buf_.end(), chunk.data(), chunk.data() + n); + continue; + } + if (n == 0) { + // Peer performed orderly close. + closing_.store(true, std::memory_order_release); + // Process any already-buffered frames before tearing down. + break; + } + // n < 0 + if (errno == EINTR) { + continue; + } + if (errno == EAGAIN || errno == EWOULDBLOCK) { + break; + } + mygram::utils::StructuredLog() + .Event("reactor_recv_failed") + .Field("fd", static_cast(fd_)) + .Field("errno", static_cast(errno)) + .Field("error", std::strerror(errno)) + .Warn(); + closing_.store(true, std::memory_order_release); + return false; + } + + // 2. Extract complete frames and push onto the drain queue. + size_t enqueued = 0; + { + std::lock_guard lock(frame_mutex_); + enqueued = ExtractFramesLocked(); + } + + // 3. If we parsed at least one frame, make sure a drain task is running. + // If none were parsed but the peer closed, we still need to tear down. + if (enqueued > 0) { + if (!ScheduleDrainTask()) { + return false; + } + } + + // If the peer closed and there are no frames in flight, report close to + // the reactor. (If frames are still pending, the drain task will call + // Unregister after draining.) + if (closing_.load(std::memory_order_acquire)) { + std::lock_guard lock(frame_mutex_); + if (pending_frames_.empty() && !drain_scheduled_.load(std::memory_order_acquire)) { + return false; + } + } + + return true; +} + +bool ReactorConnection::OnWritable() { + std::unique_lock lock(write_mutex_); + + if (!DrainWriteQueueLocked()) { + // Fatal send error during drain. + closing_.store(true, std::memory_order_release); + return false; + } + + if (write_queue_.empty()) { + // Fully drained: disarm kWritable so the event loop stops spinning on + // this fd. If we had never actually armed (edge case — OnWritable fired + // spuriously), skip the disarm call. + if (write_armed_ && reactor_ != nullptr) { + (void)reactor_->DisarmWrite(fd_); + write_armed_ = false; + } + if (closing_.load(std::memory_order_acquire)) { + return false; + } + } + // Partial drain: leave the queue armed, fire again on next writable event. + return true; +} + +bool ReactorConnection::OnError() { + closing_.store(true, std::memory_order_release); + return false; +} + +size_t ReactorConnection::ExtractFramesLocked() { + size_t enqueued = 0; + size_t scan_start = 0; + size_t consumed = 0; + while (scan_start + kFrameDelimiterLen <= read_buf_.size()) { + // Search for the next delimiter. + const char* begin = read_buf_.data() + scan_start; + const size_t remaining = read_buf_.size() - scan_start; + const char* found = static_cast(std::memchr(begin, kFrameDelimiter[0], remaining)); + if (found == nullptr) { + break; + } + const size_t found_off = static_cast(found - read_buf_.data()); + if (found_off + kFrameDelimiterLen > read_buf_.size()) { + break; // delimiter straddles the buffer end; wait for more bytes + } + if (read_buf_[found_off + 1] != kFrameDelimiter[1]) { + // Lone CR without LF — skip past the CR and keep scanning. + scan_start = found_off + 1; + continue; + } + // Frame is [consumed, found_off); delimiter is [found_off, found_off+2). + const size_t frame_len = found_off - consumed; + pending_frames_.emplace_back(read_buf_.data() + consumed, frame_len); + ++enqueued; + consumed = found_off + kFrameDelimiterLen; + scan_start = consumed; + } + if (consumed > 0) { + // Single splice at the end to avoid quadratic erase-per-frame cost. + read_buf_.erase(read_buf_.begin(), read_buf_.begin() + static_cast(consumed)); + } + return enqueued; +} + +bool ReactorConnection::ScheduleDrainTask() { + bool expected = false; + if (!drain_scheduled_.compare_exchange_strong(expected, true, std::memory_order_acq_rel, + std::memory_order_acquire)) { + // A drain task is already running or queued; it will pick up the new + // frames when it next checks `pending_frames_`. + return true; + } + + if (thread_pool_ == nullptr || dispatcher_ == nullptr) { + // Misconfiguration — no way to process the frames. + drain_scheduled_.store(false, std::memory_order_release); + return false; + } + + auto self = shared_from_this(); + const bool submitted = thread_pool_->Submit([self]() { self->DrainTask(); }); + if (!submitted) { + drain_scheduled_.store(false, std::memory_order_release); + mygram::utils::StructuredLog() + .Event("reactor_drain_submit_failed") + .Field("fd", static_cast(fd_)) + .Warn(); + closing_.store(true, std::memory_order_release); + return false; + } + return true; +} + +void ReactorConnection::DrainTask() { + while (!closing_.load(std::memory_order_acquire)) { + std::string frame; + { + std::lock_guard lock(frame_mutex_); + if (pending_frames_.empty()) { + break; + } + frame = std::move(pending_frames_.front()); + pending_frames_.pop_front(); + } + + // Dispatch. `Dispatch` is synchronous and returns the full response. + std::string response = dispatcher_->Dispatch(frame, conn_ctx_); + if (stats_ != nullptr) { + // Mirror the blocking path's per-request counter increment. + stats_->IncrementRequests(); + } + + // Enqueue the response for non-blocking send. The fast path in + // EnqueueResponse attempts an inline drain before returning; only on + // EAGAIN does it hand off to the event loop via ArmWrite. + if (!EnqueueResponse(std::move(response))) { + closing_.store(true, std::memory_order_release); + break; + } + } + + // Netty/Vert.x "clear-then-recheck": before releasing the drain slot, + // confirm that no new frames arrived in the window between the last + // queue-empty check and now. If frames did arrive, reschedule ourselves. + bool reschedule = false; + { + std::lock_guard lock(frame_mutex_); + if (!pending_frames_.empty() && !closing_.load(std::memory_order_acquire)) { + reschedule = true; + } + } + drain_scheduled_.store(false, std::memory_order_release); + if (reschedule) { + (void)ScheduleDrainTask(); + return; + } + + if (closing_.load(std::memory_order_acquire) && reactor_ != nullptr) { + // Ask the reactor to unregister us. This is safe from a worker: the + // IoReactor::Unregister acquires the connections_ write lock, and the + // event loop will observe the erase on its next Poll iteration. The + // shared_ptr held by this lambda capture keeps the object alive until + // DrainTask returns. + reactor_->Unregister(fd_); + } +} + +bool ReactorConnection::EnqueueResponse(std::string response) { + // Payload + CRLF terminator. We hold write_mutex_ across the entire + // enqueue + optional inline drain + optional ArmWrite sequence so that + // the event loop's OnWritable cannot race and pop frames out from under + // us mid-drain, and so OnWritable cannot observe write_armed_ in an + // inconsistent state relative to the multiplexer's interest mask. + // + // Holding `write_mutex_` across `reactor_->ArmWrite` is safe: ArmWrite + // only acquires the reactor's `mux_lifecycle_` (shared). No IoReactor + // method ever takes `write_mutex_`, so there is no reverse lock order. + const size_t payload_bytes = response.size() + kResponseTerminatorLen; + + std::unique_lock lock(write_mutex_); + + if (closing_.load(std::memory_order_acquire)) { + return false; + } + + // Slow-reader backpressure: cap the per-connection unsent byte budget. + // Design doc §7 R3: exceeding the cap means the peer cannot keep up and + // the server forcibly closes the connection to protect its own memory. + if (write_queue_bytes_ + payload_bytes > max_write_queue_bytes_) { + mygram::utils::StructuredLog() + .Event("reactor_write_queue_overflow") + .Field("fd", static_cast(fd_)) + .Field("current_bytes", static_cast(write_queue_bytes_)) + .Field("attempted_bytes", static_cast(payload_bytes)) + .Field("cap_bytes", static_cast(max_write_queue_bytes_)) + .Warn(); + return false; + } + + response.append(kResponseTerminator, kResponseTerminatorLen); + write_queue_.emplace_back(std::move(response)); + write_queue_bytes_ += payload_bytes; + pending_write_bytes_.store(write_queue_bytes_, std::memory_order_relaxed); + + // Fast path: if the queue is not currently armed for EPOLLOUT, the + // event loop is NOT going to drain us. Try an inline non-blocking drain + // right here on the worker thread (design doc §4.2 D6: attempt write + // immediately, register EPOLLOUT on EAGAIN). + if (!write_armed_) { + if (!DrainWriteQueueLocked()) { + return false; // fatal send error + } + if (write_queue_.empty()) { + return true; // fully drained inline — no arming required + } + // Residue remains → ask the reactor to arm kWritable so the event + // loop takes over. + if (reactor_ == nullptr) { + // Unit-test harness with no reactor and residue we cannot arm on. + return false; + } + auto arm_result = reactor_->ArmWrite(fd_); + if (!arm_result) { + mygram::utils::StructuredLog() + .Event("reactor_arm_write_failed") + .Field("fd", static_cast(fd_)) + .Field("error", arm_result.error().to_string()) + .Warn(); + return false; + } + write_armed_ = true; + } + // Queue was already armed — event loop's OnWritable will pick up the + // new entries when it next fires. + return true; +} + +bool ReactorConnection::DrainWriteQueueLocked() { + while (!write_queue_.empty()) { + const std::string& front = write_queue_.front(); + const char* data = front.data() + front_offset_; + const size_t remaining = front.size() - front_offset_; + + ssize_t n = ::send(fd_, data, remaining, MSG_NOSIGNAL); + if (n > 0) { + front_offset_ += static_cast(n); + write_queue_bytes_ -= static_cast(n); + pending_write_bytes_.store(write_queue_bytes_, std::memory_order_relaxed); + if (front_offset_ == front.size()) { + write_queue_.pop_front(); + front_offset_ = 0; + } + continue; + } + if (n == 0) { + // send() returning 0 on a non-zero-length buffer is undefined per POSIX + // but defensively treat as a fatal peer state. + return false; + } + // n < 0 + if (errno == EINTR) { + continue; + } + if (errno == EAGAIN || errno == EWOULDBLOCK) { + return true; // partial — event loop will finish via OnWritable + } + // EPIPE / ECONNRESET / ENOTCONN / etc. + mygram::utils::StructuredLog() + .Event("reactor_send_failed") + .Field("fd", static_cast(fd_)) + .Field("errno", static_cast(errno)) + .Field("error", std::strerror(errno)) + .Debug(); + return false; + } + return true; +} + +} // namespace mygramdb::server diff --git a/src/server/reactor_connection.h b/src/server/reactor_connection.h new file mode 100644 index 0000000..b0dd2fa --- /dev/null +++ b/src/server/reactor_connection.h @@ -0,0 +1,299 @@ +/** + * @file reactor_connection.h + * @brief Heap-allocated per-connection state for the reactor I/O model. + * + * This is the Phase 2/3 implementation of the per-connection state object + * described in docs/ja/design/reactor-io-refactor.md §4.3. An instance is + * created per accepted client socket and lives on the heap as a + * `std::shared_ptr`, jointly owned by: + * - `IoReactor`'s connection map (primary owner), and + * - any in-flight drain task captured by the thread pool. + * + * The shared ownership is deliberate (design doc §7 R5): once a worker has + * started draining a connection's frame queue we must keep the object alive + * until the worker finishes writing, even if the event loop has already + * observed EPOLLHUP and unregistered the fd. + * + * Naming note: the design document calls this class `ConnectionContext`, but + * that name is already used by `mygramdb::server::ConnectionContext` in + * `server_types.h` for the per-request dispatch struct passed to command + * handlers. To avoid a disruptive rename across ~36 files, the reactor + * per-connection state type is introduced here as `ReactorConnection`. + * Semantically it is exactly the type described in §4.3 of the design doc. + * + * ----------------------------------------------------------------------- + * Thread-safety contract + * ----------------------------------------------------------------------- + * - `read_buf_` is touched exclusively by the event-loop thread (via + * `OnReadable`) and requires no locking. + * - `pending_frames_` is shared between the event-loop thread (producer) + * and a worker thread (consumer) and is protected by `frame_mutex_`. + * - `write_queue_`, `write_queue_bytes_`, `front_offset_`, `write_armed_` + * are shared between the worker thread (via `EnqueueResponse` → inline + * drain) and the event-loop thread (via `OnWritable`) and are protected + * by `write_mutex_`. The contract is: holders of `write_mutex_` may + * call `reactor_->ArmWrite/DisarmWrite` while the mutex is held. The + * reverse is never done (no IoReactor method acquires `write_mutex_`). + * - `closing_` and `drain_scheduled_` are atomics. + * - `fd_` is immutable after construction; the destructor closes it + * exactly once via `closed_` guard. + * - `reactor_`, `dispatcher_`, `thread_pool_` are set once at construction + * and read-only thereafter. + */ + +#pragma once + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "server/server_types.h" + +namespace mygramdb::server { + +class IoReactor; +class RequestDispatcher; +class ServerStats; +class ThreadPool; + +/** + * @brief Per-connection state owned jointly by the reactor and drain tasks. + * + * Lifetime: + * 1. `IoReactor::Register` inserts the shared_ptr into its map and arms + * `kReadable` on the multiplexer. + * 2. The event loop calls `OnReadable`/`OnError`. When `OnReadable` parses + * at least one complete frame it schedules a drain task via the + * `ThreadPool`; the task captures a shared_ptr copy. + * 3. If the connection is torn down (peer close, error, write failure), + * either the event loop or the drain task calls + * `IoReactor::Unregister(fd)`, which removes the shared_ptr from the + * map. The object is destroyed when the last shared_ptr (typically the + * drain task's) drops, and the destructor closes `fd_`. + */ +class ReactorConnection : public std::enable_shared_from_this { + public: + /// Default read buffer reservation. Grows on demand up to kMaxReadBufferBytes. + static constexpr size_t kDefaultReadBufferBytes = 4096; + + /// Hard cap on the read accumulation buffer. A single frame larger than + /// this is rejected (peer is either misbehaving or under attack). 1 MiB is + /// comfortably above the configured MygramDB query length limit (~64 KiB) + /// while still providing OOM protection. + static constexpr size_t kMaxReadBufferBytes = 1 * 1024 * 1024; // 1 MiB + + /// Hard upper bound on unsent response bytes; once exceeded the reactor + /// forcibly closes the connection to protect against slow-reader OOM + /// (see design doc §7 R3). Phase 3 enforces this cap in `EnqueueResponse`: + /// a push that would exceed the cap sets `closing_` and causes the drain + /// task to tear down the connection. + static constexpr size_t kDefaultMaxWriteQueueBytes = 16 * 1024 * 1024; // 16 MiB + + /** + * @brief Factory. Must be used instead of a bare constructor because + * `std::enable_shared_from_this` requires the object to live inside + * a `shared_ptr` from the moment it is born. + * + * @param stats Optional non-owning pointer to `ServerStats`. If non-null, + * the drain task calls `stats->IncrementRequests()` after + * each successful Dispatch, matching the blocking path's + * per-request counter. May be null in unit tests. + */ + static std::shared_ptr Create(int fd, IoReactor* reactor, RequestDispatcher* dispatcher, + ThreadPool* thread_pool, ServerStats* stats = nullptr, + size_t max_write_queue_bytes = kDefaultMaxWriteQueueBytes); + + /** + * @brief Public constructor (required by `std::make_shared`). Prefer + * `Create()` at call sites for clarity. + */ + ReactorConnection(int fd, IoReactor* reactor, RequestDispatcher* dispatcher, ThreadPool* thread_pool, + ServerStats* stats, size_t max_write_queue_bytes); + + ~ReactorConnection(); + + ReactorConnection(const ReactorConnection&) = delete; + ReactorConnection& operator=(const ReactorConnection&) = delete; + ReactorConnection(ReactorConnection&&) = delete; + ReactorConnection& operator=(ReactorConnection&&) = delete; + + /// Returns the raw client fd. The reactor still owns close(2). + [[nodiscard]] int Fd() const { return fd_; } + + // ---- Reactor event callbacks (event-loop thread) -------------------- + + /** + * @brief Handle `event::kReadable` for this connection. + * + * Drains the socket via non-blocking recv() into `read_buf_`, scans for + * "\r\n"-delimited frames, enqueues each complete frame onto + * `pending_frames_`, and schedules a single drain task on the thread pool + * if one is not already in flight. + * + * @return false if the reactor should close and unregister this fd. + */ + bool OnReadable(); + + /** + * @brief Handle `event::kWritable` for this connection. + * + * Phase 3: drain `write_queue_` via non-blocking `send()` until EAGAIN + * or empty. On full drain, call `reactor_->DisarmWrite(fd_)` and return + * true (or false if `closing_` was also set, so the reactor tears down + * the fd). On partial drain, leave the queue armed and return true. On + * fatal send error (EPIPE / ECONNRESET / etc.), return false. + */ + bool OnWritable(); + + /** + * @brief Handle `event::kError` / `event::kHangup` for this connection. + * Always returns false so the reactor tears the fd down. + */ + bool OnError(); + + /// Current bytes held in the pending write accounting (for metrics / tests). + [[nodiscard]] size_t PendingWriteBytes() const { + return pending_write_bytes_.load(std::memory_order_relaxed); + } + + /// Whether `closing_` has been set. Exposed for tests. + [[nodiscard]] bool IsClosing() const { return closing_.load(std::memory_order_acquire); } + + /// Returns the number of frames currently in `pending_frames_`. Exposed for tests only. + [[nodiscard]] size_t PendingFrameCountForTest() const { + std::lock_guard lock(frame_mutex_); + return pending_frames_.size(); + } + + /// Current number of entries in the write queue. TEST ONLY. + [[nodiscard]] size_t WriteQueueDepthForTest() const { + std::lock_guard lock(write_mutex_); + return write_queue_.size(); + } + + /// Whether the reactor currently has `kWritable` armed for this fd. + /// TEST ONLY. + [[nodiscard]] bool WriteArmedForTest() const { + std::lock_guard lock(write_mutex_); + return write_armed_; + } + + /** + * @brief Enqueue a response for non-blocking send on this connection. + * + * The CRLF terminator is appended internally; callers should pass just + * the response body. This is the Phase 3 write-path entry point used by + * `DrainTask`. + * + * The worker thread (drain task) owns the fast path: if the queue was + * empty and `kWritable` was not armed, this call attempts an inline + * non-blocking drain before returning. Only on EAGAIN does it ask the + * reactor to arm `kWritable`, at which point the event loop takes over + * and finishes draining via `OnWritable`. + * + * Failure modes (returns false AND sets `closing_`): + * - enqueue would exceed `max_write_queue_bytes_` (slow reader + * backpressure; see design doc §7 R3) + * - fatal send error during the inline drain (EPIPE / ECONNRESET) + * - `ArmWrite` failed (reactor was stopped mid-Enqueue) + * - Called with `reactor_` null AND the inline drain could not fully + * drain the queue (unit-test corner case) + * + * Called exclusively from worker threads; never from the event loop. + */ + bool EnqueueResponse(std::string response); + + private: + /** + * @brief Attempt to submit a drain task to the thread pool. + * + * Uses a compare-exchange on `drain_scheduled_` to ensure at most one + * drain task is in flight per connection at any time. If the slot is + * already claimed (a previous drain task is still running and will pick + * up the newly enqueued frames when it next checks `pending_frames_`), + * this is a no-op. + * + * @return false if submission failed (thread pool queue full). The caller + * should treat this as a fatal condition for the connection. + */ + bool ScheduleDrainTask(); + + /** + * @brief Drain task body: runs in a worker thread. + * + * Pops frames from `pending_frames_`, dispatches each through + * `RequestDispatcher`, and enqueues each response for non-blocking send + * via `EnqueueResponse` (Phase 3 write path). Implements the Netty/Vert.x + * "clear-then-recheck" idiom to guarantee progress when new frames arrive + * during the window between observing an empty queue and clearing + * `drain_scheduled_`. + */ + void DrainTask(); + + /** + * @brief Drain the write queue via non-blocking `send()` until the queue + * is empty or the socket reports EAGAIN. Must be called with + * `write_mutex_` held. + * + * Updates `front_offset_` for partial sends of the head frame. + * + * @return false on fatal send error (EPIPE / ECONNRESET / etc.); + * true on EAGAIN or when the queue was fully drained. + */ + bool DrainWriteQueueLocked(); + + /** + * @brief Scan `read_buf_` for complete "\r\n"-terminated frames, move + * them into `pending_frames_`, and erase the consumed prefix in a + * single splice. + * + * @return number of frames newly enqueued (0 if no complete frame). + */ + size_t ExtractFramesLocked(); + + int fd_; + bool closed_ = false; // destructor close(2) guard + const size_t max_write_queue_bytes_; + + // Non-owning collaborators. Set at construction, read-only afterwards. + IoReactor* reactor_; + RequestDispatcher* dispatcher_; + ThreadPool* thread_pool_; + ServerStats* stats_; ///< Optional; null in unit tests. + + // Per-request context passed to `RequestDispatcher::Dispatch`. Filled in at + // construction with client_fd = fd_. + ConnectionContext conn_ctx_{}; + + // Read-side state — touched only by the event-loop thread. + std::vector read_buf_; + + // Frame queue: event loop produces, drain task consumes. + mutable std::mutex frame_mutex_; + std::deque pending_frames_; + + // Write queue: drain task (worker) produces; either the worker itself + // (inline fast path) or the event-loop thread (OnWritable slow path) + // consumes. Protected by `write_mutex_`. + mutable std::mutex write_mutex_; + std::deque write_queue_; + size_t write_queue_bytes_ = 0; ///< Sum of byte lengths in write_queue_. + size_t front_offset_ = 0; ///< Bytes of write_queue_.front() already sent. + bool write_armed_ = false; ///< Whether reactor_->ArmWrite was called for this fd. + + // Atomic flags. + std::atomic closing_{false}; + std::atomic drain_scheduled_{false}; + + // Mirror of `write_queue_bytes_` for lock-free metric readers. + std::atomic pending_write_bytes_{0}; +}; + +} // namespace mygramdb::server diff --git a/src/server/server_lifecycle_manager.cpp b/src/server/server_lifecycle_manager.cpp index 8a15a6f..744289d 100644 --- a/src/server/server_lifecycle_manager.cpp +++ b/src/server/server_lifecycle_manager.cpp @@ -27,8 +27,11 @@ namespace mygramdb::server { namespace { -// Thread pool queue size for backpressure -constexpr size_t kThreadPoolQueueSize = 1000; +// Historical default for backpressure queue depth. Used when the operator +// leaves `api.tcp.thread_pool_queue_size` at 0 in YAML. This is NOT the same +// semantic as "0 = unbounded" on ThreadPool; we treat 0 as "keep the legacy +// default" so that existing configs and tests continue to work unchanged. +constexpr size_t kDefaultThreadPoolQueueSize = 1000; } // namespace ServerLifecycleManager::ServerLifecycleManager(const ServerConfig& config, @@ -218,8 +221,9 @@ mygram::utils::Expected, mygram::utils::Error> Serve using mygram::utils::MakeUnexpected; try { - auto pool = - std::make_unique(config_.worker_threads > 0 ? config_.worker_threads : 0, kThreadPoolQueueSize); + const size_t queue_size = config_.thread_pool_queue_size > 0 ? static_cast(config_.thread_pool_queue_size) + : kDefaultThreadPoolQueueSize; + auto pool = std::make_unique(config_.worker_threads > 0 ? config_.worker_threads : 0, queue_size); return pool; } catch (const std::exception& e) { auto error = MakeError(ErrorCode::kInternalError, "Failed to create thread pool: " + std::string(e.what())); diff --git a/src/server/server_types.h b/src/server/server_types.h index e89f5fd..839ac9b 100644 --- a/src/server/server_types.h +++ b/src/server/server_types.h @@ -61,6 +61,22 @@ struct ServerConfig { int send_buffer_size = kDefaultSendBufferSize; int default_limit = kDefaultLimit; // Default LIMIT for SEARCH queries (range: 5-1000) int max_query_length = config::defaults::kDefaultQueryLengthLimit; // Max characters for query expressions + + // Connection I/O tunables. + int recv_timeout_sec = 60; ///< SO_RCVTIMEO seconds applied to accepted sockets (0 = disabled) + int thread_pool_queue_size = 1000; ///< ThreadPool task queue bound; 0 = unbounded + std::string io_model = "reactor"; ///< "reactor" (default) or "blocking"; see config.h ApiConfig::tcp::io_model + int64_t max_write_queue_bytes = 16LL * 1024 * 1024; ///< Per-connection slow-reader cap; see config.h + + // TCP keepalive applied per-accepted client socket. See + // config.h ApiConfig::tcp::keepalive for rationale. + struct { + bool enabled = true; + int idle_sec = 60; + int interval_sec = 20; + int probe_count = 3; + } keepalive; + std::vector allow_cidrs; std::vector parsed_allow_cidrs; std::string unix_socket_path; // Empty = TCP mode, non-empty = UDS mode diff --git a/src/server/tcp_server.cpp b/src/server/tcp_server.cpp index b7ee650..fbfe3e3 100644 --- a/src/server/tcp_server.cpp +++ b/src/server/tcp_server.cpp @@ -56,9 +56,6 @@ namespace mygramdb::server { namespace { -// Thread pool queue size for backpressure -constexpr size_t kThreadPoolQueueSize = 1000; - // Buffer size for IP address formatting constexpr size_t kIpAddressBufferSize = 64; @@ -218,8 +215,85 @@ mygram::utils::Expected TcpServer::Start() { acceptor_ = std::move(components.acceptor); scheduler_ = std::move(components.scheduler); - // Set connection handler callback (must be done after acceptor_ is assigned) - acceptor_->SetConnectionHandler([this](int client_fd) { HandleConnection(client_fd); }); + // Reactor I/O model: attempt to create the IoReactor up front. On platforms + // with no supported event multiplexer (neither epoll nor kqueue), log a + // warning and fall back to the blocking model. + const bool reactor_requested = config_.io_model == "reactor"; + bool reactor_active = false; + if (reactor_requested) { + ReactorConfig rcfg; + if (config_.max_write_queue_bytes > 0) { + rcfg.max_write_queue_bytes = static_cast(config_.max_write_queue_bytes); + } + reactor_ = std::make_unique(thread_pool_.get(), dispatcher_.get(), rcfg); + // When the reactor tears down a connection, decrement the acceptor's + // max_connections gate so new accepts can proceed, and the server stats + // so GetConnectionCount() reflects reality in reactor mode. (The blocking + // path calls IncrementConnections/DecrementConnections inside + // HandleConnection; the reactor path has no such entry point, so we + // count at Register / close_callback instead — see the reactor_handler + // lambda below.) + ConnectionAcceptor* accept_ptr = acceptor_.get(); + ServerStats* close_stats_ptr = &stats_; + reactor_->SetCloseCallback([accept_ptr, close_stats_ptr](int fd) { + if (accept_ptr != nullptr) { + accept_ptr->RemoveConnection(fd); + } + if (close_stats_ptr != nullptr) { + close_stats_ptr->DecrementConnections(); + } + }); + auto r = reactor_->Start(); + if (!r) { + if (r.error().code() == mygram::utils::ErrorCode::kNetworkReactorUnsupported) { + mygram::utils::StructuredLog() + .Event("reactor_fallback_to_blocking") + .Field("reason", "no event multiplexer available on this platform") + .Warn(); + reactor_.reset(); + } else { + return MakeUnexpected(r.error()); + } + } else { + reactor_active = true; + mygram::utils::StructuredLog() + .Event("reactor_mode_enabled") + .Field("backend", reactor_->BackendName()) + .Info(); + } + } + + // Install the appropriate acceptor callback: + // - Reactor mode: inline hand-off to IoReactor::Register, no thread pool hop. + // - Blocking mode: submit to thread pool running HandleConnection. + if (reactor_active) { + IoReactor* reactor_ptr = reactor_.get(); + RequestDispatcher* dispatcher_ptr = dispatcher_.get(); + ThreadPool* pool_ptr = thread_pool_.get(); + ServerStats* stats_ptr = &stats_; + const size_t max_write_bytes = config_.max_write_queue_bytes > 0 + ? static_cast(config_.max_write_queue_bytes) + : ReactorConnection::kDefaultMaxWriteQueueBytes; + acceptor_->SetReactorHandler( + [reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, max_write_bytes](int client_fd) -> bool { + auto conn = ReactorConnection::Create(client_fd, reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, + max_write_bytes); + auto reg = reactor_ptr->Register(conn); + if (reg.has_value()) { + // Mirror the blocking path's HandleConnection: count this as an + // active connection so GetConnectionCount() and the + // mygramdb_active_connections metric report the live reactor + // population. The matching decrement happens in the close + // callback installed above. + stats_ptr->IncrementConnections(); + stats_ptr->IncrementTotalConnections(); + return true; + } + return false; + }); + } else { + acceptor_->SetConnectionHandler([this](int client_fd) { HandleConnection(client_fd); }); + } // Start Unix domain socket acceptor (if configured) if (!config_.unix_socket_path.empty()) { @@ -227,6 +301,8 @@ mygram::utils::Expected TcpServer::Start() { uds_config.unix_socket_path = config_.unix_socket_path; uds_config.max_connections = config_.max_connections; unix_acceptor_ = std::make_unique(uds_config, thread_pool_.get()); + // UDS acceptors always use the blocking I/O model for now — reactor mode + // is aimed at persistent TCP client fleets. unix_acceptor_->SetConnectionHandler([this](int client_fd) { HandleConnection(client_fd); }); auto uds_result = unix_acceptor_->Start(); @@ -267,6 +343,22 @@ void TcpServer::Stop() { scheduler_->Stop(); } + // Stop the IoReactor BEFORE the acceptor. Rationale: `ConnectionAcceptor::Stop` + // eagerly close(2)s every fd in its active_fds_ set — which includes the + // reactor-owned client fds, since the reactor's close_callback removes them + // only when the connection terminates naturally. If the acceptor ran first, + // it would close fds the reactor still owns, and drain tasks would then hit + // EBADF mid-send. Stopping the reactor first gives it the chance to drain + // and release its fds via Unregister → close_callback → active_fds_.erase. + // + // While the reactor is stopping, the acceptor may still accept a stray + // connection and hand it to reactor_handler_; the handler's Register call + // returns `kNetworkServerNotStarted`, the handler returns false, and the + // acceptor sends SERVER_BUSY and closes the socket. Acceptable. + if (reactor_) { + reactor_->Stop(); + } + // Stop connection acceptor if (acceptor_) { acceptor_->Stop(); @@ -341,10 +433,16 @@ void TcpServer::HandleConnection(int client_fd) { // RAII guard to ensure stats are decremented even if exceptions occur mygram::utils::ScopeGuard stats_cleanup([this]() { stats_.DecrementConnections(); }); - // Create I/O handler config + // Create I/O handler config. recv_timeout_sec is YAML-configurable + // (api.tcp.recv_timeout_sec); fall back to the historical 60s default if + // it was left at zero for legacy/test configs (0 means "disable timeout" + // only when explicitly negative in config — clamp here to preserve the + // long-standing production behaviour). + const int configured_recv_timeout = + config_.recv_timeout_sec > 0 ? config_.recv_timeout_sec : kDefaultConnectionRecvTimeoutSec; IOConfig io_config{.recv_buffer_size = static_cast(config_.recv_buffer_size), .max_query_length = static_cast(config_.max_query_length), - .recv_timeout_sec = kDefaultConnectionRecvTimeoutSec}; + .recv_timeout_sec = configured_recv_timeout}; // Request processor callback auto processor = [this](const std::string& request, ConnectionContext& conn_ctx) -> std::string { diff --git a/src/server/tcp_server.h b/src/server/tcp_server.h index f7f9f5c..bc7c5ce 100644 --- a/src/server/tcp_server.h +++ b/src/server/tcp_server.h @@ -20,6 +20,7 @@ #include "query/query_parser.h" #include "server/connection_acceptor.h" #include "server/connection_io_handler.h" +#include "server/io_reactor.h" #include "server/rate_limiter.h" #include "server/request_dispatcher.h" #include "server/server_stats.h" @@ -116,6 +117,15 @@ class TcpServer { */ uint16_t GetPort() const { return acceptor_ ? acceptor_->GetPort() : 0; } + /** + * @brief Check whether the IoReactor is active. TEST-ONLY accessor. + * + * Returns true when reactor mode was requested, the platform multiplexer + * was available, and Start() successfully started the event loop. + * Do not call this from production code. + */ + bool IsReactorActiveForTest() const { return reactor_ != nullptr && reactor_->IsRunning(); } + /** * @brief Get active connection count */ @@ -141,6 +151,7 @@ class TcpServer { */ ServerStats* GetMutableStats() { return &stats_; } + /** * @brief Get dump load in progress flag pointer (for HttpServer) */ @@ -204,6 +215,7 @@ class TcpServer { std::unique_ptr acceptor_; std::unique_ptr unix_acceptor_; std::unique_ptr dispatcher_; + std::unique_ptr reactor_; ///< Non-null when io_model == "reactor" and a backend is available. std::unique_ptr scheduler_; std::unique_ptr cache_manager_; std::unique_ptr variable_manager_; diff --git a/src/server/thread_pool.cpp b/src/server/thread_pool.cpp index 497c54f..225b35c 100644 --- a/src/server/thread_pool.cpp +++ b/src/server/thread_pool.cpp @@ -15,12 +15,28 @@ namespace mygramdb::server { ThreadPool::ThreadPool(size_t num_threads, size_t queue_size) : max_queue_size_(queue_size) { - // Default to CPU count if not specified + // Auto-size the pool when not specified. + // + // Under the Phase 3 default reactor I/O model, persistent client connections + // do NOT pin worker threads — they live in the reactor's connection map and + // only consume a worker briefly (via a drain task) when a complete command + // frame arrives. Consequently the worker count no longer has to scale with + // the concurrent-connection count; scaling by CPU count is sufficient. + // + // The floor of 4 keeps small VMs and containers responsive even when + // `hardware_concurrency()` reports a very small value (e.g. 1-2 cores) and + // gives the reactor somewhere to land burst dispatch tasks. + // + // Operators running the legacy blocking I/O model on a persistent-client + // fleet should set `api.tcp.worker_threads` explicitly (or switch back to + // `io_model: blocking` which is still supported as an emergency lever). if (num_threads == 0) { - num_threads = std::thread::hardware_concurrency(); - if (num_threads == 0) { - num_threads = 4; // Fallback + unsigned hw = std::thread::hardware_concurrency(); + if (hw == 0) { + hw = 4; // Fallback when the runtime can't detect core count } + constexpr size_t kMinAutoWorkers = 4; + num_threads = std::max(static_cast(hw) * 2, kMinAutoWorkers); } mygram::utils::StructuredLog() diff --git a/src/utils/error.h b/src/utils/error.h index b0c0114..998733a 100644 --- a/src/utils/error.h +++ b/src/utils/error.h @@ -125,6 +125,14 @@ enum class ErrorCode : std::uint16_t { kNetworkInvalidBindAddress = 6013, ///< Invalid bind address kNetworkUnixSocketPathTooLong = 6014, ///< Unix socket path exceeds limit kNetworkUnixSocketStale = 6015, ///< Unix socket already in use by another server + kNetworkReactorUnsupported = 6016, ///< No event multiplexer available on this platform + kNetworkReactorInitFailed = 6017, ///< epoll_create / kqueue syscall failed + kNetworkReactorRegisterFailed = 6018, ///< epoll_ctl ADD / kevent EV_ADD failed + kNetworkReactorModifyFailed = 6019, ///< epoll_ctl MOD / kevent update failed + kNetworkReactorRemoveFailed = 6020, ///< epoll_ctl DEL / kevent EV_DELETE failed + kNetworkReactorPollFailed = 6021, ///< epoll_wait / kevent poll failed + kNetworkReactorQueueFull = 6022, ///< Per-connection write queue cap exceeded (slow reader) + kNetworkReactorAlreadyOpen = 6023, ///< Multiplexer already opened // ===== Client Errors (7000-7999) ===== kClientNotConnected = 7000, ///< Client not connected @@ -327,6 +335,22 @@ inline const char* ErrorCodeToString(ErrorCode code) { return "Unix socket path too long"; case ErrorCode::kNetworkUnixSocketStale: return "Unix socket already in use"; + case ErrorCode::kNetworkReactorUnsupported: + return "Event multiplexer not supported on this platform"; + case ErrorCode::kNetworkReactorInitFailed: + return "Event multiplexer initialization failed"; + case ErrorCode::kNetworkReactorRegisterFailed: + return "Event multiplexer register failed"; + case ErrorCode::kNetworkReactorModifyFailed: + return "Event multiplexer modify failed"; + case ErrorCode::kNetworkReactorRemoveFailed: + return "Event multiplexer remove failed"; + case ErrorCode::kNetworkReactorPollFailed: + return "Event multiplexer poll failed"; + case ErrorCode::kNetworkReactorQueueFull: + return "Reactor per-connection write queue full"; + case ErrorCode::kNetworkReactorAlreadyOpen: + return "Event multiplexer already opened"; // Client case ErrorCode::kClientNotConnected: From d1e901233f468365810295ecfde4be6168fb7dbc Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 06:57:32 +0900 Subject: [PATCH 03/13] test(server): Add reactor tests and dual-mode CI coverage Unit tests - tests/server/reactor/event_multiplexer_test.cpp with MockEventMultiplexer: register/modify/remove/poll semantics against a deterministic fake so the reactor's event-loop logic is covered without touching real fds. - tests/server/io_reactor_test.cpp: start/stop lifecycle, Register after Stop is rejected, ArmWrite before Register returns the right error, close-callback fires exactly once per fd. - tests/server/reactor_connection_test.cpp: drain-task "clear-then-recheck" reschedule, EnqueueResponse cap enforcement, partial-send front_offset tracking, write_armed transitions, close during in-flight drain. Integration tests - tests/integration/server/reactor_integration_test.cpp: end-to-end happy-path (SEARCH/INFO), many concurrent clients, and two new tests: * WriteBackpressureHandledGracefully: small cap (64 KiB) plus a slow reader (SO_RCVBUF=4096) must log reactor_write_queue_overflow and force-close the slow client without stalling four parallel fast clients. * ManyIdleConnectionsDoNotBlockActiveClient: thread pool kWorkers=8 plus thousands of idle persistent clients must still serve a new active client in under 500 ms, proving the reactor avoids the one-thread-per-connection starvation failure mode. The Connect() helper uses poll() instead of select() so the test works past the FD_SETSIZE=1024 cliff on macOS when opening many fds. - tests/integration/server/reactor_starvation_regression_test.cpp: three tests that pin the reactor's invariant (LateClientServedUnderLoad, NoBusyErrorUnderSustainedLoad) plus a blocking-mode negative control that still exhibits starvation, so we can tell if anything regresses. - tests/integration/server/thread_pool_saturation_test.cpp: existing saturation test migrated into its own binary with the OneWorkerPerConnectionStarvesQueuedWork assertion inverted (LateClientServedDespitePinnedIdleClientsInDefaultMode) now that reactor is the default; the blocking-mode legacy behaviour is preserved by passing io_model="blocking" in two dedicated cases. Dual-mode CI - tests/integration/server/test_io_model_override.h: reads the MYGRAMDB_TEST_IO_MODEL env var and flips ServerConfig::io_model in the test fixture when set. - end_to_end_test.cpp / multi_table_test.cpp / verify_text_test.cpp call ApplyIoModelOverride() in SetUp. - tests/integration/server/CMakeLists.txt registers a second ctest entry for each of the three binaries with ENVIRONMENT MYGRAMDB_TEST_IO_MODEL=blocking so blocking-mode coverage keeps running alongside the reactor default. --- tests/integration/server/CMakeLists.txt | 120 ++ tests/integration/server/end_to_end_test.cpp | 2 + tests/integration/server/multi_table_test.cpp | 6 + .../server/reactor_integration_test.cpp | 1071 +++++++++++++++++ .../reactor_starvation_regression_test.cpp | 574 +++++++++ .../server/test_io_model_override.h | 48 + .../server/thread_pool_saturation_test.cpp | 510 ++++++++ tests/integration/server/verify_text_test.cpp | 5 + tests/server/CMakeLists.txt | 41 + tests/server/io_reactor_test.cpp | 471 ++++++++ tests/server/reactor/CMakeLists.txt | 22 + .../server/reactor/event_multiplexer_test.cpp | 473 ++++++++ .../server/reactor/mock_event_multiplexer.cpp | 168 +++ tests/server/reactor/mock_event_multiplexer.h | 106 ++ tests/server/reactor_connection_test.cpp | 445 +++++++ 15 files changed, 4062 insertions(+) create mode 100644 tests/integration/server/reactor_integration_test.cpp create mode 100644 tests/integration/server/reactor_starvation_regression_test.cpp create mode 100644 tests/integration/server/test_io_model_override.h create mode 100644 tests/integration/server/thread_pool_saturation_test.cpp create mode 100644 tests/server/io_reactor_test.cpp create mode 100644 tests/server/reactor/CMakeLists.txt create mode 100644 tests/server/reactor/event_multiplexer_test.cpp create mode 100644 tests/server/reactor/mock_event_multiplexer.cpp create mode 100644 tests/server/reactor/mock_event_multiplexer.h create mode 100644 tests/server/reactor_connection_test.cpp diff --git a/tests/integration/server/CMakeLists.txt b/tests/integration/server/CMakeLists.txt index b4ff022..a4b3c15 100644 --- a/tests/integration/server/CMakeLists.txt +++ b/tests/integration/server/CMakeLists.txt @@ -26,6 +26,7 @@ target_link_libraries(multi_table_integration_test mygramdb_server GTest::gtest_main ) +target_include_directories(multi_table_integration_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) # RESOURCE_LOCK: Prevent parallel execution to avoid port binding conflicts gtest_discover_tests(multi_table_integration_test @@ -34,6 +35,21 @@ gtest_discover_tests(multi_table_integration_test PROPERTIES RESOURCE_LOCK server_port ) +# Dual-mode CI (design doc Phase 2.6, deferred to Phase 3): the gtest_discover_tests +# call above registers the binary's tests under the reactor default. Add a second +# whole-binary ctest entry that runs the same binary with MYGRAMDB_TEST_IO_MODEL=blocking +# so the blocking fallback I/O model keeps integration coverage. +add_test( + NAME multi_table_integration_test.BlockingMode + COMMAND multi_table_integration_test +) +set_tests_properties(multi_table_integration_test.BlockingMode PROPERTIES + ENVIRONMENT "MYGRAMDB_TEST_IO_MODEL=blocking" + LABELS "INTEGRATION_BLOCKING" + RESOURCE_LOCK server_port + TIMEOUT 120 +) + # End-to-End Integration Tests add_executable(end_to_end_integration_test end_to_end_test.cpp @@ -43,6 +59,7 @@ target_link_libraries(end_to_end_integration_test mygramdb_server GTest::gtest_main ) +target_include_directories(end_to_end_integration_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) # RESOURCE_LOCK: Prevent parallel execution to avoid port binding conflicts gtest_discover_tests(end_to_end_integration_test @@ -51,6 +68,18 @@ gtest_discover_tests(end_to_end_integration_test PROPERTIES RESOURCE_LOCK server_port ) +# Dual-mode CI: re-run the same binary with MYGRAMDB_TEST_IO_MODEL=blocking. +add_test( + NAME end_to_end_integration_test.BlockingMode + COMMAND end_to_end_integration_test +) +set_tests_properties(end_to_end_integration_test.BlockingMode PROPERTIES + ENVIRONMENT "MYGRAMDB_TEST_IO_MODEL=blocking" + LABELS "INTEGRATION_BLOCKING" + RESOURCE_LOCK server_port + TIMEOUT 120 +) + # Stress Tests add_executable(stress_test stress_test.cpp @@ -70,6 +99,35 @@ gtest_discover_tests(stress_test TIMEOUT 300 # 5 minutes timeout ) +# Thread pool saturation regression tests +# +# Regression gate for the blocking I/O model's starvation failure mode: +# ConnectionIOHandler holds one worker thread per persistent connection for +# its entire lifetime, so W idle clients starve every subsequent request +# until recv() idle timeouts fire. +# +# LOAD-labeled so it runs only via `make test-load` / `ctest -L LOAD`, +# not in `make test-fast` / CI. +add_executable(thread_pool_saturation_test + thread_pool_saturation_test.cpp +) + +target_link_libraries(thread_pool_saturation_test + mygramdb_server + GTest::gtest_main +) + +# RESOURCE_LOCK: opens many concurrent sockets and binds a test server, +# so it must not race with other server/port-using tests. +gtest_discover_tests(thread_pool_saturation_test + DISCOVERY_MODE POST_BUILD + DISCOVERY_TIMEOUT 30 + PROPERTIES + LABELS "LOAD" + RESOURCE_LOCK server_port + TIMEOUT 120 # 2 minutes: starvation test waits up to 1.5s per late client +) + # Variable Handler Integration Tests add_executable(variable_handler_integration_test variable_handler_test.cpp @@ -96,6 +154,7 @@ target_link_libraries(verify_text_integration_test mygramdb_server GTest::gtest_main ) +target_include_directories(verify_text_integration_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) # RESOURCE_LOCK: Prevent parallel execution to avoid port binding and file I/O conflicts gtest_discover_tests(verify_text_integration_test @@ -104,3 +163,64 @@ gtest_discover_tests(verify_text_integration_test PROPERTIES RESOURCE_LOCK server_port ) + +# Dual-mode CI: re-run the same binary with MYGRAMDB_TEST_IO_MODEL=blocking. +add_test( + NAME verify_text_integration_test.BlockingMode + COMMAND verify_text_integration_test +) +set_tests_properties(verify_text_integration_test.BlockingMode PROPERTIES + ENVIRONMENT "MYGRAMDB_TEST_IO_MODEL=blocking" + LABELS "INTEGRATION_BLOCKING" + RESOURCE_LOCK server_port + TIMEOUT 120 +) + +# Reactor starvation regression tests (Phase 2.T7) +# +# Goal test: reactor mode must NOT exhibit the blocking I/O model's +# starvation failure. Three tests: +# T1 — positive control: reactor with 128 persistent clients + late client +# T2 — throughput: 256 clients × 10 INFO requests, no ERR SERVER_BUSY +# T3 — negative control: blocking mode starves under 8 persistent clients +add_executable(reactor_starvation_regression_test + reactor_starvation_regression_test.cpp +) + +target_link_libraries(reactor_starvation_regression_test + mygramdb_server + GTest::gtest_main +) + +gtest_discover_tests(reactor_starvation_regression_test + DISCOVERY_MODE POST_BUILD + DISCOVERY_TIMEOUT 30 + PROPERTIES + LABELS "INTEGRATION" + RESOURCE_LOCK server_port + TIMEOUT 120 +) + +# Reactor I/O model integration tests (Phase 2.T6) +# +# Exercises the end-to-end reactor path: config io_model="reactor" -> +# IoReactor (epoll/kqueue) -> ReactorConnection drain-task pattern -> +# RequestDispatcher. Tests skip at runtime on platforms without epoll/kqueue. +add_executable(reactor_integration_test + reactor_integration_test.cpp +) + +target_link_libraries(reactor_integration_test + mygramdb_server + GTest::gtest_main +) + +# RESOURCE_LOCK: opens concurrent sockets and binds a test server port +gtest_discover_tests(reactor_integration_test + DISCOVERY_MODE POST_BUILD + DISCOVERY_TIMEOUT 30 + PROPERTIES + LABELS "INTEGRATION" + RESOURCE_LOCK server_port + TIMEOUT 120 # 2 minutes: concurrent-clients tests can take ~30 s +) diff --git a/tests/integration/server/end_to_end_test.cpp b/tests/integration/server/end_to_end_test.cpp index b006411..4a1f841 100644 --- a/tests/integration/server/end_to_end_test.cpp +++ b/tests/integration/server/end_to_end_test.cpp @@ -15,6 +15,7 @@ #include "config/config.h" #include "server/tcp_server.h" +#include "test_io_model_override.h" using namespace mygramdb::server; using namespace mygramdb; @@ -86,6 +87,7 @@ class EndToEndTest : public ::testing::Test { config_.port = 0; // Random port config_.host = "127.0.0.1"; config_.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(config_); server_ = std::make_unique(config_, table_contexts_, "./snapshots", nullptr); ASSERT_TRUE(server_->Start()); diff --git a/tests/integration/server/multi_table_test.cpp b/tests/integration/server/multi_table_test.cpp index fc11894..b806d8d 100644 --- a/tests/integration/server/multi_table_test.cpp +++ b/tests/integration/server/multi_table_test.cpp @@ -17,6 +17,7 @@ #include "config/config.h" #include "server/tcp_server.h" +#include "test_io_model_override.h" #ifdef USE_MYSQL #include "mysql/binlog_reader.h" @@ -68,6 +69,7 @@ TEST(TcpServerMultiTableTest, MultiTableSearch) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts, "./snapshots", nullptr); ASSERT_TRUE(server.Start()); @@ -167,6 +169,7 @@ TEST(TcpServerMultiTableTest, MultiTableCount) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts); ASSERT_TRUE(server.Start()); @@ -248,6 +251,7 @@ TEST(TcpServerMultiTableTest, MultiTableGet) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts); ASSERT_TRUE(server.Start()); @@ -345,6 +349,7 @@ TEST(TcpServerMultiTableTest, MultiTableInfo) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts); ASSERT_TRUE(server.Start()); @@ -415,6 +420,7 @@ TEST(TcpServerMultiTableTest, TableIsolation) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts); ASSERT_TRUE(server.Start()); diff --git a/tests/integration/server/reactor_integration_test.cpp b/tests/integration/server/reactor_integration_test.cpp new file mode 100644 index 0000000..4a1f2c5 --- /dev/null +++ b/tests/integration/server/reactor_integration_test.cpp @@ -0,0 +1,1071 @@ +/** + * @file reactor_integration_test.cpp + * @brief Integration tests for the reactor I/O model against a real TcpServer. + * + * These tests exercise the end-to-end reactor path: + * config_.io_model == "reactor" + * -> IoReactor (epoll on Linux, kqueue on macOS) + * -> ReactorConnection per-fd drain-task pattern + * -> RequestDispatcher -> INFO handler -> response written on worker thread + * + * On platforms with no supported event multiplexer (not Linux, macOS, or + * BSD), the fixture skips all tests at runtime via GTEST_SKIP(). + * + * Labeled "INTEGRATION" — included in `ctest -L INTEGRATION`. + */ + +// Platform guard: compile-time skip for unsupported platforms. +// macOS (kqueue) and Linux (epoll) are the two real targets. +#if !defined(__linux__) && !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \ + !defined(__OpenBSD__) +#include +// Provide a trivially-passing placeholder so the binary links cleanly. +TEST(ReactorIntegrationTest, PlatformNotSupported) { + GTEST_SKIP() << "Reactor I/O model not supported on this platform (no epoll/kqueue)."; +} +#else + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "config/config.h" +#include "index/index.h" +#include "server/server_types.h" +#include "server/tcp_server.h" +#include "storage/document_store.h" + +namespace mygramdb::server { + +// ============================================================================ +// Test fixture +// ============================================================================ + +class ReactorIntegrationTest : public ::testing::Test { + protected: + void SetUp() override { + spdlog::set_level(spdlog::level::debug); // Enable debug logs for reactor diagnostics + auto index = std::make_unique(2, 1); + auto doc_store = std::make_unique(); + table_ctx_ = std::make_unique(TableContext{ + .name = "t", + .config = config::TableConfig{}, + .index = std::move(index), + .doc_store = std::move(doc_store), + }); + table_contexts_["t"] = table_ctx_.get(); + } + + void TearDown() override { + table_contexts_.clear(); + table_ctx_.reset(); + } + + // ------------------------------------------------------------------------- + // Server helpers + // ------------------------------------------------------------------------- + + /** + * @brief Start a TcpServer in reactor mode and return it. + * + * If the platform has no supported event multiplexer the reactor silently + * falls back to blocking mode. Callers that need reactor mode specifically + * should check `server->IsReactorActiveForTest()` and GTEST_SKIP if false. + */ + std::unique_ptr StartServer(int worker_threads = 8, int max_connections = 512, + int64_t max_write_queue_bytes = 0) { + ServerConfig cfg; + cfg.host = "127.0.0.1"; + cfg.port = 0; // OS assigns + cfg.worker_threads = worker_threads; + cfg.max_connections = max_connections; + cfg.allow_cidrs = {"127.0.0.1/32"}; + cfg.io_model = "reactor"; + if (max_write_queue_bytes > 0) { + cfg.max_write_queue_bytes = max_write_queue_bytes; + } + + auto s = std::make_unique(cfg, table_contexts_); + auto res = s->Start(); + EXPECT_TRUE(res) << "Failed to start TcpServer: " + << (res ? std::string{} : res.error().to_string()); + // Give the accept loop a moment to reach its main loop. + std::this_thread::sleep_for(std::chrono::milliseconds(30)); + return s; + } + + /** + * @brief Require reactor mode; skip the test if the server fell back to + * blocking (happens when no epoll/kqueue factory is available). + */ + static void RequireReactor(const TcpServer& server) { + if (!server.IsReactorActiveForTest()) { + GTEST_SKIP() << "IoReactor is not active on this build/platform " + "(no epoll/kqueue available); skipping reactor-specific test."; + } + } + + // ------------------------------------------------------------------------- + // Network helpers — mirrors ThreadPoolSaturationTest for API consistency + // ------------------------------------------------------------------------- + + /** + * @brief Connect to 127.0.0.1:port with a bounded timeout. + * @return socket fd on success, -1 on failure. + */ + int Connect(uint16_t port, int timeout_ms = 2000) { + int sock = socket(AF_INET, SOCK_STREAM, 0); + if (sock < 0) return -1; + + int flags = fcntl(sock, F_GETFL, 0); + if (flags >= 0) fcntl(sock, F_SETFL, flags | O_NONBLOCK); + + struct sockaddr_in addr {}; + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr); + + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API + int rc = connect(sock, reinterpret_cast(&addr), sizeof(addr)); + if (rc < 0 && errno != EINPROGRESS) { + close(sock); + return -1; + } + + if (rc < 0) { + // Use poll() rather than select() so this helper works past the + // FD_SETSIZE cliff (1024 on macOS/glibc). Tests that open many + // concurrent sockets quickly exceed that cap. + struct pollfd pfd {}; + pfd.fd = sock; + pfd.events = POLLOUT; + int ready = ::poll(&pfd, 1, timeout_ms); + if (ready <= 0) { + close(sock); + return -1; + } + int so_err = 0; + socklen_t len = sizeof(so_err); + if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &so_err, &len) < 0 || so_err != 0) { + close(sock); + return -1; + } + } + + // Restore flags; set I/O timeout for blocking reads + if (flags >= 0) fcntl(sock, F_SETFL, flags); + struct timeval io {}; + io.tv_sec = 5; + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); + setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &io, sizeof(io)); + return sock; + } + + /** @brief Send `line` followed by CRLF. */ + bool SendLine(int sock, const std::string& line) { + std::string msg = line + "\r\n"; + ssize_t sent = send(sock, msg.data(), msg.size(), 0); + return sent == static_cast(msg.size()); + } + + /** + * @brief Read one CRLF-terminated response within timeout_ms. + * + * WARNING: this helper matches the first `\r\n` and discards anything after + * it. It only works for single-line responses (e.g. `"OK DEBUG_ON\r\n"`). + * For multi-line responses like INFO or SEARCH that contain internal `\r\n` + * and end with `\nEND\r\n`, use `RecvMultilineResponse` instead. + * + * @return response without trailing CRLF, or empty string on timeout/error. + */ + std::string RecvLine(int sock, int timeout_ms = 5000) { + struct timeval io {}; + io.tv_sec = timeout_ms / 1000; + io.tv_usec = (timeout_ms % 1000) * 1000; + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); + + std::string out; + std::array buf{}; + while (out.size() < 65536) { + ssize_t n = recv(sock, buf.data(), buf.size(), 0); + if (n <= 0) return ""; + out.append(buf.data(), static_cast(n)); + if (out.find("\r\n") != std::string::npos) break; + } + auto pos = out.find("\r\n"); + if (pos != std::string::npos) out.resize(pos); + return out; + } + + /** + * @brief Read a full multi-line response ending in `\r\nEND\r\n`. + * + * The MygramDB text protocol's INFO, SEARCH, and similar commands return + * a stream of `\r\n`-separated lines followed by a final `END\r\n`. The + * test must read the ENTIRE response before issuing the next request — + * otherwise the next RecvLine will start reading in the middle of this + * response. + * + * @return the full response bytes (including internal CRLFs and the + * trailing `\r\nEND\r\n`), or empty string on timeout/error. + */ + std::string RecvMultilineResponse(int sock, int timeout_ms = 5000) { + struct timeval io {}; + io.tv_sec = timeout_ms / 1000; + io.tv_usec = (timeout_ms % 1000) * 1000; + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); + + static constexpr const char kTerminator[] = "\r\nEND\r\n"; + static constexpr size_t kTerminatorLen = 7; + + std::string out; + std::array buf{}; + while (out.size() < 1 * 1024 * 1024) { + ssize_t n = recv(sock, buf.data(), buf.size(), 0); + if (n <= 0) return ""; + out.append(buf.data(), static_cast(n)); + if (out.size() >= kTerminatorLen && + out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { + return out; + } + } + return ""; + } + + /** + * @brief Raise RLIMIT_NOFILE to at least `desired`. + * @return the effective soft limit after the attempt. + */ + static rlim_t RaiseFdLimit(rlim_t desired) { + struct rlimit rl {}; + if (getrlimit(RLIMIT_NOFILE, &rl) != 0) return 0; + rlim_t target = std::min(desired, rl.rlim_max); + if (rl.rlim_cur < target) { + rl.rlim_cur = target; + setrlimit(RLIMIT_NOFILE, &rl); // best-effort + getrlimit(RLIMIT_NOFILE, &rl); + } + return rl.rlim_cur; + } + + std::unique_ptr table_ctx_; + std::unordered_map table_contexts_; +}; + +// ============================================================================ +// Test 1 — Basic INFO round-trip +// ============================================================================ + +/** + * Start a reactor server, connect once, send INFO, get "OK INFO" response. + */ +TEST_F(ReactorIntegrationTest, InfoCommandRoundtrip) { + auto server = StartServer(); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + int s = Connect(port); + ASSERT_GE(s, 0) << "connect() failed"; + ASSERT_TRUE(SendLine(s, "INFO")); + std::string resp = RecvLine(s); + EXPECT_EQ(resp.substr(0, 7), "OK INFO") << "Unexpected response: " << resp; + close(s); + server->Stop(); +} + +// ============================================================================ +// Test 2 — 50 sequential commands on one connection +// ============================================================================ + +/** + * The drain-task-per-connection invariant: a single connection processes + * multiple commands in order. 50 sequential INFO commands on one fd must + * all return "OK INFO" and in the order they were sent. + */ +TEST_F(ReactorIntegrationTest, MultipleSequentialCommands) { + auto server = StartServer(); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + int s = Connect(port); + ASSERT_GE(s, 0); + + constexpr int kCount = 50; + for (int i = 0; i < kCount; ++i) { + ASSERT_TRUE(SendLine(s, "INFO")) << "send failed at i=" << i; + std::string resp = RecvMultilineResponse(s); + ASSERT_FALSE(resp.empty()) << "Command " << i << " timed out or got empty response"; + ASSERT_EQ(resp.substr(0, 7), "OK INFO") << "Command " << i << " got: " << resp.substr(0, 40); + } + + close(s); + server->Stop(); +} + +// ============================================================================ +// Test 3 — Pipelining: 3 requests in one write(), read 3 responses +// ============================================================================ + +/** + * Pipelining test: send "INFO\r\nINFO\r\nINFO\r\n" in a single write() and + * read back 3 responses. This exercises the ReactorConnection frame parser + * handling multiple frames arriving in one recv() chunk. + */ +TEST_F(ReactorIntegrationTest, PersistentConnectionPipelining) { + auto server = StartServer(); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + int s = Connect(port); + ASSERT_GE(s, 0); + + // Three INFO requests pipelined into one write + const std::string burst = "INFO\r\nINFO\r\nINFO\r\n"; + ssize_t sent = send(s, burst.data(), burst.size(), 0); + ASSERT_EQ(sent, static_cast(burst.size())) << "partial send"; + + // Read 3 responses + for (int i = 0; i < 3; ++i) { + std::string resp = RecvMultilineResponse(s, 5000); + ASSERT_FALSE(resp.empty()) << "Pipelined response " << i << " timed out"; + EXPECT_EQ(resp.substr(0, 7), "OK INFO") << "Pipelined response " << i << ": " << resp.substr(0, 40); + } + + close(s); + server->Stop(); +} + +// ============================================================================ +// Test 4 — 100 concurrent clients, 10 commands each +// ============================================================================ + +/** + * 100 client threads, all releasing at the same moment (barrier), each + * sending 10 INFO commands. All 1000 requests must succeed. No + * SERVER_BUSY, no timeouts, no connection refused. + */ +TEST_F(ReactorIntegrationTest, ConcurrentClients100) { + auto server = StartServer(/*worker_threads=*/8); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + constexpr int kClients = 100; + constexpr int kCmdsPerClient = 10; + + std::atomic failures{0}; + // C++17 manual barrier: all kClients threads wait until the last one arrives + std::mutex barrier_mu; + std::condition_variable barrier_cv; + std::atomic barrier_count{0}; + auto wait_for_all = [&]() { + barrier_count.fetch_add(1, std::memory_order_acq_rel); + std::unique_lock lk(barrier_mu); + barrier_cv.wait(lk, [&] { return barrier_count.load() >= kClients; }); + barrier_cv.notify_all(); + }; + + auto client_task = [&]() { + wait_for_all(); + + int s = Connect(port, 3000); + if (s < 0) { + failures.fetch_add(1, std::memory_order_relaxed); + return; + } + + for (int i = 0; i < kCmdsPerClient; ++i) { + if (!SendLine(s, "INFO")) { + failures.fetch_add(1, std::memory_order_relaxed); + close(s); + return; + } + std::string resp = RecvMultilineResponse(s, 5000); + if (resp.empty() || resp.substr(0, 7) != "OK INFO") { + failures.fetch_add(1, std::memory_order_relaxed); + close(s); + return; + } + } + close(s); + }; + + std::vector threads; + threads.reserve(kClients); + for (int i = 0; i < kClients; ++i) threads.emplace_back(client_task); + for (auto& t : threads) t.join(); + + EXPECT_EQ(failures.load(), 0) + << failures.load() << " out of " << kClients << " clients encountered errors"; + server->Stop(); +} + +// ============================================================================ +// Test 5 — Scale-up: as many clients as RLIMIT_NOFILE allows (cap 500) +// ============================================================================ + +/** + * Scale-up variant. Tries up to 500 concurrent clients; gracefully + * degrades if the fd budget doesn't permit it. Each client sends 5 INFO + * commands. All requests must succeed. + */ +TEST_F(ReactorIntegrationTest, ConcurrentClientsMany) { + auto server = StartServer(/*worker_threads=*/16); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + // Each client needs ~2 fds (client-side sock + server-side sock) plus + // headroom for the server's listen fd, test binary fds, etc. + constexpr rlim_t kDesiredFds = 2048; + constexpr int kMaxClients = 500; + constexpr int kMinClientsToRun = 50; // skip if budget is tiny + + rlim_t effective = RaiseFdLimit(kDesiredFds); + // Reserve ~64 fds for the test process itself + int max_clients = std::min(kMaxClients, static_cast((effective - 64) / 2)); + + if (max_clients < kMinClientsToRun) { + GTEST_SKIP() << "RLIMIT_NOFILE too small (" << effective << ") for meaningful concurrency test; " + << "re-run with ulimit -n 2048"; + } + + std::cout << "[ConcurrentClientsMany] using " << max_clients << " clients (rlimit=" << effective << ")" + << std::endl; + + constexpr int kCmdsPerClient = 5; + std::atomic failures{0}; + // C++17 manual barrier + std::mutex barrier_mu2; + std::condition_variable barrier_cv2; + std::atomic barrier_count2{0}; + int barrier_total = max_clients; + auto wait_for_all2 = [&]() { + barrier_count2.fetch_add(1, std::memory_order_acq_rel); + std::unique_lock lk(barrier_mu2); + barrier_cv2.wait(lk, [&] { return barrier_count2.load() >= barrier_total; }); + barrier_cv2.notify_all(); + }; + + auto client_task = [&]() { + wait_for_all2(); + + int s = Connect(port, 3000); + if (s < 0) { + failures.fetch_add(1, std::memory_order_relaxed); + return; + } + for (int i = 0; i < kCmdsPerClient; ++i) { + if (!SendLine(s, "INFO")) { + failures.fetch_add(1, std::memory_order_relaxed); + close(s); + return; + } + std::string resp = RecvMultilineResponse(s, 5000); + if (resp.empty() || resp.substr(0, 7) != "OK INFO") { + failures.fetch_add(1, std::memory_order_relaxed); + close(s); + return; + } + } + close(s); + }; + + std::vector threads; + threads.reserve(max_clients); + for (int i = 0; i < max_clients; ++i) threads.emplace_back(client_task); + for (auto& t : threads) t.join(); + + EXPECT_EQ(failures.load(), 0) + << failures.load() << " out of " << max_clients << " clients failed"; + server->Stop(); +} + +// ============================================================================ +// Test 6 — Client disconnects mid-request (incomplete frame) +// ============================================================================ + +/** + * Client sends an incomplete frame ("IN" with no CRLF) then closes. + * The server must handle the HUP gracefully — no hang, no crash. + * A subsequent client must still get a valid response. + */ +TEST_F(ReactorIntegrationTest, ClientDisconnectMidRequest) { + auto server = StartServer(); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + // Abrupt client + { + int s = Connect(port); + ASSERT_GE(s, 0); + // Send partial frame — no CRLF + const char* partial = "IN"; + send(s, partial, 2, 0); + close(s); // close without completing frame + } + + // Give the reactor event loop a chance to observe the HUP and clean up + // the connection. We use a poll loop rather than a blind sleep: wait + // until the server reports zero active connections (or timeout). + auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(3); + while (std::chrono::steady_clock::now() < deadline) { + if (server->GetConnectionCount() == 0) break; + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + + // A new client must still work + int s2 = Connect(port); + ASSERT_GE(s2, 0) << "Failed to connect after abrupt client disconnect"; + ASSERT_TRUE(SendLine(s2, "INFO")); + std::string resp = RecvLine(s2, 5000); + EXPECT_EQ(resp.substr(0, 7), "OK INFO") << "Second client got: " << resp; + close(s2); + + server->Stop(); +} + +// ============================================================================ +// Test 7 — Client disconnects during response (EPIPE tolerance) +// ============================================================================ + +/** + * Client sends INFO, reads exactly 1 byte, then closes. The server may + * observe EPIPE on the remainder of the write. It must clean up gracefully + * and subsequent clients must still succeed. + * + * Inherently racy (timing of the close vs. the send on the worker thread). + * The test is structured so it passes deterministically: success is defined + * as "the subsequent client always succeeds", regardless of whether EPIPE + * was actually triggered for the first client. + */ +TEST_F(ReactorIntegrationTest, ClientDisconnectDuringResponse) { + auto server = StartServer(); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + // Attempt to trigger EPIPE: send INFO, read 1 byte, close immediately + { + int s = Connect(port); + ASSERT_GE(s, 0); + ASSERT_TRUE(SendLine(s, "INFO")); + // Read exactly 1 byte so the socket receive buffer is partially drained, + // then close without reading the rest. + char byte = 0; + recv(s, &byte, 1, 0); + close(s); + } + + // Wait for the abrupt client to be cleaned up + auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(3); + while (std::chrono::steady_clock::now() < deadline) { + if (server->GetConnectionCount() == 0) break; + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + + // Subsequent client must succeed — this is the invariant we are asserting + int s2 = Connect(port); + ASSERT_GE(s2, 0); + ASSERT_TRUE(SendLine(s2, "INFO")); + std::string resp = RecvLine(s2, 5000); + EXPECT_EQ(resp.substr(0, 7), "OK INFO") << "Post-EPIPE client got: " << resp; + close(s2); + + server->Stop(); +} + +// ============================================================================ +// Test 8 — Graceful shutdown with active clients +// ============================================================================ + +/** + * Open 10 persistent idle connections (sent INFO, got response, now idle). + * Call Stop() from a separate thread. Assert Stop() returns within 3 s. + * After Stop(), all client recv()s return 0 (FIN) or an error (EBADF/ + * ECONNRESET). + */ +TEST_F(ReactorIntegrationTest, GracefulShutdownWithActiveClients) { + auto server = StartServer(); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + constexpr int kPersistentClients = 10; + std::vector socks; + socks.reserve(kPersistentClients); + for (int i = 0; i < kPersistentClients; ++i) { + int s = Connect(port); + ASSERT_GE(s, 0) << "client " << i; + ASSERT_TRUE(SendLine(s, "INFO")); + // Drain the entire multi-line response so the kernel socket buffer is + // empty by the time Stop() runs. Otherwise the leftover "\r\nEND\r\n" + // trailer would be returned by the post-shutdown recv() check and mask + // the actual FIN we want to observe. + std::string resp = RecvMultilineResponse(s); + ASSERT_FALSE(resp.empty()) << "client " << i << " timed out"; + ASSERT_EQ(resp.substr(0, 7), "OK INFO") << "client " << i; + socks.push_back(s); + } + + // Stop in a separate thread; measure elapsed time + std::atomic stop_done{false}; + std::thread stopper([&]() { + server->Stop(); + stop_done.store(true, std::memory_order_release); + }); + + auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5); + while (!stop_done.load(std::memory_order_acquire)) { + ASSERT_LT(std::chrono::steady_clock::now(), deadline) << "Stop() did not return within 5 s"; + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + } + stopper.join(); + + // After Stop(), all sockets should receive FIN (n==0) or error. + // Give FINs a moment to propagate. + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + for (int s : socks) { + char buf = 0; + ssize_t n = recv(s, &buf, 1, MSG_DONTWAIT); + // n == 0 → clean FIN; n < 0 → EAGAIN/EBADF/ECONNRESET (all acceptable) + // n > 0 would mean the server sent unexpected data after Stop(), fail. + EXPECT_LE(n, 0) << "Expected FIN or error from stopped server, got " << n << " bytes"; + close(s); + } +} + +// ============================================================================ +// Test 9 — Confirm reactor backend is active +// ============================================================================ + +/** + * After Start(), IsReactorActiveForTest() must return true (handled by + * RequireReactor which would skip otherwise). Additionally verify that + * zero clients are connected at baseline. + */ +TEST_F(ReactorIntegrationTest, BackendIsReactor) { + auto server = StartServer(); + RequireReactor(*server); + + // Reactor is running; no clients yet. + EXPECT_TRUE(server->IsReactorActiveForTest()); + EXPECT_EQ(server->GetConnectionCount(), 0U); + + // One quick request to confirm it actually routes through the reactor. + uint16_t port = server->GetPort(); + int s = Connect(port); + ASSERT_GE(s, 0); + ASSERT_TRUE(SendLine(s, "INFO")); + EXPECT_EQ(RecvLine(s).substr(0, 7), "OK INFO"); + close(s); + + server->Stop(); + EXPECT_FALSE(server->IsReactorActiveForTest()); +} + +// ============================================================================ +// Test 10 — Reactor does not starve a persistent fleet +// ============================================================================ + +/** + * Inverse of thread_pool_saturation_test: pin 8 persistent idle clients. + * A 9th client must get a response in <500 ms. In reactor mode the 8 + * pinned connections do NOT hold worker threads, so the 9th request is + * always serviced from the free pool. + */ +TEST_F(ReactorIntegrationTest, ReactorModeDoesNotStarvePersistentFleet) { + // Keep the thread pool tiny so the starvation would be obvious if the + // reactor degraded to one-worker-per-connection. + constexpr int kWorkers = 4; + auto server = StartServer(kWorkers); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + // Pin 8 persistent idle clients (> kWorkers to stress-test) + constexpr int kPinned = 8; + std::vector pinned; + pinned.reserve(kPinned); + for (int i = 0; i < kPinned; ++i) { + int s = Connect(port); + ASSERT_GE(s, 0) << "pinned client " << i; + ASSERT_TRUE(SendLine(s, "INFO")); + ASSERT_EQ(RecvLine(s).substr(0, 7), "OK INFO") << "pinned client " << i; + pinned.push_back(s); + } + + // 9th client: must respond quickly even though there are 8 idle connections + int late = Connect(port); + ASSERT_GE(late, 0); + ASSERT_TRUE(SendLine(late, "INFO")); + + auto t0 = std::chrono::steady_clock::now(); + std::string resp = RecvLine(late, /*timeout_ms=*/500); + auto elapsed_ms = + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0).count(); + + EXPECT_EQ(resp.substr(0, 7), "OK INFO") + << "9th client starved in reactor mode with " << kPinned << " idle connections"; + EXPECT_LT(elapsed_ms, 500) + << "9th client responded but took " << elapsed_ms << "ms (>500ms) in reactor mode"; + + close(late); + for (int s : pinned) close(s); + server->Stop(); +} + +// ============================================================================ +// Test 11 — Large frame handling +// ============================================================================ + +/** + * Send a command just under 1 MiB (ReactorConnection::kMaxReadBufferBytes). + * The server should respond normally (it won't recognise the giant command + * but it should close gracefully, not crash). + * + * Send a frame > 1 MiB: the connection must be closed by the server. + */ +TEST_F(ReactorIntegrationTest, ClientSendsLargeFrame) { + auto server = StartServer(); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + // --- Sub-cap frame (slightly under 1 MiB) --- + // The server will close when it can't parse the oversized command, + // but it should NOT crash. + { + int s = Connect(port); + ASSERT_GE(s, 0); + + // 900 KB of 'X' characters + CRLF — under the 1 MiB cap. + constexpr size_t kSubCapSize = 900 * 1024; + std::string big_cmd(kSubCapSize, 'X'); + big_cmd += "\r\n"; + // Send in chunks to avoid hitting SO_SNDBUF + size_t sent_total = 0; + while (sent_total < big_cmd.size()) { + ssize_t n = send(s, big_cmd.data() + sent_total, big_cmd.size() - sent_total, 0); + if (n <= 0) break; + sent_total += static_cast(n); + } + // We don't assert a specific response here — just that the connection is + // handled without crashing (recv returns something or EOF). + std::string resp = RecvLine(s, 5000); + // Acceptable: error response or connection closed; NOT a crash. + (void)resp; + close(s); + } + + // --- Over-cap frame (> 1 MiB) --- + // ReactorConnection must close the connection after exceeding kMaxReadBufferBytes. + { + int s = Connect(port); + ASSERT_GE(s, 0); + + // 1.1 MiB — exceeds the 1 MiB cap, no CRLF yet (to keep it as one frame) + constexpr size_t kOverCapSize = 1100 * 1024; + std::string huge_cmd(kOverCapSize, 'Y'); + huge_cmd += "\r\n"; + + // Send until we get EPIPE or the server closes + size_t sent_total = 0; + bool got_epipe = false; + while (sent_total < huge_cmd.size()) { + ssize_t n = send(s, huge_cmd.data() + sent_total, + std::min(65536, huge_cmd.size() - sent_total), MSG_NOSIGNAL); + if (n <= 0) { + got_epipe = (errno == EPIPE || errno == ECONNRESET); + break; + } + sent_total += static_cast(n); + } + + // Either we got EPIPE/ECONNRESET during send, or the server closed the + // connection which we observe as recv() == 0. + if (!got_epipe) { + char buf = 0; + struct timeval tv {}; + tv.tv_sec = 3; + setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + ssize_t n = recv(s, &buf, 1, 0); + EXPECT_LE(n, 0) << "Expected server to close over-cap connection"; + } + close(s); + } + + // Server must still be operational after both large-frame clients + int s3 = Connect(port); + ASSERT_GE(s3, 0); + ASSERT_TRUE(SendLine(s3, "INFO")); + EXPECT_EQ(RecvLine(s3).substr(0, 7), "OK INFO"); + close(s3); + + server->Stop(); +} + +// ============================================================================ +// Test 12 — Write backpressure: a slow reader does not starve other clients +// ============================================================================ + +/** + * Design-doc §7 R3 invariant: a client that accepts bytes into its kernel + * recv buffer but never calls recv() must NOT be able to stall the server + * or starve other clients. The reactor's per-connection write queue + * decouples the slow reader from the rest of the server: + * + * 1. Worker drains frames, Dispatch() runs, EnqueueResponse is called. + * 2. The inline non-blocking send fills the slow reader's socket buffer + * and starts hitting EAGAIN. + * 3. ReactorConnection arms kWritable on the slow reader's fd and returns + * control to the worker, which moves on to other connections. + * 4. Other clients' requests continue to be served with their normal + * latency. + * + * This test constructs that exact scenario with a small + * max_write_queue_bytes cap (64 KiB) so that the cap enforcement path is + * exercised: once the slow reader's write_queue exceeds 64 KiB, the reactor + * forcibly closes that connection and logs `reactor_write_queue_overflow`. + * Meanwhile a "fast client" thread continuously issues INFO requests and + * verifies they are all served promptly. + */ +TEST_F(ReactorIntegrationTest, WriteBackpressureHandledGracefully) { + // 64 KiB cap: small enough that a burst of pipelined INFO responses to a + // non-reading peer will exceed it within a few hundred milliseconds. + constexpr int64_t kCapBytes = 64 * 1024; + auto server = StartServer(/*worker_threads=*/4, /*max_connections=*/64, kCapBytes); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + // ------------------------------------------------------------------------- + // Slow reader: shrink the kernel recv buffer so it fills quickly, pipeline + // many INFO requests, and NEVER recv(). The server's send() will hit + // EAGAIN, arm kWritable, and pile bytes into the write_queue until the + // cap fires. + // ------------------------------------------------------------------------- + int slow = Connect(port); + ASSERT_GE(slow, 0); + + // Shrink SO_RCVBUF so the kernel buffer fills after only a few responses. + // The kernel may round this up but it will still be far below 64 KiB so + // the ReactorConnection queue bears the brunt of the pressure. + int rcvbuf = 4096; + setsockopt(slow, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)); + + // Pipeline a large batch of INFO commands. Each INFO response is a few + // hundred bytes, so ~1000 responses is more than enough to blow past the + // 64 KiB cap once the slow reader's recv buffer is full. + std::string burst; + burst.reserve(8 * 1024); + for (int i = 0; i < 1024; ++i) burst.append("INFO\r\n"); + ssize_t sent = 0; + while (sent < static_cast(burst.size())) { + ssize_t n = send(slow, burst.data() + sent, burst.size() - sent, MSG_NOSIGNAL); + if (n <= 0) break; + sent += n; + } + // Slow reader deliberately does NOT recv(). + + // ------------------------------------------------------------------------- + // Fast client(s): a small pool of concurrent workers that issue INFO and + // expect responses within 500 ms per request. If the slow reader were + // somehow blocking the event loop or starving the worker pool, these + // requests would time out. + // ------------------------------------------------------------------------- + constexpr int kFastClients = 4; + constexpr int kFastCommandsPerClient = 20; + std::atomic fast_failures{0}; + std::atomic fast_successes{0}; + + auto fast_client_task = [&]() { + int s = Connect(port); + if (s < 0) { + fast_failures.fetch_add(1, std::memory_order_relaxed); + return; + } + for (int i = 0; i < kFastCommandsPerClient; ++i) { + if (!SendLine(s, "INFO")) { + fast_failures.fetch_add(1, std::memory_order_relaxed); + close(s); + return; + } + std::string resp = RecvMultilineResponse(s, /*timeout_ms=*/2000); + if (resp.empty() || resp.substr(0, 7) != "OK INFO") { + fast_failures.fetch_add(1, std::memory_order_relaxed); + close(s); + return; + } + fast_successes.fetch_add(1, std::memory_order_relaxed); + } + close(s); + }; + + std::vector fast_threads; + fast_threads.reserve(kFastClients); + for (int i = 0; i < kFastClients; ++i) fast_threads.emplace_back(fast_client_task); + for (auto& t : fast_threads) t.join(); + + // Invariant: every fast client request must have succeeded. + EXPECT_EQ(fast_failures.load(), 0) + << fast_failures.load() << " fast-client failures while slow reader was " + << "backpressured; reactor should have isolated the slow reader but did not"; + EXPECT_EQ(fast_successes.load(), kFastClients * kFastCommandsPerClient); + + // The slow reader should eventually be force-closed by the reactor once + // its write queue exceeds 64 KiB. We detect this by draining the + // client-side kernel recv buffer until recv() returns 0 (FIN) or + // errors out. The drop-on-shutdown is essentially instant from the + // reactor's perspective, but the client still has to consume any bytes + // that were sent BEFORE the cap fired — so we drain aggressively with a + // large buffer so the FIN shows up within the deadline. + auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5); + bool slow_closed = false; + while (std::chrono::steady_clock::now() < deadline) { + std::array drain{}; + ssize_t n = recv(slow, drain.data(), drain.size(), MSG_DONTWAIT); + if (n == 0) { + slow_closed = true; // FIN observed after draining + break; + } + if (n < 0) { + if (errno == EAGAIN || errno == EWOULDBLOCK) { + // Kernel buffer empty but the server hasn't closed yet. Sleep + // briefly and recheck. + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + continue; + } + slow_closed = true; // ECONNRESET / EBADF / etc. + break; + } + // n > 0: we just drained a chunk; loop immediately to keep going + // until the buffer is empty and FIN shows up. + } + + EXPECT_TRUE(slow_closed) + << "Slow reader was never force-closed by the reactor within 5s " + << "despite piling up responses against a 64 KiB write queue cap"; + + close(slow); + server->Stop(); +} + +// ============================================================================ +// Test 13 — G1 goal: many idle persistent clients + 1 active (LOAD) +// ============================================================================ + +/** + * Design-doc §3.1 G1: with a small worker pool and a large number of idle + * persistent connections, a newly-arriving active client must be served in + * well under 500 ms. This is the Phase 3 upgrade of + * `ReactorServesPersistentFleetWithoutStarvation`: instead of 128 idle + * clients, this test pushes the scale up to the per-process fd budget. + * + * Tagged as LOAD because it stresses RLIMIT_NOFILE and may take noticeably + * longer than the other reactor tests. Skipped if the fd budget cannot + * accommodate at least 512 persistent clients. + */ +TEST_F(ReactorIntegrationTest, ManyIdleConnectionsDoNotBlockActiveClient) { + constexpr rlim_t kDesiredFds = 4096; + // Target: as many idle clients as the fd budget allows, up to 2048. + // The design doc targets 10k; most CI runners can't provide that many + // fds, so we scale to whatever is available and still prove the + // invariant. + constexpr int kTargetIdleClients = 2048; + constexpr int kMinIdleClientsToRun = 256; + + rlim_t effective = RaiseFdLimit(kDesiredFds); + // Reserve ~128 fds for the test process / server / leak headroom, and + // each idle client needs ~2 fds (client side + server side). + int idle_count = std::min(kTargetIdleClients, static_cast((effective - 128) / 2)); + if (idle_count < kMinIdleClientsToRun) { + GTEST_SKIP() << "RLIMIT_NOFILE too small (" << effective + << ") for the G1 starvation test; re-run with ulimit -n 4096 " + << "to exercise the many-idle-clients invariant"; + } + + // Small worker pool: the whole point of the reactor refactor is that the + // worker count does NOT have to scale with the idle-connection count. + constexpr int kWorkers = 8; + auto server = StartServer(kWorkers, /*max_connections=*/static_cast(idle_count + 64)); + RequireReactor(*server); + uint16_t port = server->GetPort(); + + // Open idle_count persistent clients: each sends one INFO to prove the + // round-trip works, drains the full multi-line response, and then goes + // completely idle (no more sends, no more recvs). + std::vector idle_socks; + idle_socks.reserve(idle_count); + for (int i = 0; i < idle_count; ++i) { + int s = Connect(port, /*timeout_ms=*/2000); + if (s < 0) { + // Couldn't open all the sockets we wanted; run with what we got if + // we still have at least kMinIdleClientsToRun. + if (static_cast(idle_socks.size()) >= kMinIdleClientsToRun) break; + GTEST_SKIP() << "Failed to open idle client " << i << "; fd budget exhausted"; + } + if (!SendLine(s, "INFO")) { + close(s); + continue; + } + std::string resp = RecvMultilineResponse(s, /*timeout_ms=*/3000); + if (resp.empty() || resp.substr(0, 7) != "OK INFO") { + close(s); + continue; + } + idle_socks.push_back(s); + } + + std::cout << "[ManyIdleConnectionsDoNotBlockActiveClient] " + << "idle_clients=" << idle_socks.size() << " workers=" << kWorkers + << " rlimit=" << effective << std::endl; + ASSERT_GE(static_cast(idle_socks.size()), kMinIdleClientsToRun) + << "Not enough idle clients opened to meaningfully stress the server"; + + // Give the reactor a moment to re-arm kReadable on all idle fds. + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + + // Active client: send INFO and expect a response within 500 ms. Under + // the reactor I/O model the idle clients do not consume worker threads, + // so the active client is served by a free worker immediately. + int active = Connect(port); + ASSERT_GE(active, 0); + ASSERT_TRUE(SendLine(active, "INFO")); + + auto t0 = std::chrono::steady_clock::now(); + std::string resp = RecvMultilineResponse(active, /*timeout_ms=*/500); + auto elapsed_ms = std::chrono::duration_cast( + std::chrono::steady_clock::now() - t0) + .count(); + + EXPECT_FALSE(resp.empty()) + << "Active client starved with " << idle_socks.size() + << " idle persistent connections — the G1 invariant failed"; + if (!resp.empty()) { + EXPECT_EQ(resp.substr(0, 7), "OK INFO"); + EXPECT_LT(elapsed_ms, 500) + << "Active client responded but took " << elapsed_ms << "ms (>500ms) with " + << idle_socks.size() << " idle persistent connections"; + } + + close(active); + for (int s : idle_socks) close(s); + server->Stop(); +} + +} // namespace mygramdb::server + +#endif // platform guard diff --git a/tests/integration/server/reactor_starvation_regression_test.cpp b/tests/integration/server/reactor_starvation_regression_test.cpp new file mode 100644 index 0000000..54b16cb --- /dev/null +++ b/tests/integration/server/reactor_starvation_regression_test.cpp @@ -0,0 +1,574 @@ +/** + * @file reactor_starvation_regression_test.cpp + * @brief Phase 2.T7 — GOAL test: reactor mode must NOT exhibit the blocking + * I/O model's starvation failure. + * + * The blocking I/O model pins one worker thread per persistent TCP connection. + * When the number of idle persistent clients >= worker pool size, no newly- + * submitted task makes progress until a pinned recv() idle timeout fires. + * In production this manifested as queue full + 5xx cascades. + * + * The reactor I/O model (Phase 2) replaces this with an epoll/kqueue event + * loop + drain-task-per-connection workers, decoupling the concurrent-client + * count from the worker pool size. These tests prove the replacement works. + * + * Test 1 (positive control): reactor mode with 128 persistent clients + 1 late + * client, worker_threads=2 — late client MUST get a response within 500 ms. + * Test 2 (throughput): 256 persistent clients each sending 10 INFO requests — + * no ERR SERVER_BUSY, all responses are OK INFO. + * Test 3 (negative control): blocking mode with 8 idle clients, worker_threads=2 + * — late client MUST NOT get a response within 1.5 s. + * + * Labeled "INTEGRATION" — runs via `ctest -L INTEGRATION`. + * RESOURCE_LOCK "server_port" — each test binds a real OS port. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "config/config.h" +#include "index/index.h" +#include "server/server_types.h" +#include "server/tcp_server.h" +#include "storage/document_store.h" + +namespace mygramdb::server { + +// --------------------------------------------------------------------------- +// Shared test fixture +// --------------------------------------------------------------------------- +class ReactorStarvationRegressionTest : public ::testing::Test { + protected: + void SetUp() override { + // Raise fd limit to accommodate 256+ client sockets plus server-side fds. + effective_fd_limit_ = RaiseFdLimit(4096); + + auto index = std::make_unique(2, 1); + auto doc_store = std::make_unique(); + table_ctx_ = std::make_unique(TableContext{ + .name = "t", + .config = config::TableConfig{}, + .index = std::move(index), + .doc_store = std::move(doc_store), + }); + table_contexts_["t"] = table_ctx_.get(); + } + + void TearDown() override { + table_contexts_.clear(); + table_ctx_.reset(); + } + + // ------------------------------------------------------------------------- + // Socket helpers (mirrored from ThreadPoolSaturationTest for isolation) + // ------------------------------------------------------------------------- + + /** + * @brief Connect to 127.0.0.1:port with a non-blocking connect + select. + * @return socket fd, or -1 on failure. + */ + int Connect(uint16_t port, int timeout_ms = 2000) { + int sock = socket(AF_INET, SOCK_STREAM, 0); + if (sock < 0) { + return -1; + } + + int flags = fcntl(sock, F_GETFL, 0); + if (flags >= 0) { + fcntl(sock, F_SETFL, flags | O_NONBLOCK); + } + + struct sockaddr_in addr{}; + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr); + + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API + int rc = connect(sock, reinterpret_cast(&addr), sizeof(addr)); + if (rc < 0 && errno != EINPROGRESS) { + close(sock); + return -1; + } + + if (rc < 0) { + fd_set ws; + FD_ZERO(&ws); + FD_SET(sock, &ws); + struct timeval tv{}; + tv.tv_sec = timeout_ms / 1000; + tv.tv_usec = (timeout_ms % 1000) * 1000; + int ready = select(sock + 1, nullptr, &ws, nullptr, &tv); + if (ready <= 0) { + close(sock); + return -1; + } + int so_err = 0; + socklen_t len = sizeof(so_err); + if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &so_err, &len) < 0 || so_err != 0) { + close(sock); + return -1; + } + } + + // Restore blocking mode after connect + if (flags >= 0) { + fcntl(sock, F_SETFL, flags); + } + return sock; + } + + bool SendLine(int sock, const std::string& line) { + std::string msg = line + "\r\n"; + ssize_t sent = send(sock, msg.data(), msg.size(), 0); + return sent == static_cast(msg.size()); + } + + /** + * @brief Read a full multi-line response ending in `\r\nEND\r\n`. + * + * INFO, SEARCH and friends are multi-line: the response body contains + * internal `\r\n` separators and ends with `\r\nEND\r\n`. A simple + * read-until-first-CRLF helper would truncate at "OK INFO" and leave the + * rest of the response in the kernel socket buffer, corrupting any + * subsequent read on the same connection. + * + * Returns the full response bytes (including internal CRLFs and the + * trailing `\r\nEND\r\n`), or empty string on timeout / peer close. + */ + std::string RecvMultilineResponse(int sock, int timeout_ms = 5000) { + struct timeval tv{}; + tv.tv_sec = timeout_ms / 1000; + tv.tv_usec = (timeout_ms % 1000) * 1000; + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + + static constexpr const char kTerminator[] = "\r\nEND\r\n"; + static constexpr size_t kTerminatorLen = 7; + + std::string out; + std::array buf{}; + while (out.size() < 1 * 1024 * 1024) { + ssize_t n = recv(sock, buf.data(), buf.size(), 0); + if (n <= 0) { + return ""; + } + out.append(buf.data(), static_cast(n)); + if (out.size() >= kTerminatorLen && + out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { + return out; + } + } + return ""; + } + + /** + * @brief Read a single-line response (no internal CRLFs) terminated by `\r\n`. + * + * Used by the blocking-mode negative control test, where the late client + * must receive NO response at all — so we only need to observe the empty + * string return on timeout. + */ + std::string RecvLine(int sock, int timeout_ms = 2000) { + struct timeval tv{}; + tv.tv_sec = timeout_ms / 1000; + tv.tv_usec = (timeout_ms % 1000) * 1000; + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + + std::string out; + std::array buf{}; + while (out.size() < 8192) { + ssize_t n = recv(sock, buf.data(), buf.size(), 0); + if (n <= 0) { + return ""; + } + out.append(buf.data(), static_cast(n)); + if (out.find("\r\n") != std::string::npos) { + break; + } + } + auto pos = out.find("\r\n"); + if (pos != std::string::npos) { + out.resize(pos); + } + return out; + } + + // ------------------------------------------------------------------------- + // Server factory + // ------------------------------------------------------------------------- + std::unique_ptr StartServer(const std::string& io_model, int worker_threads, + int max_connections = 512) { + ServerConfig cfg; + cfg.host = "127.0.0.1"; + cfg.port = 0; + cfg.worker_threads = worker_threads; + cfg.max_connections = max_connections; + cfg.io_model = io_model; + cfg.allow_cidrs = {"127.0.0.1/32"}; + // Disable recv timeout so idle persistent clients don't self-terminate + // during the test; the starvation window is deliberately short. + cfg.recv_timeout_sec = 0; + auto s = std::make_unique(cfg, table_contexts_); + auto res = s->Start(); + EXPECT_TRUE(res) << "Failed to start TcpServer (" << io_model + << "): " << (res ? std::string{} : res.error().to_string()); + // Give the accept loop a moment to reach its main select/epoll/kqueue call. + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + return s; + } + + // ------------------------------------------------------------------------- + // FD limit helper + // ------------------------------------------------------------------------- + static rlim_t RaiseFdLimit(rlim_t desired) { + struct rlimit rl{}; + if (getrlimit(RLIMIT_NOFILE, &rl) != 0) { + return 0; + } + rlim_t target = std::min(desired, rl.rlim_max); + if (rl.rlim_cur < target) { + rl.rlim_cur = target; + setrlimit(RLIMIT_NOFILE, &rl); // Best-effort + getrlimit(RLIMIT_NOFILE, &rl); + } + return rl.rlim_cur; + } + + // ------------------------------------------------------------------------- + // State + // ------------------------------------------------------------------------- + rlim_t effective_fd_limit_{0}; + std::unique_ptr table_ctx_; + std::unordered_map table_contexts_; +}; + +// --------------------------------------------------------------------------- +// Test 1 — Positive control: reactor serves 128 persistent clients without +// starving a late client (worker_threads = 2). +// --------------------------------------------------------------------------- +/** + * Pin 128 persistent idle clients against a 2-worker reactor server. + * In the blocking model this is impossible: only 2 clients would ever reach + * a worker. In reactor mode the event loop dispatches all 128 initial INFO + * responses, and the 129th (late) client still gets a reply within 500 ms. + */ +TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarvation) { + // Need at least 256 fds: 128 pinned + 1 late + server-side fds + overhead. + constexpr int kNeededFds = 256; + // RLIM_INFINITY means unlimited; only skip when we have a real hard cap below what we need. + if (effective_fd_limit_ != RLIM_INFINITY && effective_fd_limit_ < static_cast(kNeededFds)) { + GTEST_SKIP() << "RLIMIT_NOFILE=" << effective_fd_limit_ << " < " << kNeededFds + << " — cannot open enough client sockets. Run with ulimit -n 4096."; + } + + constexpr int kWorkers = 2; + constexpr int kPinnedClients = 128; + auto server = StartServer("reactor", kWorkers, /*max_connections=*/512); + uint16_t port = server->GetPort(); + + // Skip if the reactor backend is not available on this platform. + if (!server->IsReactorActiveForTest()) { + server->Stop(); + GTEST_SKIP() << "Reactor backend not available on this platform (fell back to " + "blocking mode). Skipping reactor-specific test."; + } + + // --- Pin kPinnedClients persistent idle clients --- + // Each sends INFO once (to exercise the reactor's drain path), then idles. + // In blocking mode the 3rd client onward would not get a response at all. + std::vector pinned; + pinned.reserve(kPinnedClients); + int pin_failures = 0; + + for (int i = 0; i < kPinnedClients; ++i) { + int s = Connect(port); + if (s < 0) { + ++pin_failures; + continue; + } + if (!SendLine(s, "INFO")) { + close(s); + ++pin_failures; + continue; + } + pinned.push_back(s); + } + + if (pin_failures > 0) { + for (int s : pinned) close(s); + server->Stop(); + GTEST_SKIP() << "Could only open " << pinned.size() << " of " << kPinnedClients + << " pinned client sockets (fd budget?). Skipping."; + } + + // Drain the initial INFO responses for all pinned clients in parallel. + // Serial draining would take kPinnedClients * timeout_ms worst-case; + // parallel draining bounds the total wait to one timeout window. + std::atomic pinned_ok{0}; + { + std::vector drain_threads; + drain_threads.reserve(pinned.size()); + for (int s : pinned) { + drain_threads.emplace_back([this, s, &pinned_ok]() { + std::string resp = RecvMultilineResponse(s, /*timeout_ms=*/5000); + if (resp.size() >= 7 && resp.substr(0, 7) == "OK INFO") { + pinned_ok.fetch_add(1, std::memory_order_relaxed); + } + }); + } + for (auto& t : drain_threads) { + t.join(); + } + } + + EXPECT_EQ(pinned_ok.load(), kPinnedClients) + << "Only " << pinned_ok.load() << " of " << kPinnedClients + << " pinned clients received their initial INFO response. " + "The reactor event loop did not dispatch all connections."; + + // All pinned clients are now idle (last recv() returned, no new send). + // In blocking mode the workers would be idle-looping in recv() for each. + // In reactor mode the workers are free; the event loop is the only thing + // monitoring those fds. + + // --- Late client --- + int late = Connect(port); + ASSERT_GE(late, 0) << "Failed to connect late client"; + ASSERT_TRUE(SendLine(late, "INFO")); + + auto t0 = std::chrono::steady_clock::now(); + std::string late_resp = RecvMultilineResponse(late, /*timeout_ms=*/500); + auto elapsed_ms = + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) + .count(); + + // --- Assertions --- + EXPECT_FALSE(late_resp.empty()) + << "Late client received no response within 500 ms despite reactor mode " + "being active. Starvation regression: reactor is not decoupling " + "worker count from persistent-client count."; + + if (!late_resp.empty()) { + EXPECT_EQ(late_resp.substr(0, 7), "OK INFO") + << "Late client response was not OK INFO: " << late_resp; + EXPECT_LT(elapsed_ms, 500) + << "Late client responded (" << late_resp << ") but took " << elapsed_ms + << "ms (> 500ms limit)."; + + std::cout << "[T1] late_client_latency_ms=" << elapsed_ms << " pinned_ok=" << pinned_ok.load() + << " workers=" << kWorkers << std::endl; + } + + // Cleanup + close(late); + for (int s : pinned) close(s); + server->Stop(); +} + +// --------------------------------------------------------------------------- +// Test 2 — Throughput: 256 persistent clients × 10 INFO requests, no +// ERR SERVER_BUSY, all responses are "OK INFO". +// --------------------------------------------------------------------------- +/** + * Open 256 connections and send 10 sequential INFO requests on each. With + * only 2 worker threads in blocking mode this would deadlock immediately. + * In reactor mode the event loop processes reads and dispatches drain tasks + * back-to-back on the small pool, and all 2560 responses arrive correctly. + */ +TEST_F(ReactorStarvationRegressionTest, ReactorHighConcurrencyShowsNoQueueFull) { + // 256 client fds + server-side fds + overhead. + constexpr int kNeededFds = 256; + if (effective_fd_limit_ != RLIM_INFINITY && effective_fd_limit_ < static_cast(kNeededFds)) { + GTEST_SKIP() << "RLIMIT_NOFILE=" << effective_fd_limit_ << " < " << kNeededFds + << " — cannot open enough client sockets."; + } + + constexpr int kWorkers = 2; + // Scaled down to 128 (from 256) to fit within macOS soft RLIMIT_NOFILE=256 + // (128 client fds + 128 server-side fds + overhead stays within 256). + constexpr int kClients = 128; + constexpr int kRequestsPerClient = 10; + constexpr int kExpectedTotal = kClients * kRequestsPerClient; + + auto server = StartServer("reactor", kWorkers, /*max_connections=*/512); + uint16_t port = server->GetPort(); + + if (!server->IsReactorActiveForTest()) { + server->Stop(); + GTEST_SKIP() << "Reactor backend not available on this platform."; + } + + // Open kClients connections. + std::vector clients; + clients.reserve(kClients); + for (int i = 0; i < kClients; ++i) { + int s = Connect(port); + if (s < 0) break; + clients.push_back(s); + } + + if (static_cast(clients.size()) < kClients) { + for (int s : clients) close(s); + server->Stop(); + GTEST_SKIP() << "Could only open " << clients.size() << " of " << kClients + << " client sockets (fd budget?)."; + } + + // Snapshot request counter before the burst. + uint64_t reqs_before = server->GetStats().GetTotalRequests(); + + // Each client sends kRequestsPerClient INFO requests sequentially. + // We use threads so that the clients exercise the reactor concurrently. + std::atomic total_ok{0}; + std::atomic total_busy{0}; + std::atomic total_error{0}; + + std::vector threads; + threads.reserve(clients.size()); + + for (int i = 0; i < static_cast(clients.size()); ++i) { + threads.emplace_back([&, i]() { + int s = clients[static_cast(i)]; + for (int j = 0; j < kRequestsPerClient; ++j) { + if (!SendLine(s, "INFO")) { + total_error.fetch_add(1, std::memory_order_relaxed); + return; + } + std::string resp = RecvMultilineResponse(s, /*timeout_ms=*/5000); + if (resp.empty()) { + total_error.fetch_add(1, std::memory_order_relaxed); + return; + } + if (resp.find("ERR SERVER_BUSY") != std::string::npos) { + total_busy.fetch_add(1, std::memory_order_relaxed); + } else if (resp.size() >= 7 && resp.substr(0, 7) == "OK INFO") { + total_ok.fetch_add(1, std::memory_order_relaxed); + } else { + total_error.fetch_add(1, std::memory_order_relaxed); + } + } + }); + } + + for (auto& t : threads) { + t.join(); + } + + uint64_t reqs_after = server->GetStats().GetTotalRequests(); + + std::cout << "[T2] total_ok=" << total_ok.load() << " total_busy=" << total_busy.load() + << " total_error=" << total_error.load() + << " stat_requests_delta=" << (reqs_after - reqs_before) << std::endl; + + // --- Assertions --- + EXPECT_EQ(total_busy.load(), 0) + << "Reactor mode sent ERR SERVER_BUSY " << total_busy.load() + << " times. The worker pool should not saturate when the reactor is active."; + + EXPECT_EQ(total_ok.load(), kExpectedTotal) + << "Expected " << kExpectedTotal << " OK INFO responses but got " << total_ok.load() + << " (errors=" << total_error.load() << ", busy=" << total_busy.load() << ")."; + + EXPECT_GE(reqs_after - reqs_before, static_cast(kExpectedTotal)) + << "Server stats counted fewer total requests than expected."; + + // Cleanup + for (int s : clients) close(s); + server->Stop(); +} + +// --------------------------------------------------------------------------- +// Test 3 — Negative control: blocking mode starves under the same load. +// --------------------------------------------------------------------------- +/** + * Pin 8 idle persistent clients against a 2-worker BLOCKING server. + * The late client's INFO MUST NOT arrive within 1.5 s, proving that the + * starvation mechanism is real and the reactor test is discriminating. + * + * If this test ever starts failing (blocking mode becomes responsive), either + * (a) the thread pool was enlarged beyond the pinned-client count, or + * (b) the blocking model was silently replaced with a reactor. Either way, + * the discriminating property of Test 1 is no longer valid and both tests + * need to be reviewed. + */ +TEST_F(ReactorStarvationRegressionTest, BlockingModeStarvesUnderSameLoad) { + constexpr int kWorkers = 2; + constexpr int kPinnedClients = 8; // > kWorkers → guaranteed starvation + + auto server = StartServer("blocking", kWorkers, /*max_connections=*/512); + uint16_t port = server->GetPort(); + + // The blocking model must be engaged; if somehow the reactor activated, + // skip rather than give a false-green result. + if (server->IsReactorActiveForTest()) { + server->Stop(); + GTEST_SKIP() << "Reactor is active even though io_model=blocking was requested. " + "Blocking-mode negative control is not valid in this configuration."; + } + + // --- Pin kPinnedClients persistent idle clients --- + std::vector pinned; + pinned.reserve(kPinnedClients); + for (int i = 0; i < kPinnedClients; ++i) { + int s = Connect(port); + ASSERT_GE(s, 0) << "Failed to connect pinning client " << i; + ASSERT_TRUE(SendLine(s, "INFO")); + // Receive the first response (this uses one worker during HandleConnection + // setup; the worker then loops back into blocking recv()). + std::string resp = RecvLine(s, /*timeout_ms=*/2000); + // Only the first kWorkers clients will actually get a response; the rest + // will time out because all workers are pinned. Accept either outcome — + // the important assertion is on the late client below. + (void)resp; + pinned.push_back(s); + } + + // Give workers time to return to their blocking recv() loops. + std::this_thread::sleep_for(std::chrono::milliseconds(300)); + + // --- Late client --- + int late = Connect(port); + ASSERT_GE(late, 0) << "Failed to connect late client"; + ASSERT_TRUE(SendLine(late, "INFO")); + + auto t0 = std::chrono::steady_clock::now(); + std::string resp = RecvLine(late, /*timeout_ms=*/1500); + auto elapsed_ms = + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) + .count(); + + // This is the permanent regression gate. If this assertion ever fails, the + // blocking connection model has been replaced and Test 1 + Test 2 above are + // the definitive PASS criteria. + EXPECT_TRUE(resp.empty()) + << "Blocking-mode late INFO was served in " << elapsed_ms + << "ms despite all " << kWorkers + << " workers being pinned by " << kPinnedClients + << " idle persistent clients. Has the connection-per-worker model been " + "replaced? If so, update the negative control to expect success."; + + std::cout << "[T3] blocking_late_client_elapsed_ms=" << elapsed_ms + << " (expected: no response within 1500ms)" << std::endl; + + close(late); + for (int s : pinned) close(s); + server->Stop(); +} + +} // namespace mygramdb::server diff --git a/tests/integration/server/test_io_model_override.h b/tests/integration/server/test_io_model_override.h new file mode 100644 index 0000000..f9bf643 --- /dev/null +++ b/tests/integration/server/test_io_model_override.h @@ -0,0 +1,48 @@ +/** + * @file test_io_model_override.h + * @brief Shared helper for dual-mode CI: lets integration tests pick up an + * `io_model` override from the environment at runtime. + * + * Design doc Phase 2.6 (deferred to Phase 3): we want the same integration + * test binary to be exercised under both `io_model=reactor` (the Phase 3 + * default) and `io_model=blocking` (the fallback). Rather than duplicate + * the test fixtures, the test reads `MYGRAMDB_TEST_IO_MODEL` once at setup + * and applies it to its `ServerConfig`. CMake registers a second ctest + * entry per test binary with that environment variable set to "blocking", + * giving us "two runs, one binary". + * + * Usage in a test fixture's SetUp(): + * + * ServerConfig config_; + * mygramdb::server::test::ApplyIoModelOverride(config_); + * // ... rest of setup ... + */ +#pragma once + +#include +#include + +#include "server/server_types.h" + +namespace mygramdb::server::test { + +/** + * @brief Apply the `MYGRAMDB_TEST_IO_MODEL` environment variable to the + * given `ServerConfig`, if set. + * + * Recognised values: "reactor", "blocking". Any other value is ignored + * (the config's existing io_model is left untouched). If the environment + * variable is unset the function is a no-op. + */ +inline void ApplyIoModelOverride(ServerConfig& config) { + const char* env = std::getenv("MYGRAMDB_TEST_IO_MODEL"); + if (env == nullptr) { + return; + } + const std::string value(env); + if (value == "reactor" || value == "blocking") { + config.io_model = value; + } +} + +} // namespace mygramdb::server::test diff --git a/tests/integration/server/thread_pool_saturation_test.cpp b/tests/integration/server/thread_pool_saturation_test.cpp new file mode 100644 index 0000000..59aee8a --- /dev/null +++ b/tests/integration/server/thread_pool_saturation_test.cpp @@ -0,0 +1,510 @@ +/** + * @file thread_pool_saturation_test.cpp + * @brief Regression tests anchoring the thread-pool / I/O-model invariants. + * + * Historical context: under the legacy blocking I/O model, + * ConnectionIOHandler::HandleConnection() held one worker thread for the + * entire lifetime of a client connection. With a small worker pool, + * idle-but-persistent clients could pin every worker, at which point newly + * accepted connections piled up in the task queue until it overflowed and + * the acceptor began writing "ERR SERVER_BUSY" + close() on new sockets. + * + * After the Phase 3 reactor refactor, the default I/O model is "reactor", + * so persistent idle connections no longer pin workers at all. The tests + * below therefore split into two groups: + * + * 1. Reactor-default invariants (no forced io_model): verify the new + * default model serves late clients promptly even when the worker + * pool is tiny and many persistent clients are holding connections. + * 2. Blocking-mode legacy invariants (explicit io_model="blocking"): + * preserve the original starvation and queue-overflow regression + * gates for the fallback/rollback I/O model. These still matter + * because operators can flip back to blocking mode via YAML, and the + * blocking path is not going away until Phase 4. + * + * Labeled "LOAD" — excluded from `make test-fast` / CI and only run via + * `make test-load` or `ctest -L LOAD`. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "config/config.h" +#include "index/index.h" +#include "server/server_types.h" +#include "server/tcp_server.h" +#include "storage/document_store.h" + +namespace mygramdb::server { + +class ThreadPoolSaturationTest : public ::testing::Test { + protected: + void SetUp() override { + auto index = std::make_unique(2, 1); + auto doc_store = std::make_unique(); + table_ctx_ = std::make_unique(TableContext{ + .name = "t", + .config = config::TableConfig{}, + .index = std::move(index), + .doc_store = std::move(doc_store), + }); + table_contexts_["t"] = table_ctx_.get(); + } + + void TearDown() override { + table_contexts_.clear(); + table_ctx_.reset(); + } + + /** + * @brief Connect to 127.0.0.1:port with a bounded timeout. + * @return socket fd on success, -1 on failure. + */ + int Connect(uint16_t port, int timeout_ms = 1000) { + int sock = socket(AF_INET, SOCK_STREAM, 0); + if (sock < 0) { + return -1; + } + + int flags = fcntl(sock, F_GETFL, 0); + if (flags >= 0) { + fcntl(sock, F_SETFL, flags | O_NONBLOCK); + } + + struct sockaddr_in addr {}; + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr); + + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API + int rc = connect(sock, reinterpret_cast(&addr), sizeof(addr)); + if (rc < 0 && errno != EINPROGRESS) { + close(sock); + return -1; + } + + if (rc < 0) { + fd_set ws; + FD_ZERO(&ws); + FD_SET(sock, &ws); + struct timeval tv {}; + tv.tv_sec = timeout_ms / 1000; + tv.tv_usec = (timeout_ms % 1000) * 1000; + int ready = select(sock + 1, nullptr, &ws, nullptr, &tv); + if (ready <= 0) { + close(sock); + return -1; + } + int so_err = 0; + socklen_t len = sizeof(so_err); + if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &so_err, &len) < 0 || so_err != 0) { + close(sock); + return -1; + } + } + + if (flags >= 0) { + fcntl(sock, F_SETFL, flags); + } + struct timeval io {}; + io.tv_sec = 2; + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); + setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &io, sizeof(io)); + return sock; + } + + bool SendLine(int sock, const std::string& line) { + std::string msg = line + "\r\n"; + ssize_t sent = send(sock, msg.data(), msg.size(), 0); + return sent == static_cast(msg.size()); + } + + /** + * @brief Read one \r\n-terminated response within timeout_ms. + * @return response body without the trailing CRLF, or empty string on + * timeout/error. + */ + std::string RecvLine(int sock, int timeout_ms = 2000) { + struct timeval io {}; + io.tv_sec = timeout_ms / 1000; + io.tv_usec = (timeout_ms % 1000) * 1000; + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); + + std::string out; + std::array buf{}; + while (out.size() < 4096) { + ssize_t n = recv(sock, buf.data(), buf.size(), 0); + if (n <= 0) { + return ""; + } + out.append(buf.data(), n); + if (out.find("\r\n") != std::string::npos) { + break; + } + } + auto pos = out.find("\r\n"); + if (pos != std::string::npos) { + out.resize(pos); + } + return out; + } + + std::unique_ptr StartServer(int worker_threads, int max_connections = 256, + const std::string& io_model = std::string{}) { + ServerConfig cfg; + cfg.host = "127.0.0.1"; + cfg.port = 0; + cfg.worker_threads = worker_threads; + cfg.max_connections = max_connections; + cfg.allow_cidrs = {"127.0.0.1/32"}; + if (!io_model.empty()) { + cfg.io_model = io_model; + } + auto s = std::make_unique(cfg, table_contexts_); + auto res = s->Start(); + EXPECT_TRUE(res) << "Failed to start TcpServer: " + << (res ? std::string{} : res.error().to_string()); + // Give the accept loop a moment to reach its main loop. + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + return s; + } + + /** + * @brief Try to raise the per-process FD limit (for the queue-overflow + * test which opens >1000 sockets). Returns the effective cap. + */ + static rlim_t RaiseFdLimit(rlim_t desired) { + struct rlimit rl {}; + if (getrlimit(RLIMIT_NOFILE, &rl) != 0) { + return 0; + } + rlim_t target = std::min(desired, rl.rlim_max); + if (rl.rlim_cur < target) { + rl.rlim_cur = target; + setrlimit(RLIMIT_NOFILE, &rl); // Best-effort + getrlimit(RLIMIT_NOFILE, &rl); + } + return rl.rlim_cur; + } + + std::unique_ptr table_ctx_; + std::unordered_map table_contexts_; +}; + +/** + * Phase 3 inversion of the historical starvation gate. + * + * Under the legacy blocking I/O model this test asserted that a late client + * could NOT be served when idle persistent clients had pinned every worker + * thread. Phase 3 makes "reactor" the default I/O model (see + * ApiConfig::tcp::io_model), and in that model persistent idle connections + * live in the epoll/kqueue registration map rather than parking worker + * threads. The assertion therefore flips: with the default I/O model, a + * late client MUST be served promptly even when `worker_threads` is tiny + * and matches (or is below) the idle-persistent-client count. + * + * If this test ever starts failing, the reactor no longer decouples + * connection lifetime from worker lifetime — which would be a Phase 3 + * regression. The corresponding negative control (blocking mode STILL + * starves under the same load) lives in + * `tests/integration/server/reactor_starvation_regression_test.cpp`. + */ +TEST_F(ThreadPoolSaturationTest, LateClientServedDespitePinnedIdleClientsInDefaultMode) { + // Intentionally tiny worker pool to make the "workers == idle clients" + // corner case trivially reachable. Under reactor mode this is fine — the + // event loop handles reads and workers only run briefly per command. + constexpr int kWorkers = 2; + auto server = StartServer(kWorkers); // default io_model = reactor + uint16_t port = server->GetPort(); + + // Open kWorkers idle persistent clients. Each issues one INFO and then + // sits quietly, just as the production starvation scenario did. + std::vector pinned; + pinned.reserve(kWorkers); + for (int i = 0; i < kWorkers; ++i) { + int s = Connect(port); + ASSERT_GE(s, 0) << "Failed to open pinning client " << i; + ASSERT_TRUE(SendLine(s, "INFO")); + std::string resp = RecvLine(s); + ASSERT_EQ(resp.substr(0, 7), "OK INFO") + << "Pinning client " << i << " did not receive INFO reply; got: " << resp; + pinned.push_back(s); + } + + // Give the reactor a moment to re-arm kReadable for the pinned clients. + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + + // Late client: should be served immediately under reactor mode. Under + // the old blocking model this was impossible and the request would time + // out; the inversion is deliberate. + int late = Connect(port); + ASSERT_GE(late, 0); + ASSERT_TRUE(SendLine(late, "INFO")); + + auto t0 = std::chrono::steady_clock::now(); + std::string resp = RecvLine(late, /*timeout_ms=*/1500); + auto elapsed_ms = + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) + .count(); + + EXPECT_FALSE(resp.empty()) + << "Late INFO was NOT served under the default (reactor) I/O model " + "even though the worker pool was small and all persistent clients " + "were idle. This is the Phase 3 invariant — if it fails, the " + "reactor refactor has regressed."; + if (!resp.empty()) { + EXPECT_EQ(resp.substr(0, 7), "OK INFO"); + EXPECT_LT(elapsed_ms, 500) + << "Late client was served but took " << elapsed_ms + << "ms (>500ms). Reactor latency degraded?"; + } + + close(late); + for (int s : pinned) { + close(s); + } + server->Stop(); +} + +/** + * Blocking-mode legacy invariant. + * + * Forces io_model="blocking" so the worker-count mitigation lever is + * exercised against its original failure mode. With a generously-sized + * blocking thread pool, the same client pattern that normally starves + * under io_model=blocking does NOT starve, confirming that + * `api.tcp.worker_threads` remains a usable emergency lever for operators + * who have reverted to the blocking I/O model for any reason. + */ +TEST_F(ThreadPoolSaturationTest, LargerThreadPoolRemovesStarvationInBlockingMode) { + constexpr int kWorkers = 64; + auto server = StartServer(kWorkers, /*max_connections=*/256, /*io_model=*/"blocking"); + uint16_t port = server->GetPort(); + + // Pin 4 persistent clients — well below kWorkers so there should be plenty + // of slack to serve the late client immediately. + std::vector pinned; + for (int i = 0; i < 4; ++i) { + int s = Connect(port); + ASSERT_GE(s, 0); + ASSERT_TRUE(SendLine(s, "INFO")); + ASSERT_EQ(RecvLine(s).substr(0, 7), "OK INFO"); + pinned.push_back(s); + } + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + + int late = Connect(port); + ASSERT_GE(late, 0); + ASSERT_TRUE(SendLine(late, "INFO")); + + auto t0 = std::chrono::steady_clock::now(); + std::string resp = RecvLine(late, /*timeout_ms=*/1500); + auto elapsed_ms = + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) + .count(); + + EXPECT_FALSE(resp.empty()) << "Late client starved even with worker_threads=" << kWorkers; + EXPECT_EQ(resp.substr(0, 7), "OK INFO"); + EXPECT_LT(elapsed_ms, 500) + << "Late client responded but took " << elapsed_ms << "ms (>500ms)"; + + close(late); + for (int s : pinned) { + close(s); + } + server->Stop(); +} + +/** + * Regression test for the default auto-sized thread pool under the + * default (reactor) I/O model. + * + * With the Phase 3 defaults (`io_model=reactor`, `worker_threads=0` → + * auto-size = max(hw*2, 4)), persistent idle clients do NOT pin workers — + * they live in the reactor's connection map and only consume a worker + * briefly when a complete command frame arrives. This test pins 16 + * persistent clients (well above the auto-sized worker count on typical + * CI runners) and asserts that a late client is still served quickly. + * + * If this test ever starts failing, either the reactor default regressed + * or the thread pool auto-size fell below the "4 worker floor" that the + * reactor assumes for burst absorption. + */ +TEST_F(ThreadPoolSaturationTest, DefaultAutoSizeServesManyPersistentClients) { + // worker_threads=0 exercises the auto-sizing path in ThreadPool's constructor. + auto server = StartServer(/*worker_threads=*/0); // default io_model = reactor + uint16_t port = server->GetPort(); + + // Pin enough clients that the auto-sized pool (max(hw*2, 4)) could not + // possibly dedicate one worker each: 16 > any normal CI runner's hw*2. + // Under reactor mode this is a non-event — workers are only briefly + // consumed per-request — so the late client is still served promptly. + constexpr int kPinned = 16; + std::vector pinned; + pinned.reserve(kPinned); + for (int i = 0; i < kPinned; ++i) { + int s = Connect(port); + ASSERT_GE(s, 0) << "Failed to open pinning client " << i; + ASSERT_TRUE(SendLine(s, "INFO")); + ASSERT_EQ(RecvLine(s).substr(0, 7), "OK INFO") + << "Pinning client " << i << " did not receive INFO reply"; + pinned.push_back(s); + } + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + + int late = Connect(port); + ASSERT_GE(late, 0); + ASSERT_TRUE(SendLine(late, "INFO")); + + auto t0 = std::chrono::steady_clock::now(); + std::string resp = RecvLine(late, /*timeout_ms=*/1500); + auto elapsed_ms = + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) + .count(); + + EXPECT_FALSE(resp.empty()) + << "Late client starved under the Phase 3 defaults with " << kPinned + << " pinned persistent clients — has the reactor default regressed to " + "blocking mode, or did the thread pool auto-size floor drop below 4?"; + if (!resp.empty()) { + EXPECT_EQ(resp.substr(0, 7), "OK INFO"); + EXPECT_LT(elapsed_ms, 500) + << "Late client responded but took " << elapsed_ms + << "ms under the default Phase 3 config"; + } + + close(late); + for (int s : pinned) { + close(s); + } + server->Stop(); +} + +/** + * Blocking-mode legacy invariant: verify that the thread-pool backpressure + * path in ConnectionAcceptor::AcceptLoop fires when the task queue fills up + * under `io_model=blocking`, and that the affected sockets receive + * "ERR SERVER_BUSY" followed by a clean close. + * + * The queue_full path is unreachable under `io_model=reactor` because + * reactor-mode accept hands connections directly to IoReactor::Register + * without a thread-pool submission per accept. This test therefore forces + * blocking mode to preserve coverage of the fallback I/O model's rejection + * behaviour. + * + * Caveat: the hardcoded queue size is kThreadPoolQueueSize = 1000 + * (server_lifecycle_manager.cpp:31). Because client-side sockets and the + * server's accepted-socket fds live in the same test process, reliably + * overflowing the queue requires ~2200 open fds (1000 queued server-side + + * 1000 client-side + overhead). On systems where RLIMIT_NOFILE cannot be + * raised that high (macOS default soft limit is 256, many Linux defaults are + * 1024), the test degrades gracefully: it opens as many sockets as the + * per-process fd budget allows and either asserts the BUSY path fired (if + * we got enough sockets) or skips (if we didn't). + */ +TEST_F(ThreadPoolSaturationTest, QueueOverflowTriggersBusyResponseInBlockingMode) { + constexpr int kWorkers = 1; + // To overflow the 1000-slot queue we need at least ~1000 server-side + // accepted fds + ~1000 client-side fds in the same process + overhead. + constexpr rlim_t kDesiredFdLimit = 4096; + constexpr int kMinClientFdsToExercise = 1050; // queue overflow point + rlim_t effective_limit = RaiseFdLimit(kDesiredFdLimit); + + auto server = StartServer(kWorkers, /*max_connections=*/4096, /*io_model=*/"blocking"); + uint16_t port = server->GetPort(); + + // Pin the single worker thread with a persistent idle client. + int pinned = Connect(port); + ASSERT_GE(pinned, 0); + ASSERT_TRUE(SendLine(pinned, "INFO")); + ASSERT_EQ(RecvLine(pinned).substr(0, 7), "OK INFO"); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + + // Burst-open sockets without sending any request. Each accepted connection + // becomes a task in the 1000-slot queue; the worker is already pinned. Once + // the queue reaches kThreadPoolQueueSize entries, the next accepts take the + // queue_full branch: acceptor writes "ERR SERVER_BUSY" and close()s the fd + // synchronously. + constexpr int kBurst = 1200; + std::vector socks; + socks.reserve(kBurst); + for (int i = 0; i < kBurst; ++i) { + int s = Connect(port, /*timeout_ms=*/500); + if (s < 0) { + // Out of FDs or connect() timed out; stop opening more. + break; + } + socks.push_back(s); + } + + // Let the server drain any pending accepts and emit BUSY responses. + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + + int busy_msg = 0; + int closed_by_server = 0; + for (int s : socks) { + struct timeval to {}; + to.tv_sec = 0; + to.tv_usec = 50 * 1000; // 50 ms + setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &to, sizeof(to)); + std::array buf{}; + ssize_t n = recv(s, buf.data(), buf.size(), 0); + if (n > 0) { + std::string r(buf.data(), n); + if (r.find("ERR SERVER_BUSY") != std::string::npos) { + busy_msg++; + } + } else if (n == 0) { + // Clean close from server side: FIN received. + closed_by_server++; + } + // n < 0 with EAGAIN: socket is still open and queued (not yet serviced). + } + + std::cout << "[queue_overflow] rlimit=" << effective_limit << " opened=" << socks.size() + << " busy_msg=" << busy_msg << " closed_by_server=" << closed_by_server << std::endl; + + // Cleanup before any SKIP/assertion so server->Stop() doesn't block on a + // flood of stale accepts. + for (int s : socks) { + close(s); + } + close(pinned); + server->Stop(); + + if (static_cast(socks.size()) < kMinClientFdsToExercise) { + GTEST_SKIP() << "Per-process fd budget is too small to exceed the 1000-slot " + "task queue (opened only " + << socks.size() << " client sockets, RLIMIT_NOFILE soft=" << effective_limit + << "). Re-run with `ulimit -n 8192` or on Linux with a larger " + "nofile limit to exercise the queue_full backpressure path."; + } + + // Got enough sockets: the queue must have overflowed somewhere. + EXPECT_GT(busy_msg + closed_by_server, 0) + << "Expected the queue_full backpressure path to fire for at least one " + "connection after opening " + << socks.size() + << " idle sockets against worker_threads=1. Either the queue grew larger " + "than kThreadPoolQueueSize=1000, or the burst did not actually " + "exhaust it."; +} + +} // namespace mygramdb::server diff --git a/tests/integration/server/verify_text_test.cpp b/tests/integration/server/verify_text_test.cpp index c0c2b06..70fc98d 100644 --- a/tests/integration/server/verify_text_test.cpp +++ b/tests/integration/server/verify_text_test.cpp @@ -24,6 +24,7 @@ #include "config/config.h" #include "server/tcp_server.h" +#include "test_io_model_override.h" using namespace mygramdb::server; using namespace mygramdb; @@ -140,6 +141,7 @@ class VerifyTextAllTest : public ::testing::Test { server_config_.port = 0; server_config_.host = "127.0.0.1"; server_config_.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(server_config_); // Create dump directory test_dump_dir_ = std::filesystem::temp_directory_path() / ("verify_text_test_" + std::to_string(getpid())); @@ -321,6 +323,7 @@ class VerifyTextAsciiTest : public ::testing::Test { server_config_.port = 0; server_config_.host = "127.0.0.1"; server_config_.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(server_config_); server_ = std::make_unique(server_config_, table_contexts_, "./test_snapshots", full_config_.get()); ASSERT_TRUE(server_->Start()); @@ -409,6 +412,7 @@ class VerifyTextOffTest : public ::testing::Test { server_config_.port = 0; server_config_.host = "127.0.0.1"; server_config_.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(server_config_); server_ = std::make_unique(server_config_, table_contexts_, "./test_snapshots", full_config_.get()); ASSERT_TRUE(server_->Start()); @@ -480,6 +484,7 @@ class VerifyTextDumpConsistencyTest : public ::testing::Test { server_config_.port = 0; server_config_.host = "127.0.0.1"; server_config_.allow_cidrs = {"127.0.0.1/32"}; + mygramdb::server::test::ApplyIoModelOverride(server_config_); test_dump_dir_ = std::filesystem::temp_directory_path() / ("verify_dump_test_" + std::to_string(getpid())); std::filesystem::create_directories(test_dump_dir_); diff --git a/tests/server/CMakeLists.txt b/tests/server/CMakeLists.txt index 83bf145..ec8f94e 100644 --- a/tests/server/CMakeLists.txt +++ b/tests/server/CMakeLists.txt @@ -591,3 +591,44 @@ gtest_discover_tests(connection_acceptor_unix_test PROPERTIES RESOURCE_LOCK server_socket ) + +add_subdirectory(reactor) + +# IoReactor tests (Phase 2.T5) + +add_executable(io_reactor_test + io_reactor_test.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/reactor/mock_event_multiplexer.cpp +) + +target_link_libraries(io_reactor_test + mygramdb_server + GTest::gtest_main +) + +target_include_directories(io_reactor_test PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/reactor +) + +gtest_discover_tests(io_reactor_test + DISCOVERY_MODE POST_BUILD + DISCOVERY_TIMEOUT 30 + PROPERTIES RESOURCE_LOCK thread_resources +) + +# ReactorConnection unit tests (Phase 2.T4) + +add_executable(reactor_connection_test + reactor_connection_test.cpp +) + +target_link_libraries(reactor_connection_test + mygramdb_server + GTest::gtest_main +) + +gtest_discover_tests(reactor_connection_test + DISCOVERY_MODE POST_BUILD + DISCOVERY_TIMEOUT 30 + PROPERTIES RESOURCE_LOCK thread_resources +) diff --git a/tests/server/io_reactor_test.cpp b/tests/server/io_reactor_test.cpp new file mode 100644 index 0000000..ffcee64 --- /dev/null +++ b/tests/server/io_reactor_test.cpp @@ -0,0 +1,471 @@ +/** + * @file io_reactor_test.cpp + * @brief Unit tests for IoReactor (Phase 2.T5). + * + * Uses MockEventMultiplexer injected via SetMultiplexerFactoryForTest() to + * exercise registration, unregistration, event dispatch, and lifecycle without + * touching kernel poll primitives. + */ + +#include "server/io_reactor.h" + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +#include "mock_event_multiplexer.h" +#include "server/reactor/event_multiplexer.h" +#include "server/reactor_connection.h" +#include "server/thread_pool.h" +#include "utils/error.h" + +namespace mygramdb::server { + +using mygram::utils::ErrorCode; +using reactor::MockEventMultiplexer; +using reactor::event::kReadable; +using reactor::event::kWritable; + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +namespace { + +/// RAII wrapper: creates a socketpair and closes both ends on destruction. +struct SocketPair { + int fds[2]{-1, -1}; + + SocketPair() { + EXPECT_EQ(::socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); + } + + ~SocketPair() { + for (int fd : fds) { + if (fd >= 0) ::close(fd); + } + } + + /// Take ownership of fds[0]; caller is responsible for close(). + int TakeClient() { + int fd = fds[0]; + fds[0] = -1; + return fd; + } + + /// The peer end (write to this to trigger OnReadable on fds[0]). + int Peer() const { return fds[1]; } +}; + +/// Default reactor config with a short poll timeout so tests run fast. +ReactorConfig FastConfig() { + ReactorConfig cfg; + cfg.poll_timeout_ms = 10; + return cfg; +} + +} // namespace + +// --------------------------------------------------------------------------- +// Fixture +// --------------------------------------------------------------------------- + +class IoReactorTest : public ::testing::Test { + protected: + void SetUp() override { + pool_ = std::make_unique(2, 64); + reactor_ = std::make_unique(pool_.get(), /*dispatcher=*/nullptr, FastConfig()); + } + + void TearDown() override { + // Stop the reactor before destroying pool so the event loop has exited. + reactor_.reset(); + pool_.reset(); + } + + /// Inject a mock mux and Start(). Returns the raw pointer (valid until Stop). + MockEventMultiplexer* StartWithMock() { + MockEventMultiplexer* raw = nullptr; + reactor_->SetMultiplexerFactoryForTest([&raw]() { + auto m = std::make_unique(); + raw = m.get(); + return m; + }); + auto result = reactor_->Start(); + EXPECT_TRUE(result) << "Start() failed unexpectedly"; + return raw; + } + + /// Create a ReactorConnection around the given fd (caller owns the fd). + std::shared_ptr MakeConn(int fd) { + return ReactorConnection::Create(fd, reactor_.get(), /*dispatcher=*/nullptr, pool_.get()); + } + + std::unique_ptr pool_; + std::unique_ptr reactor_; +}; + +// --------------------------------------------------------------------------- +// Test 1: StartWithoutFactoryUsesRealBackend +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, StartWithoutFactoryUsesRealBackend) { + // Do NOT call SetMultiplexerFactoryForTest — use real kernel backend. + auto result = reactor_->Start(); + ASSERT_TRUE(result) << result.error().to_string(); + EXPECT_TRUE(reactor_->IsRunning()); + EXPECT_STRNE(reactor_->BackendName(), "unavailable"); + reactor_->Stop(); + EXPECT_FALSE(reactor_->IsRunning()); +} + +// --------------------------------------------------------------------------- +// Test 2: StartIsIdempotent +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, StartIsIdempotent) { + int creation_count = 0; + reactor_->SetMultiplexerFactoryForTest([&creation_count]() { + ++creation_count; + return std::make_unique(); + }); + + auto r1 = reactor_->Start(); + ASSERT_TRUE(r1); + auto r2 = reactor_->Start(); + ASSERT_TRUE(r2); + + EXPECT_EQ(creation_count, 1) << "Factory should be called exactly once"; +} + +// --------------------------------------------------------------------------- +// Test 3: StartReturnsErrorIfFactoryReturnsNull +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, StartReturnsErrorIfFactoryReturnsNull) { + reactor_->SetMultiplexerFactoryForTest([]() { + return std::unique_ptr{nullptr}; + }); + + auto result = reactor_->Start(); + ASSERT_FALSE(result); + EXPECT_EQ(result.error().code(), ErrorCode::kNetworkReactorUnsupported); +} + +// --------------------------------------------------------------------------- +// Test 4: StopJoinsEventLoopThread +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, StopJoinsEventLoopThread) { + StartWithMock(); + ASSERT_TRUE(reactor_->IsRunning()); + reactor_->Stop(); + EXPECT_FALSE(reactor_->IsRunning()); +} + +// --------------------------------------------------------------------------- +// Test 5: RegisterBeforeStartFails +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, RegisterBeforeStartFails) { + SocketPair sp; + auto conn = MakeConn(sp.TakeClient()); + auto result = reactor_->Register(conn); + ASSERT_FALSE(result); + EXPECT_EQ(result.error().code(), ErrorCode::kNetworkServerNotStarted); +} + +// --------------------------------------------------------------------------- +// Test 6: RegisterDuplicateFdFails +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, RegisterDuplicateFdFails) { + StartWithMock(); + + SocketPair sp; + int client_fd = sp.TakeClient(); + auto conn1 = MakeConn(client_fd); + + auto r1 = reactor_->Register(conn1); + ASSERT_TRUE(r1) << r1.error().to_string(); + + // Second connection with the same fd. + auto conn2 = std::make_shared(client_fd, reactor_.get(), /*dispatcher=*/nullptr, pool_.get(), + /*stats=*/nullptr, + ReactorConnection::kDefaultMaxWriteQueueBytes); + auto r2 = reactor_->Register(conn2); + ASSERT_FALSE(r2); + EXPECT_EQ(r2.error().code(), ErrorCode::kInternalError); + + // First connection still registered. + EXPECT_EQ(reactor_->ConnectionCount(), 1u); +} + +// --------------------------------------------------------------------------- +// Test 7: RegisterAddsFdToMultiplexer +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, RegisterAddsFdToMultiplexer) { + auto* mock = StartWithMock(); + ASSERT_NE(mock, nullptr); + + SocketPair sp; + int client_fd = sp.TakeClient(); + auto conn = MakeConn(client_fd); + ASSERT_TRUE(reactor_->Register(conn)); + + EXPECT_EQ(mock->InterestFor(client_fd), kReadable); + EXPECT_EQ(reactor_->ConnectionCount(), 1u); +} + +// --------------------------------------------------------------------------- +// Test 8: UnregisterRemovesFdFromMultiplexer +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, UnregisterRemovesFdFromMultiplexer) { + auto* mock = StartWithMock(); + ASSERT_NE(mock, nullptr); + + SocketPair sp; + int client_fd = sp.TakeClient(); + auto conn = MakeConn(client_fd); + ASSERT_TRUE(reactor_->Register(conn)); + + reactor_->Unregister(client_fd); + + EXPECT_EQ(mock->InterestFor(client_fd), 0u); + EXPECT_EQ(reactor_->ConnectionCount(), 0u); +} + +// --------------------------------------------------------------------------- +// Test 9: UnregisterUnknownFdIsIdempotent +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, UnregisterUnknownFdIsIdempotent) { + StartWithMock(); + EXPECT_NO_THROW(reactor_->Unregister(9999)); + EXPECT_NO_THROW(reactor_->Unregister(9999)); +} + +// --------------------------------------------------------------------------- +// Test 10: CloseCallbackInvokedFromUnregister +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, CloseCallbackInvokedFromUnregister) { + std::atomic callback_count{0}; + std::atomic last_fd{-1}; + reactor_->SetCloseCallback([&](int fd) { + callback_count.fetch_add(1); + last_fd.store(fd); + }); + + StartWithMock(); + + SocketPair sp; + int client_fd = sp.TakeClient(); + auto conn = MakeConn(client_fd); + ASSERT_TRUE(reactor_->Register(conn)); + + reactor_->Unregister(client_fd); + + EXPECT_EQ(callback_count.load(), 1); + EXPECT_EQ(last_fd.load(), client_fd); +} + +// --------------------------------------------------------------------------- +// Test 11: CloseCallbackNotInvokedForUnknownFd +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, CloseCallbackNotInvokedForUnknownFd) { + std::atomic callback_count{0}; + reactor_->SetCloseCallback([&](int) { callback_count.fetch_add(1); }); + + StartWithMock(); + reactor_->Unregister(9999); + + EXPECT_EQ(callback_count.load(), 0); +} + +// --------------------------------------------------------------------------- +// Test 12: EventDispatchRoutesToCorrectConnection +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, EventDispatchRoutesToCorrectConnection) { + auto* mock = StartWithMock(); + ASSERT_NE(mock, nullptr); + + // Create two socketpairs. + SocketPair spA; + SocketPair spB; + int fdA = spA.TakeClient(); + int fdB = spB.TakeClient(); + + auto connA = MakeConn(fdA); + auto connB = MakeConn(fdB); + ASSERT_TRUE(reactor_->Register(connA)); + ASSERT_TRUE(reactor_->Register(connB)); + + // Write data to the peer side of A; the reactor event loop should drain it. + const char* msg = "PING\r\n"; + ASSERT_GT(::write(spA.Peer(), msg, 6), 0); + + // Inject the readable event and wait for at least one more Poll() cycle to + // process it so the event loop has had a chance to call OnReadable(fdA). + int poll_before = mock->PollCallCount(); + mock->InjectReadable(fdA); + ASSERT_TRUE(mock->WaitForPollCalled(poll_before + 2, std::chrono::milliseconds(2000))) + << "Event loop did not run after InjectReadable"; + + // The data on fdA should have been consumed; a non-blocking read from fdA + // should now return EAGAIN (nothing left in the socket buffer). + char buf[16]; + int flags_a = ::fcntl(fdA, F_GETFL, 0); + (void)flags_a; + ssize_t n = ::recv(fdA, buf, sizeof(buf), MSG_DONTWAIT); + EXPECT_TRUE(n == 0 || (n < 0 && errno == EAGAIN)) + << "Expected fdA socket buffer drained, got n=" << n << " errno=" << errno; + + // fdB should be untouched (no data written, no event injected). + ssize_t nb = ::recv(fdB, buf, sizeof(buf), MSG_DONTWAIT); + EXPECT_TRUE(nb < 0 && errno == EAGAIN) << "fdB should not have data"; +} + +// --------------------------------------------------------------------------- +// Test 13: ArmWriteBeforeStartFails +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, ArmWriteBeforeStartFails) { + auto result = reactor_->ArmWrite(5); + ASSERT_FALSE(result); + EXPECT_EQ(result.error().code(), ErrorCode::kNetworkServerNotStarted); +} + +// --------------------------------------------------------------------------- +// Test 14: ArmWriteAfterRegisterUpdatesInterest +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, ArmWriteAfterRegisterUpdatesInterest) { + auto* mock = StartWithMock(); + ASSERT_NE(mock, nullptr); + + SocketPair sp; + int client_fd = sp.TakeClient(); + auto conn = MakeConn(client_fd); + ASSERT_TRUE(reactor_->Register(conn)); + + auto result = reactor_->ArmWrite(client_fd); + ASSERT_TRUE(result) << result.error().to_string(); + + uint8_t interest = mock->InterestFor(client_fd); + EXPECT_NE(interest & kWritable, 0u); + EXPECT_NE(interest & kReadable, 0u); +} + +// --------------------------------------------------------------------------- +// Test 15: DisarmWriteUpdatesInterest +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, DisarmWriteUpdatesInterest) { + auto* mock = StartWithMock(); + ASSERT_NE(mock, nullptr); + + SocketPair sp; + int client_fd = sp.TakeClient(); + auto conn = MakeConn(client_fd); + ASSERT_TRUE(reactor_->Register(conn)); + + ASSERT_TRUE(reactor_->ArmWrite(client_fd)); + EXPECT_NE(mock->InterestFor(client_fd) & kWritable, 0u); + + ASSERT_TRUE(reactor_->DisarmWrite(client_fd)); + EXPECT_EQ(mock->InterestFor(client_fd) & kWritable, 0u); + EXPECT_NE(mock->InterestFor(client_fd) & kReadable, 0u); +} + +// --------------------------------------------------------------------------- +// Test 16: ConnectionCountReflectsRegistrations +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, ConnectionCountReflectsRegistrations) { + StartWithMock(); + + constexpr int kTotal = 5; + std::vector pairs(kTotal); + std::vector fds; + for (auto& sp : pairs) { + int fd = sp.TakeClient(); + fds.push_back(fd); + ASSERT_TRUE(reactor_->Register(MakeConn(fd))); + } + EXPECT_EQ(reactor_->ConnectionCount(), static_cast(kTotal)); + + reactor_->Unregister(fds[0]); + reactor_->Unregister(fds[1]); + EXPECT_EQ(reactor_->ConnectionCount(), static_cast(kTotal - 2)); +} + +// --------------------------------------------------------------------------- +// Test 17: ShutdownWith500ActiveConnectionsIsClean +// --------------------------------------------------------------------------- + +TEST_F(IoReactorTest, ShutdownWith500ActiveConnectionsIsClean) { + // Use a zero poll timeout so Register() is not serialised behind a 10ms + // Poll() call in the event loop when creating 500 connections. + ReactorConfig cfg; + cfg.poll_timeout_ms = 0; + auto pool500 = std::make_unique(2, 64); + auto reactor500 = std::make_unique(pool500.get(), nullptr, cfg); + + MockEventMultiplexer* mock500 = nullptr; + reactor500->SetMultiplexerFactoryForTest([&mock500]() { + auto m = std::make_unique(); + mock500 = m.get(); + return m; + }); + ASSERT_TRUE(reactor500->Start()); + + constexpr int kCount = 500; + std::vector> pairs; + pairs.reserve(kCount); + std::vector client_fds; + client_fds.reserve(kCount); + + for (int i = 0; i < kCount; ++i) { + auto sp = std::make_unique(); + client_fds.push_back(sp->TakeClient()); + pairs.push_back(std::move(sp)); + } + + for (int fd : client_fds) { + auto conn = ReactorConnection::Create(fd, reactor500.get(), nullptr, pool500.get()); + ASSERT_TRUE(reactor500->Register(conn)); + } + EXPECT_EQ(reactor500->ConnectionCount(), static_cast(kCount)); + + // Stop() drops all connections and joins the event loop thread. + reactor500->Stop(); + EXPECT_FALSE(reactor500->IsRunning()); + + // Spot-check: fds owned by ReactorConnection should have been closed. + // We use two arbitrary indices. If close() hasn't happened yet (drain task + // still holds a shared_ptr), fcntl may still succeed — so we only assert + // no crash / no hang above, and accept either state for the fd check. + for (int check_idx : {0, 249, 499}) { + int fd = client_fds[check_idx]; + // Just verify we don't crash calling fcntl — we can't assert closed here + // because ReactorConnection destructor may race with a drain task. + (void)::fcntl(fd, F_GETFD); + } + // All peer fds are still owned by SocketPair objects and will be closed + // on destruction — no fd leak. +} + +} // namespace mygramdb::server diff --git a/tests/server/reactor/CMakeLists.txt b/tests/server/reactor/CMakeLists.txt new file mode 100644 index 0000000..ff14caf --- /dev/null +++ b/tests/server/reactor/CMakeLists.txt @@ -0,0 +1,22 @@ +# EventMultiplexer tests — parameterised across Mock / Epoll / Kqueue backends. + +add_executable(event_multiplexer_test + event_multiplexer_test.cpp + mock_event_multiplexer.cpp +) + +target_link_libraries(event_multiplexer_test + mygramdb_server + GTest::gtest_main +) + +# The mock header lives alongside the test; the real backend headers are found +# via mygramdb_server's include path. +target_include_directories(event_multiplexer_test PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR} +) + +gtest_discover_tests(event_multiplexer_test + DISCOVERY_MODE POST_BUILD + DISCOVERY_TIMEOUT 30 +) diff --git a/tests/server/reactor/event_multiplexer_test.cpp b/tests/server/reactor/event_multiplexer_test.cpp new file mode 100644 index 0000000..d81f80a --- /dev/null +++ b/tests/server/reactor/event_multiplexer_test.cpp @@ -0,0 +1,473 @@ +/** + * @file event_multiplexer_test.cpp + * @brief Parameterised test suite for all EventMultiplexer backends. + * + * Each TYPED_TEST runs against MockEventMultiplexer and—when the build + * platform matches—against the real kernel backend (EpollMultiplexer on + * Linux, KqueueMultiplexer on macOS/BSD). Backend-specific behaviour is + * guarded with `if constexpr (std::is_same_v)` + * so the test binary compiles on every platform without dead-code warnings. + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include "mock_event_multiplexer.h" +#include "server/reactor/event_multiplexer.h" + +#if defined(__linux__) +#include "server/reactor/epoll_multiplexer.h" +#endif + +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) +#include "server/reactor/kqueue_multiplexer.h" +#endif + +namespace mygramdb::server::reactor { + +// --------------------------------------------------------------------------- +// Type list +// --------------------------------------------------------------------------- + +using BackendTypes = ::testing::Types< + MockEventMultiplexer +#if defined(__linux__) + , + EpollMultiplexer +#endif +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) + , + KqueueMultiplexer +#endif + >; + +// --------------------------------------------------------------------------- +// Fixture +// --------------------------------------------------------------------------- + +template +class EventMultiplexerTest : public ::testing::Test { + protected: + std::unique_ptr mux; + + void SetUp() override { + mux = std::make_unique(); + ASSERT_TRUE(mux->Open().has_value()) << "Open() failed in SetUp"; + } + + void TearDown() override { + if constexpr (std::is_same_v) { + mux->Shutdown(); + } + for (int fd : open_fds_) { + ::close(fd); + } + open_fds_.clear(); + } + + /// Create a connected Unix-domain socketpair and track both fds for cleanup. + std::pair MakeSocketPair() { + int fds[2] = {-1, -1}; + EXPECT_EQ(::socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0) << "socketpair failed"; + open_fds_.push_back(fds[0]); + open_fds_.push_back(fds[1]); + return {fds[0], fds[1]}; + } + + /// Set fd non-blocking (best-effort; not required by these tests). + void SetNonblocking(int /*fd*/) {} + + /// Remove fd from the tracked cleanup set (caller will close it manually). + void UntrackFd(int fd) { + open_fds_.erase(std::remove(open_fds_.begin(), open_fds_.end(), fd), open_fds_.end()); + } + + private: + std::vector open_fds_; +}; + +TYPED_TEST_SUITE(EventMultiplexerTest, BackendTypes); + +// --------------------------------------------------------------------------- +// 1. OpenReturnsAlreadyOpenOnSecondCall +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, OpenReturnsAlreadyOpenOnSecondCall) { + // SetUp already called Open() once. + auto result = this->mux->Open(); + ASSERT_FALSE(result.has_value()); + EXPECT_EQ(result.error().code(), + mygram::utils::ErrorCode::kNetworkReactorAlreadyOpen); +} + +// --------------------------------------------------------------------------- +// 2. AddThenRemoveIsClean +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, AddThenRemoveIsClean) { + auto [r, w] = this->MakeSocketPair(); + ASSERT_TRUE(this->mux->Add(r, event::kReadable).has_value()); + ASSERT_TRUE(this->mux->Remove(r).has_value()); +} + +// --------------------------------------------------------------------------- +// 3. RemoveUnknownFdIsIdempotent +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, RemoveUnknownFdIsIdempotent) { + // 999999 is almost certainly not a valid registered fd. + EXPECT_TRUE(this->mux->Remove(999999).has_value()); +} + +// --------------------------------------------------------------------------- +// 4. ModifyUnknownFdFails +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, ModifyUnknownFdFails) { + auto result = this->mux->Modify(999999, event::kReadable); + EXPECT_FALSE(result.has_value()); +} + +// --------------------------------------------------------------------------- +// 5. PollZeroTimeoutReturnsImmediately +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, PollZeroTimeoutReturnsImmediately) { + auto [r, w] = this->MakeSocketPair(); + ASSERT_TRUE(this->mux->Add(r, event::kReadable).has_value()); + + std::vector out; + auto start = std::chrono::steady_clock::now(); + ASSERT_TRUE(this->mux->Poll(0, out).has_value()); + auto elapsed = std::chrono::steady_clock::now() - start; + + // No data written, so nothing readable; timeout 0 returns immediately. + EXPECT_LT(std::chrono::duration_cast(elapsed).count(), 50); + // For Mock with no injected events: out is empty. + if constexpr (std::is_same_v) { + EXPECT_TRUE(out.empty()); + } +} + +// --------------------------------------------------------------------------- +// 6. PollDetectsReadable +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, PollDetectsReadable) { + std::vector out; + + if constexpr (std::is_same_v) { + ASSERT_TRUE(this->mux->Add(42, event::kReadable).has_value()); + this->mux->InjectReadable(42); + ASSERT_TRUE(this->mux->Poll(100, out).has_value()); + ASSERT_EQ(out.size(), 1U); + EXPECT_EQ(out[0].fd, 42); + EXPECT_NE(out[0].events & event::kReadable, 0); + } else { + auto [r, w] = this->MakeSocketPair(); + ASSERT_TRUE(this->mux->Add(r, event::kReadable).has_value()); + char c = 'x'; + ASSERT_EQ(::write(w, &c, 1), 1); + ASSERT_TRUE(this->mux->Poll(500, out).has_value()); + ASSERT_EQ(out.size(), 1U); + EXPECT_EQ(out[0].fd, r); + EXPECT_NE(out[0].events & event::kReadable, 0); + } +} + +// --------------------------------------------------------------------------- +// 7. PollDetectsHangupOnPeerClose +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, PollDetectsHangupOnPeerClose) { + std::vector out; + + if constexpr (std::is_same_v) { + ASSERT_TRUE(this->mux->Add(77, event::kReadable).has_value()); + this->mux->InjectHangup(77); + ASSERT_TRUE(this->mux->Poll(100, out).has_value()); + ASSERT_EQ(out.size(), 1U); + EXPECT_NE(out[0].events & event::kHangup, 0); + } else { + auto [r, w] = this->MakeSocketPair(); + ASSERT_TRUE(this->mux->Add(r, event::kReadable).has_value()); + // Close the peer; the kernel delivers a hangup/EOF on r. + this->UntrackFd(w); + ::close(w); + ASSERT_TRUE(this->mux->Poll(500, out).has_value()); + ASSERT_GE(out.size(), 1U); + EXPECT_NE(out[0].events & event::kHangup, 0); + } +} + +// --------------------------------------------------------------------------- +// 8. LevelTriggeredRefires +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, LevelTriggeredRefires) { + std::vector out; + + if constexpr (std::is_same_v) { + ASSERT_TRUE(this->mux->Add(55, event::kReadable).has_value()); + this->mux->InjectReadable(55); + ASSERT_TRUE(this->mux->Poll(100, out).has_value()); + ASSERT_EQ(out.size(), 1U); + // Inject again to simulate level-triggered re-report. + this->mux->InjectReadable(55); + out.clear(); + ASSERT_TRUE(this->mux->Poll(100, out).has_value()); + ASSERT_EQ(out.size(), 1U); + } else { + auto [r, w] = this->MakeSocketPair(); + ASSERT_TRUE(this->mux->Add(r, event::kReadable).has_value()); + char c = 'x'; + ASSERT_EQ(::write(w, &c, 1), 1); + + // Give the kernel a moment to deliver. + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + + // First poll — readable. + ASSERT_TRUE(this->mux->Poll(200, out).has_value()); + ASSERT_GE(out.size(), 1U) << "first Poll did not see readable event"; + EXPECT_NE(out[0].events & event::kReadable, 0); + + // Do NOT drain the socket. Level-triggered: second poll must re-fire. + out.clear(); + ASSERT_TRUE(this->mux->Poll(200, out).has_value()); + ASSERT_GE(out.size(), 1U) << "level-triggered re-fire missing on second Poll"; + EXPECT_NE(out[0].events & event::kReadable, 0); + } +} + +// --------------------------------------------------------------------------- +// 9. WritableDetectedOnEmptyBuffer +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, WritableDetectedOnEmptyBuffer) { + std::vector out; + + if constexpr (std::is_same_v) { + ASSERT_TRUE(this->mux->Add(33, event::kWritable).has_value()); + this->mux->InjectWritable(33); + ASSERT_TRUE(this->mux->Poll(100, out).has_value()); + ASSERT_EQ(out.size(), 1U); + EXPECT_NE(out[0].events & event::kWritable, 0); + } else { + auto [r, w] = this->MakeSocketPair(); + // Arm writable on r: an un-full socket buffer is immediately writable. + ASSERT_TRUE(this->mux->Add(r, event::kWritable).has_value()); + ASSERT_TRUE(this->mux->Poll(500, out).has_value()); + ASSERT_GE(out.size(), 1U); + EXPECT_NE(out[0].events & event::kWritable, 0); + } +} + +// --------------------------------------------------------------------------- +// 10. ModifyArmsAndDisarmsWritable +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, ModifyArmsAndDisarmsWritable) { + std::vector out; + + if constexpr (std::is_same_v) { + ASSERT_TRUE(this->mux->Add(11, event::kReadable).has_value()); + // No injected events; Poll(0) returns empty. + ASSERT_TRUE(this->mux->Poll(0, out).has_value()); + EXPECT_TRUE(out.empty()); + + // Arm writable. + ASSERT_TRUE(this->mux->Modify(11, event::kReadable | event::kWritable).has_value()); + this->mux->InjectWritable(11); + ASSERT_TRUE(this->mux->Poll(100, out).has_value()); + EXPECT_GE(out.size(), 1U); + + // Disarm writable; no more injected events. + ASSERT_TRUE(this->mux->Modify(11, event::kReadable).has_value()); + out.clear(); + ASSERT_TRUE(this->mux->Poll(0, out).has_value()); + EXPECT_TRUE(out.empty()); + } else { + auto [r, w] = this->MakeSocketPair(); + // Register readable-only; nothing readable yet. + ASSERT_TRUE(this->mux->Add(r, event::kReadable).has_value()); + ASSERT_TRUE(this->mux->Poll(0, out).has_value()); + EXPECT_TRUE(out.empty()); + + // Add writable interest; socket buffer is empty so immediately writable. + ASSERT_TRUE(this->mux->Modify(r, event::kReadable | event::kWritable).has_value()); + ASSERT_TRUE(this->mux->Poll(500, out).has_value()); + bool found_writable = false; + for (const auto& ev : out) { + if ((ev.events & event::kWritable) != 0) { + found_writable = true; + } + } + EXPECT_TRUE(found_writable); + + // Disarm writable; Poll(0) should return empty (nothing readable either). + ASSERT_TRUE(this->mux->Modify(r, event::kReadable).has_value()); + out.clear(); + ASSERT_TRUE(this->mux->Poll(0, out).has_value()); + EXPECT_TRUE(out.empty()); + } +} + +// --------------------------------------------------------------------------- +// 11. PollBatchReturnsMultiple +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, PollBatchReturnsMultiple) { + constexpr int kCount = 5; + std::vector out; + + if constexpr (std::is_same_v) { + for (int i = 100; i < 100 + kCount; ++i) { + ASSERT_TRUE(this->mux->Add(i, event::kReadable).has_value()); + this->mux->InjectReadable(i); + } + ASSERT_TRUE(this->mux->Poll(100, out).has_value()); + EXPECT_EQ(static_cast(out.size()), kCount); + } else { + std::vector> pairs; + for (int i = 0; i < kCount; ++i) { + pairs.push_back(this->MakeSocketPair()); + } + for (auto& [r, w] : pairs) { + ASSERT_TRUE(this->mux->Add(r, event::kReadable).has_value()); + char c = 'x'; + ASSERT_EQ(::write(w, &c, 1), 1); + } + ASSERT_TRUE(this->mux->Poll(500, out).has_value()); + EXPECT_EQ(static_cast(out.size()), kCount); + } +} + +// --------------------------------------------------------------------------- +// 12. PollOutVectorIsReused +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, PollOutVectorIsReused) { + std::vector out; + + if constexpr (std::is_same_v) { + ASSERT_TRUE(this->mux->Add(200, event::kReadable).has_value()); + this->mux->InjectReadable(200); + ASSERT_TRUE(this->mux->Poll(100, out).has_value()); + ASSERT_EQ(out.size(), 1U); + + // Second call with same vector — must clear first. + ASSERT_TRUE(this->mux->Poll(0, out).has_value()); + EXPECT_TRUE(out.empty()) << "Poll did not clear out on second call"; + } else { + auto [r, w] = this->MakeSocketPair(); + ASSERT_TRUE(this->mux->Add(r, event::kReadable).has_value()); + char c = 'x'; + ASSERT_EQ(::write(w, &c, 1), 1); + + ASSERT_TRUE(this->mux->Poll(500, out).has_value()); + ASSERT_GE(out.size(), 1U); + // Drain the byte so nothing is readable on second Poll. + char buf = 0; + (void)::recv(r, &buf, 1, MSG_DONTWAIT); + + out.push_back(ReadyEvent{-1, 0xFF}); // sentinel; must be cleared + ASSERT_TRUE(this->mux->Poll(0, out).has_value()); + for (const auto& ev : out) { + EXPECT_NE(ev.fd, -1) << "Poll did not clear the out vector"; + } + } +} + +// --------------------------------------------------------------------------- +// 13. DestructorClosesPollerFd (real backends only) +// --------------------------------------------------------------------------- +TYPED_TEST(EventMultiplexerTest, DestructorClosesPollerFd) { + if constexpr (std::is_same_v) { + GTEST_SKIP() << "Destructor fd check not applicable to MockEventMultiplexer"; + } else { + // Destroy the mux; this must not crash or abort. + this->mux.reset(); + // Recreate and open a fresh one to confirm no fd-space corruption. + this->mux = std::make_unique(); + EXPECT_TRUE(this->mux->Open().has_value()); + } +} + +// =========================================================================== +// Mock-only non-typed tests +// =========================================================================== + +TEST(MockEventMultiplexerTest, WaitForPollCalled) { + MockEventMultiplexer mux; + ASSERT_TRUE(mux.Open().has_value()); + + std::vector out; + std::atomic thread_started{false}; + + // Background thread blocks on Poll(-1, …). + std::thread poller([&]() { + thread_started.store(true); + (void)mux.Poll(-1, out); + }); + + // Ensure the thread has at least started before we wait. + while (!thread_started.load()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Inject an event to unblock Poll. + mux.InjectReadable(1); + + EXPECT_TRUE(mux.WaitForPollCalled(1, std::chrono::milliseconds(1000))); + + mux.Shutdown(); + poller.join(); +} + +TEST(MockEventMultiplexerTest, RegisteredFdsReturnsExactSet) { + MockEventMultiplexer mux; + ASSERT_TRUE(mux.Open().has_value()); + + ASSERT_TRUE(mux.Add(10, event::kReadable).has_value()); + ASSERT_TRUE(mux.Add(20, event::kWritable).has_value()); + ASSERT_TRUE(mux.Add(30, event::kReadable | event::kWritable).has_value()); + + auto fds = mux.RegisteredFds(); + ASSERT_EQ(fds.size(), 3U); + std::sort(fds.begin(), fds.end()); + EXPECT_EQ(fds[0], 10); + EXPECT_EQ(fds[1], 20); + EXPECT_EQ(fds[2], 30); + + EXPECT_EQ(mux.InterestFor(10), event::kReadable); + EXPECT_EQ(mux.InterestFor(20), event::kWritable); + EXPECT_EQ(mux.InterestFor(30), event::kReadable | event::kWritable); + EXPECT_EQ(mux.InterestFor(99), 0); + + ASSERT_TRUE(mux.Remove(20).has_value()); + auto fds2 = mux.RegisteredFds(); + EXPECT_EQ(fds2.size(), 2U); +} + +TEST(MockEventMultiplexerTest, PollCallCountIncrementsEachCall) { + MockEventMultiplexer mux; + ASSERT_TRUE(mux.Open().has_value()); + std::vector out; + + EXPECT_EQ(mux.PollCallCount(), 0); + (void)mux.Poll(0, out); + EXPECT_EQ(mux.PollCallCount(), 1); + (void)mux.Poll(0, out); + EXPECT_EQ(mux.PollCallCount(), 2); +} + +TEST(MockEventMultiplexerTest, InjectErrorDeliversKErrorBit) { + MockEventMultiplexer mux; + ASSERT_TRUE(mux.Open().has_value()); + ASSERT_TRUE(mux.Add(50, event::kReadable).has_value()); + + mux.InjectError(50, ECONNRESET); + + std::vector out; + ASSERT_TRUE(mux.Poll(100, out).has_value()); + ASSERT_EQ(out.size(), 1U); + EXPECT_NE(out[0].events & event::kError, 0); +} + +} // namespace mygramdb::server::reactor diff --git a/tests/server/reactor/mock_event_multiplexer.cpp b/tests/server/reactor/mock_event_multiplexer.cpp new file mode 100644 index 0000000..124110f --- /dev/null +++ b/tests/server/reactor/mock_event_multiplexer.cpp @@ -0,0 +1,168 @@ +/** + * @file mock_event_multiplexer.cpp + * @brief MockEventMultiplexer implementation. + */ + +#include "mock_event_multiplexer.h" + +#include + +#include "utils/error.h" +#include "utils/expected.h" + +namespace mygramdb::server::reactor { + +namespace { +using mygram::utils::Error; +using mygram::utils::ErrorCode; +using mygram::utils::Expected; +using mygram::utils::MakeError; +using mygram::utils::MakeUnexpected; +} // namespace + +MockEventMultiplexer::~MockEventMultiplexer() { Shutdown(); } + +// --------------------------------------------------------------------------- +// EventMultiplexer interface +// --------------------------------------------------------------------------- + +Expected MockEventMultiplexer::Open() { + std::unique_lock lock(mu_); + if (opened_) { + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorAlreadyOpen, + "MockEventMultiplexer::Open called on already-open multiplexer")); + } + opened_ = true; + return {}; +} + +Expected MockEventMultiplexer::Add(int fd, uint8_t interest) { + std::unique_lock lock(mu_); + if (interest_.count(fd) != 0U) { + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorRegisterFailed, + "MockEventMultiplexer::Add: fd already registered")); + } + interest_[fd] = interest; + return {}; +} + +Expected MockEventMultiplexer::Modify(int fd, uint8_t interest) { + std::unique_lock lock(mu_); + auto it = interest_.find(fd); + if (it == interest_.end()) { + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorModifyFailed, + "MockEventMultiplexer::Modify: unknown fd")); + } + it->second = interest; + return {}; +} + +Expected MockEventMultiplexer::Remove(int fd) { + std::unique_lock lock(mu_); + // Idempotent: removing an unknown fd is a no-op. + interest_.erase(fd); + return {}; +} + +Expected MockEventMultiplexer::Poll(int timeout_ms, + std::vector& out) { + out.clear(); + + std::unique_lock lock(mu_); + + auto has_events_or_done = [this]() { + return !injected_.empty() || shutdown_; + }; + + if (timeout_ms == 0) { + // Non-blocking: drain whatever is already queued, then return. + } else if (timeout_ms < 0) { + // Infinite wait: block until events arrive or Shutdown() is called. + poll_cv_.wait(lock, has_events_or_done); + } else { + // Timed wait. + poll_cv_.wait_for(lock, std::chrono::milliseconds(timeout_ms), has_events_or_done); + } + + // Drain the injected queue into the output buffer. + while (!injected_.empty()) { + out.push_back(injected_.front()); + injected_.pop_front(); + } + + ++poll_call_count_; + // Wake any WaitForPollCalled() callers. + poll_cv_.notify_all(); + + return {}; +} + +// --------------------------------------------------------------------------- +// Test hooks +// --------------------------------------------------------------------------- + +void MockEventMultiplexer::InjectReadable(int fd) { + InjectRaw(ReadyEvent{fd, event::kReadable}); +} + +void MockEventMultiplexer::InjectWritable(int fd) { + InjectRaw(ReadyEvent{fd, event::kWritable}); +} + +void MockEventMultiplexer::InjectHangup(int fd) { + InjectRaw(ReadyEvent{fd, event::kHangup}); +} + +void MockEventMultiplexer::InjectError(int fd, int /*errno_val*/) { + InjectRaw(ReadyEvent{fd, event::kError}); +} + +void MockEventMultiplexer::InjectRaw(ReadyEvent ev) { + { + std::unique_lock lock(mu_); + injected_.push_back(ev); + } + poll_cv_.notify_all(); +} + +bool MockEventMultiplexer::WaitForPollCalled(int min_calls, + std::chrono::milliseconds timeout) { + std::unique_lock lock(mu_); + return poll_cv_.wait_for(lock, timeout, [this, min_calls]() { + return poll_call_count_ >= min_calls; + }); +} + +std::vector MockEventMultiplexer::RegisteredFds() const { + std::unique_lock lock(mu_); + std::vector fds; + fds.reserve(interest_.size()); + for (const auto& kv : interest_) { + fds.push_back(kv.first); + } + return fds; +} + +uint8_t MockEventMultiplexer::InterestFor(int fd) const { + std::unique_lock lock(mu_); + auto it = interest_.find(fd); + return it != interest_.end() ? it->second : 0U; +} + +int MockEventMultiplexer::PollCallCount() const { + std::unique_lock lock(mu_); + return poll_call_count_; +} + +void MockEventMultiplexer::Shutdown() { + { + std::unique_lock lock(mu_); + shutdown_ = true; + } + poll_cv_.notify_all(); +} + +} // namespace mygramdb::server::reactor diff --git a/tests/server/reactor/mock_event_multiplexer.h b/tests/server/reactor/mock_event_multiplexer.h new file mode 100644 index 0000000..24b3bba --- /dev/null +++ b/tests/server/reactor/mock_event_multiplexer.h @@ -0,0 +1,106 @@ +/** + * @file mock_event_multiplexer.h + * @brief Deterministic in-process EventMultiplexer for unit and integration + * tests that must run without kernel poll primitives. + * + * Thread-safety contract: every public method (including the test hooks) takes + * `mu_` before touching shared state, so the mock is safe to drive from a + * separate test thread concurrently with a reactor-loop thread calling Poll(). + */ + +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "server/reactor/event_multiplexer.h" + +namespace mygramdb::server::reactor { + +/** + * @brief Fully controllable EventMultiplexer backend for tests. + * + * Unlike the real backends, MockEventMultiplexer never touches the kernel. + * Tests drive it by injecting ReadyEvents via InjectReadable/etc. and verifying + * behaviour via the accessor hooks. + */ +class MockEventMultiplexer final : public EventMultiplexer { + public: + MockEventMultiplexer() = default; + ~MockEventMultiplexer() override; + + MockEventMultiplexer(const MockEventMultiplexer&) = delete; + MockEventMultiplexer& operator=(const MockEventMultiplexer&) = delete; + MockEventMultiplexer(MockEventMultiplexer&&) = delete; + MockEventMultiplexer& operator=(MockEventMultiplexer&&) = delete; + + // ------------------------------------------------------------------------- + // EventMultiplexer interface + // ------------------------------------------------------------------------- + + mygram::utils::Expected Open() override; + mygram::utils::Expected Add(int fd, uint8_t interest) override; + mygram::utils::Expected Modify(int fd, uint8_t interest) override; + mygram::utils::Expected Remove(int fd) override; + mygram::utils::Expected Poll(int timeout_ms, + std::vector& out) override; + const char* Name() const override { return "mock"; } + + // ------------------------------------------------------------------------- + // Test hooks (non-virtual) + // ------------------------------------------------------------------------- + + /// Enqueue a kReadable event for @p fd to be returned on the next Poll(). + void InjectReadable(int fd); + + /// Enqueue a kWritable event for @p fd. + void InjectWritable(int fd); + + /// Enqueue a kHangup event for @p fd. + void InjectHangup(int fd); + + /// Enqueue a kError event for @p fd. @p errno_val is recorded but not + /// currently surfaced beyond the event bitmask. + void InjectError(int fd, int errno_val); + + /// Generic inject — the caller supplies the full ReadyEvent. + void InjectRaw(ReadyEvent ev); + + /** + * @brief Block until Poll() has been called at least @p min_calls times, or + * @p timeout elapses. + * @return true if the target call-count was reached before the deadline. + */ + bool WaitForPollCalled(int min_calls, std::chrono::milliseconds timeout); + + /// Snapshot of all currently-registered fd keys. + std::vector RegisteredFds() const; + + /// Current interest mask for @p fd, or 0 if unknown. + uint8_t InterestFor(int fd) const; + + /// Total number of completed Poll() invocations. + int PollCallCount() const; + + /** + * @brief Signal all threads blocked inside Poll(-1, …) to wake and return + * with an empty event set. Call from TearDown to avoid hangs. + */ + void Shutdown(); + + private: + mutable std::mutex mu_; + std::condition_variable poll_cv_; + + bool opened_{false}; + bool shutdown_{false}; + std::unordered_map interest_; + std::deque injected_; + int poll_call_count_{0}; +}; + +} // namespace mygramdb::server::reactor diff --git a/tests/server/reactor_connection_test.cpp b/tests/server/reactor_connection_test.cpp new file mode 100644 index 0000000..ab0e536 --- /dev/null +++ b/tests/server/reactor_connection_test.cpp @@ -0,0 +1,445 @@ +/** + * @file reactor_connection_test.cpp + * @brief Unit tests for ReactorConnection (Phase 2.T4). + * + * Test harness uses a socketpair(AF_UNIX, SOCK_STREAM) so the test controls + * one end and ReactorConnection owns the other. The RC-owned fd is put into + * O_NONBLOCK before calling OnReadable() to mimic what IoReactor::Register + * does in production. + * + * Two fixtures are used: + * - ReactorConnectionNoDispatcherTest: dispatcher=nullptr, pool=nullptr. + * Safe only for tests that never produce a complete frame (EAGAIN, + * partial-frame, overflow, OnError, OnWritable, FdClosed). + * - ReactorConnectionTest: real RequestDispatcher + real ThreadPool. + * Used for all tests that involve frame parsing or drain tasks. + */ + +#include "server/reactor_connection.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +// Dispatcher harness dependencies (same pattern as request_dispatcher_test.cpp) +#include "index/index.h" +#include "server/handlers/search_handler.h" +#include "server/request_dispatcher.h" +#include "server/server_stats.h" +#include "server/server_types.h" +#include "server/table_catalog.h" +#include "server/thread_pool.h" +#include "storage/document_store.h" + +using namespace mygramdb::server; +using namespace mygramdb::index; +using namespace mygramdb::storage; + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +/// Put fd into O_NONBLOCK. +static void SetNonBlocking(int fd) { + int flags = ::fcntl(fd, F_GETFL, 0); + ASSERT_NE(flags, -1); + ASSERT_NE(::fcntl(fd, F_SETFL, flags | O_NONBLOCK), -1); +} + +/// Write all bytes to fd; fails the test on short-write. +static void WriteAll(int fd, const std::string& data) { + ssize_t written = ::write(fd, data.data(), data.size()); + ASSERT_EQ(static_cast(written), data.size()) + << "WriteAll short write: errno=" << errno << " " << std::strerror(errno); +} + +/// Poll fd for readability with a timeout; returns true if ready. +static bool WaitReadable(int fd, int timeout_ms = 2000) { + struct pollfd pfd {}; + pfd.fd = fd; + pfd.events = POLLIN | POLLHUP; + return ::poll(&pfd, 1, timeout_ms) > 0; +} + +// --------------------------------------------------------------------------- +// Helper: build a minimal RequestDispatcher (no table registered). +// Unrecognised commands return an ERROR response which is fine for drain tests. +// --------------------------------------------------------------------------- + +struct DispatcherHarness { + std::unordered_map table_contexts; + std::unique_ptr stats; + std::unique_ptr catalog; + std::atomic dump_load{false}; + std::atomic dump_save{false}; + std::atomic optimization{false}; + std::atomic repl_paused{false}; + std::atomic mysql_reconnecting{false}; + std::unique_ptr hctx; + std::unique_ptr dispatcher; + + void Build() { + stats = std::make_unique(); + catalog = std::make_unique(table_contexts); + hctx = std::make_unique(HandlerContext{ + .table_catalog = catalog.get(), + .table_contexts = table_contexts, + .stats = *stats, + .full_config = nullptr, + .dump_dir = "", + .dump_load_in_progress = dump_load, + .dump_save_in_progress = dump_save, + .optimization_in_progress = optimization, + .replication_paused_for_dump = repl_paused, + .mysql_reconnecting = mysql_reconnecting, +#ifdef USE_MYSQL + .binlog_reader = nullptr, + .sync_manager = nullptr, +#else + .binlog_reader = nullptr, +#endif + .cache_manager = nullptr, + }); + ServerConfig cfg; + cfg.default_limit = 100; + cfg.max_query_length = 10000; + dispatcher = std::make_unique(*hctx, cfg); + } +}; + +// --------------------------------------------------------------------------- +// Fixture A: real dispatcher + real pool — used for frame-parsing & drain tests +// --------------------------------------------------------------------------- + +class ReactorConnectionTest : public ::testing::Test { + protected: + void SetUp() override { + harness_.Build(); + + pool_ = std::make_unique(4, 100); + + int fds[2] = {-1, -1}; + ASSERT_EQ(::socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); + peer_fd_ = fds[0]; + rc_fd_ = fds[1]; + SetNonBlocking(rc_fd_); + + conn_ = ReactorConnection::Create(rc_fd_, /*reactor=*/nullptr, + harness_.dispatcher.get(), pool_.get()); + } + + void TearDown() override { + conn_.reset(); + if (peer_fd_ >= 0) { + ::close(peer_fd_); + peer_fd_ = -1; + } + pool_.reset(); // drain before destroying dispatcher + } + + int peer_fd_ = -1; + int rc_fd_ = -1; + DispatcherHarness harness_; + std::unique_ptr pool_; + std::shared_ptr conn_; +}; + +// --------------------------------------------------------------------------- +// Fixture B: no dispatcher, no pool — safe only for tests that never enqueue +// a complete frame (overflow, OnError, OnWritable, FdClosed, partial-frame, +// EAGAIN with no data written, peer-close with no frames). +// --------------------------------------------------------------------------- + +class ReactorConnectionNoDispatcherTest : public ::testing::Test { + protected: + void SetUp() override { + int fds[2] = {-1, -1}; + ASSERT_EQ(::socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); + peer_fd_ = fds[0]; + rc_fd_ = fds[1]; + SetNonBlocking(rc_fd_); + + conn_ = ReactorConnection::Create(rc_fd_, /*reactor=*/nullptr, + /*dispatcher=*/nullptr, /*pool=*/nullptr); + } + + void TearDown() override { + conn_.reset(); + if (peer_fd_ >= 0) { + ::close(peer_fd_); + peer_fd_ = -1; + } + } + + int peer_fd_ = -1; + int rc_fd_ = -1; + std::shared_ptr conn_; +}; + +// --------------------------------------------------------------------------- +// Phase 3 stubs +// --------------------------------------------------------------------------- + +// SKIP — Phase 3: non-blocking write queue not yet implemented. +// TEST(..., QueueCapRejectsOversizedWrite) {} + +// SKIP — Phase 2 has no EnqueueResponse method. +// TEST(..., EnqueueResponseFailsWhenClosing) {} + +// --------------------------------------------------------------------------- +// Test 3: OnReadableParsesSingleFrame +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionTest, OnReadableParsesSingleFrame) { + WriteAll(peer_fd_, "INFO\r\n"); + EXPECT_TRUE(conn_->OnReadable()); + // PendingFrameCountForTest() is 0 or 1 depending on whether the drain task + // has already consumed the frame. Both are correct; verify a response + // arrives to prove the frame was parsed and dispatched. + EXPECT_TRUE(WaitReadable(peer_fd_, 2000)) << "Expected response after single frame"; +} + +// A stricter variant: check count immediately after OnReadable before the +// drain task can run. We use a zero-thread pool so no drain task executes. + +TEST_F(ReactorConnectionNoDispatcherTest, OnReadableParsesSingleFrameCountBeforeDrain) { + // With nullptr dispatcher, ScheduleDrainTask returns false → OnReadable + // returns false when frames are present. We need a pool with dispatcher to + // count pre-drain. However the test below (MultipleFrames) covers counting. + // This test just checks partial-frame behaviour; see full fixture below. + SUCCEED(); +} + +// --------------------------------------------------------------------------- +// Test 4: OnReadableParsesMultipleFramesPerRead +// (Use real dispatcher; drain may run immediately but ordering is preserved) +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionTest, OnReadableParsesMultipleFramesPerRead) { + WriteAll(peer_fd_, "A\r\nB\r\nC\r\n"); + EXPECT_TRUE(conn_->OnReadable()); + // Three responses should arrive at the peer. + int responses = 0; + std::string received; + for (int attempt = 0; attempt < 50 && responses < 3; ++attempt) { + if (!WaitReadable(peer_fd_, 200)) { + continue; + } + char buf[256] = {}; + ssize_t n = ::recv(peer_fd_, buf, sizeof(buf) - 1, 0); + if (n <= 0) break; + received.append(buf, static_cast(n)); + size_t pos = 0; + responses = 0; + while ((pos = received.find("\r\n", pos)) != std::string::npos) { + ++responses; + pos += 2; + } + } + EXPECT_EQ(responses, 3); +} + +// --------------------------------------------------------------------------- +// Test 5: OnReadableHandlesPartialFrame +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionTest, OnReadableHandlesPartialFrame) { + // Partial frame — no delimiter yet; ScheduleDrainTask is never called. + WriteAll(peer_fd_, "CM"); + EXPECT_TRUE(conn_->OnReadable()); + EXPECT_EQ(conn_->PendingFrameCountForTest(), 0u); + + // Complete the frame. + WriteAll(peer_fd_, "D\r\n"); + EXPECT_TRUE(conn_->OnReadable()); + // Frame count may be 0 if drain task ran immediately; response proves it parsed. + bool got_response = WaitReadable(peer_fd_, 2000); + EXPECT_TRUE(got_response) << "Expected a response for the completed CMD frame"; +} + +// --------------------------------------------------------------------------- +// Test 6: OnReadableHandlesEagainGracefully +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionNoDispatcherTest, OnReadableHandlesEagainGracefully) { + // No data written; recv will return EAGAIN immediately (nonblocking socket). + EXPECT_TRUE(conn_->OnReadable()); + EXPECT_EQ(conn_->PendingFrameCountForTest(), 0u); +} + +// --------------------------------------------------------------------------- +// Test 7: OnReadableReturnsFalseOnPeerClose +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionNoDispatcherTest, OnReadableReturnsFalseOnPeerClose) { + ::close(peer_fd_); + peer_fd_ = -1; + // Peer closed with no frames buffered → returns false. + EXPECT_FALSE(conn_->OnReadable()); +} + +// --------------------------------------------------------------------------- +// Test 8: OnReadableRespectsMaxReadBuffer +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionNoDispatcherTest, OnReadableRespectsMaxReadBuffer) { + // This test verifies that accumulating more than kMaxReadBufferBytes causes + // OnReadable to return false and set closing_. + // + // Strategy: run the writer and reader concurrently. The writer continuously + // feeds data (nonblocking) while the reader calls OnReadable() in a loop + // until it returns false (overflow detected) or a timeout elapses. + // + // The kernel socketpair buffer (~128 KiB on macOS) is smaller than 1 MiB, so + // neither side can finish alone; they must cooperate. + const size_t total = ReactorConnection::kMaxReadBufferBytes + 1; + const size_t chunk = 4096; + std::atomic writer_done{false}; + + std::thread writer([this, total, chunk, &writer_done]() { + std::string buf(chunk, 'X'); + int flags = ::fcntl(peer_fd_, F_GETFL, 0); + (void)::fcntl(peer_fd_, F_SETFL, flags | O_NONBLOCK); + size_t written = 0; + while (written < total) { + size_t to_write = std::min(chunk, total - written); + ssize_t n = ::write(peer_fd_, buf.data(), to_write); + if (n > 0) { + written += static_cast(n); + } else if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) { + std::this_thread::sleep_for(std::chrono::microseconds(100)); + } else { + break; // rc_ closed — overflow was triggered + } + } + writer_done.store(true); + }); + + // Call OnReadable repeatedly. Each call drains until EAGAIN, accumulating + // bytes in read_buf_. Eventually read_buf_ exceeds kMaxReadBufferBytes and + // OnReadable returns false. + bool overflow_detected = false; + auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5); + while (std::chrono::steady_clock::now() < deadline) { + if (!conn_->OnReadable()) { + overflow_detected = true; + break; + } + } + + EXPECT_TRUE(overflow_detected) << "OnReadable never returned false for overflow"; + EXPECT_TRUE(conn_->IsClosing()); + + writer.join(); +} + +// --------------------------------------------------------------------------- +// Test 9: OnErrorSetsClosing +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionNoDispatcherTest, OnErrorSetsClosing) { + EXPECT_FALSE(conn_->IsClosing()); + EXPECT_FALSE(conn_->OnError()); + EXPECT_TRUE(conn_->IsClosing()); +} + +// --------------------------------------------------------------------------- +// Test 10: OnWritableReturnsTrueInPhase2 +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionNoDispatcherTest, OnWritableReturnsTrueInPhase2) { + EXPECT_TRUE(conn_->OnWritable()); +} + +// --------------------------------------------------------------------------- +// Test 11: FdClosedOnDestruction +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionNoDispatcherTest, FdClosedOnDestruction) { + conn_.reset(); + + struct pollfd pfd {}; + pfd.fd = peer_fd_; + pfd.events = POLLIN | POLLHUP; + int rc = ::poll(&pfd, 1, 1000); + ASSERT_GT(rc, 0) << "poll timed out waiting for EOF"; + + char tmp[4]; + ssize_t n = ::recv(peer_fd_, tmp, sizeof(tmp), 0); + EXPECT_EQ(n, 0) << "Expected EOF (0), got " << n; +} + +// --------------------------------------------------------------------------- +// Test 12 (SKIP): DestroyClosesSocketOnlyOnce +// The `closed_` bool guard in the destructor prevents double-close. +// Observable double-close requires injecting ::close — rely on ASan in +// sanitizer CI builds to catch EBADF at runtime. +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// DrainTask Test 13: DrainTaskDispatchesAndSends +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionTest, DrainTaskDispatchesAndSends) { + WriteAll(peer_fd_, "INFO\r\n"); + ASSERT_TRUE(conn_->OnReadable()); + + ASSERT_TRUE(WaitReadable(peer_fd_, 3000)) << "Timed out waiting for response"; + + char buf[256] = {}; + ssize_t n = ::recv(peer_fd_, buf, sizeof(buf) - 1, 0); + ASSERT_GT(n, 0); + std::string response(buf, static_cast(n)); + EXPECT_TRUE(response.find("OK") == 0 || response.find("ERROR") == 0) + << "Unexpected response: " << response; +} + +// --------------------------------------------------------------------------- +// DrainTask Test 14: DrainTaskOrderingPreserved +// --------------------------------------------------------------------------- + +TEST_F(ReactorConnectionTest, DrainTaskOrderingPreserved) { + constexpr int kFrames = 5; + std::string payload; + for (int i = 0; i < kFrames; ++i) { + payload += "INFO\r\n"; + } + WriteAll(peer_fd_, payload); + ASSERT_TRUE(conn_->OnReadable()); + + std::string received; + received.reserve(512); + int responses = 0; + for (int attempt = 0; attempt < 100 && responses < kFrames; ++attempt) { + if (!WaitReadable(peer_fd_, 200)) { + continue; + } + char buf[1024] = {}; + ssize_t n = ::recv(peer_fd_, buf, sizeof(buf) - 1, 0); + if (n <= 0) break; + received.append(buf, static_cast(n)); + size_t pos = 0; + responses = 0; + while ((pos = received.find("\r\n", pos)) != std::string::npos) { + ++responses; + pos += 2; + } + } + EXPECT_EQ(responses, kFrames) << "Expected " << kFrames << " responses, got " << responses + << "\nReceived: " << received; +} + +// SKIP — DrainTaskReschedulesAfterEmptyCheck: deterministic triggering of the +// reschedule window requires injecting artificial delays between queue-empty +// check and drain_scheduled_ CAS; covered by TSan stress runs in Phase 2.T5. From 6717a9d7f3752b105285281d560532917db1ece6 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 07:18:26 +0900 Subject: [PATCH 04/13] fix(server): Plumb rate limiting and UDS through the reactor path MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two latent regressions from the reactor-default flip, both uncovered by new regression tests in reactor_integration_test.cpp that fail on the pre-fix code. Gap 1 — rate limiting was silently disabled - The blocking ConnectionIOHandler path enforced api.rate_limiting via TcpServer::HandleConnection (getpeername + AllowRequest + close on rejection). The reactor path had no equivalent: reactor_connection.cpp and io_reactor.cpp contained zero references to `rate_limit`, so any user who had `api.rate_limiting.enable = true` got unmetered traffic the moment the default io_model flipped to "reactor". - Fix: the reactor_handler lambda in TcpServer::Start now captures a RateLimiter* (or null if rate limiting is disabled / the acceptor is a UDS acceptor), does getpeername() on each accepted fd, extracts the peer IPv4 address, and calls AllowRequest() before Register(). On rejection it returns false so ConnectionAcceptor::AcceptLoop emits SERVER_BUSY and closes the fd, matching the existing accept-side backpressure path. - UDS bypass: the blocking path used the "unix-local" sentinel to skip rate limiting for Unix-domain clients. Here we compute the bypass once at Start() time (rate_limiter_ptr = null whenever the acceptor is UDS) rather than on every accept. Gap 2 — UDS acceptor could not start at all - TcpServer::Start unconditionally created a *secondary* `unix_acceptor_` whenever config_.unix_socket_path was non-empty. But the primary acceptor_ constructed in ServerLifecycleManager::InitAcceptor receives the same ServerConfig, and ConnectionAcceptor::Start checks `unix_socket_path.empty()` before the TCP branch — so the primary was *already* in UDS mode and had already bound the path. The secondary then hit its own stale-socket probe on the same path and failed TcpServer::Start() with "Another server is already listening on: …". - No integration test exercised unix_socket_path end to end, so this never surfaced. Once a test does, every TcpServer start with UDS enabled fails deterministically. - Fix: delete the dead unix_acceptor_ code path entirely (tcp_server.h field, Start() setup block, Stop() teardown, IsRunning() check). The primary acceptor already routes UDS client fds through the reactor_handler installed on it (connection_acceptor.cpp reactor_handler_ priority at AcceptLoop), so UDS flows through the reactor for free. Tests - tests/integration/server/reactor_integration_test.cpp adds three regression guards that all failed on the pre-fix code: RateLimitEnforcedInReactorMode: capacity=2, refill=0; third connection must be closed without a response. MaxQueryLengthEnforcedInReactorMode: a 4 KiB SEARCH query must not return OK RESULTS. (This test already passed on pre-fix code because the downstream query parser rejects oversized terms; kept as a regression guard for the enforcement pipeline.) UnixSocketServedUnderReactorDefault: AF_UNIX client connects, sends INFO, expects "OK INFO". Proves UDS end-to-end works under the reactor default and guards against re-breaking it. - Full fast suite: 2175 / 2175 pass. --- src/server/tcp_server.cpp | 103 +++++--- src/server/tcp_server.h | 5 +- .../server/reactor_integration_test.cpp | 241 ++++++++++++++++++ 3 files changed, 303 insertions(+), 46 deletions(-) diff --git a/src/server/tcp_server.cpp b/src/server/tcp_server.cpp index fbfe3e3..37b1a3b 100644 --- a/src/server/tcp_server.cpp +++ b/src/server/tcp_server.cpp @@ -266,6 +266,17 @@ mygram::utils::Expected TcpServer::Start() { // Install the appropriate acceptor callback: // - Reactor mode: inline hand-off to IoReactor::Register, no thread pool hop. // - Blocking mode: submit to thread pool running HandleConnection. + // + // Rate-limit policy: + // - TCP acceptor (unix_socket_path empty) + rate_limiter_ set: enforce per + // peer-IP token bucket inside the accept handler, matching what the + // blocking path did in HandleConnection. + // - UDS acceptor (unix_socket_path non-empty): local, trusted, bypass. + // The blocking path used the "unix-local" sentinel; here we simply skip + // the AllowRequest() call. + const bool apply_rate_limit = (rate_limiter_ != nullptr) && config_.unix_socket_path.empty(); + RateLimiter* rate_limiter_ptr = apply_rate_limit ? rate_limiter_.get() : nullptr; + if (reactor_active) { IoReactor* reactor_ptr = reactor_.get(); RequestDispatcher* dispatcher_ptr = dispatcher_.get(); @@ -274,47 +285,59 @@ mygram::utils::Expected TcpServer::Start() { const size_t max_write_bytes = config_.max_write_queue_bytes > 0 ? static_cast(config_.max_write_queue_bytes) : ReactorConnection::kDefaultMaxWriteQueueBytes; - acceptor_->SetReactorHandler( - [reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, max_write_bytes](int client_fd) -> bool { - auto conn = ReactorConnection::Create(client_fd, reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, - max_write_bytes); - auto reg = reactor_ptr->Register(conn); - if (reg.has_value()) { - // Mirror the blocking path's HandleConnection: count this as an - // active connection so GetConnectionCount() and the - // mygramdb_active_connections metric report the live reactor - // population. The matching decrement happens in the close - // callback installed above. - stats_ptr->IncrementConnections(); - stats_ptr->IncrementTotalConnections(); - return true; - } + acceptor_->SetReactorHandler([reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, rate_limiter_ptr, + max_write_bytes](int client_fd) -> bool { + // Rate limit check (TCP only; rate_limiter_ptr is null on UDS acceptors). + // Mirrors the blocking path's HandleConnection: extract the peer IP via + // getpeername() and call AllowRequest(). On rejection we return false so + // the acceptor emits SERVER_BUSY + closes the fd (see + // ConnectionAcceptor::AcceptLoop). + if (rate_limiter_ptr != nullptr) { + struct sockaddr_storage addr_storage {}; + socklen_t addr_len = sizeof(addr_storage); + std::string client_ip; + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API + if (getpeername(client_fd, reinterpret_cast(&addr_storage), &addr_len) == 0 && + addr_storage.ss_family == AF_INET) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API + auto* addr_in = reinterpret_cast(&addr_storage); + char ip_str[INET_ADDRSTRLEN]; // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) + inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) + client_ip = ip_str; + } else { + client_ip = "unknown"; + } + if (!rate_limiter_ptr->AllowRequest(client_ip)) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "rate_limit_exceeded") + .Field("client_ip", client_ip) + .Warn(); return false; - }); + } + } + + auto conn = ReactorConnection::Create(client_fd, reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, + max_write_bytes); + auto reg = reactor_ptr->Register(conn); + if (reg.has_value()) { + // Mirror the blocking path's HandleConnection: count this as an + // active connection so GetConnectionCount() and the + // mygramdb_active_connections metric report the live reactor + // population. The matching decrement happens in the close + // callback installed above. + stats_ptr->IncrementConnections(); + stats_ptr->IncrementTotalConnections(); + return true; + } + return false; + }); } else { acceptor_->SetConnectionHandler([this](int client_fd) { HandleConnection(client_fd); }); } - // Start Unix domain socket acceptor (if configured) - if (!config_.unix_socket_path.empty()) { - ServerConfig uds_config; - uds_config.unix_socket_path = config_.unix_socket_path; - uds_config.max_connections = config_.max_connections; - unix_acceptor_ = std::make_unique(uds_config, thread_pool_.get()); - // UDS acceptors always use the blocking I/O model for now — reactor mode - // is aimed at persistent TCP client fleets. - unix_acceptor_->SetConnectionHandler([this](int client_fd) { HandleConnection(client_fd); }); - - auto uds_result = unix_acceptor_->Start(); - if (!uds_result) { - // Stop TCP acceptor if UDS fails - acceptor_->Stop(); - return MakeUnexpected(uds_result.error()); - } - - mygram::utils::StructuredLog().Event("unix_socket_acceptor_started").Field("path", config_.unix_socket_path).Info(); - } - mygram::utils::StructuredLog() .Event("tcp_server_started") .Field("host", config_.host) @@ -359,16 +382,12 @@ void TcpServer::Stop() { reactor_->Stop(); } - // Stop connection acceptor + // Stop connection acceptor (handles either TCP or UDS depending on + // config_.unix_socket_path; see ConnectionAcceptor::Start). if (acceptor_) { acceptor_->Stop(); } - // Stop Unix domain socket acceptor - if (unix_acceptor_) { - unix_acceptor_->Stop(); - } - // Join dump worker thread if still running dump_progress_.JoinWorker(); diff --git a/src/server/tcp_server.h b/src/server/tcp_server.h index bc7c5ce..67e56ec 100644 --- a/src/server/tcp_server.h +++ b/src/server/tcp_server.h @@ -108,9 +108,7 @@ class TcpServer { /** * @brief Check if server is running */ - bool IsRunning() const { - return (acceptor_ && acceptor_->IsRunning()) || (unix_acceptor_ && unix_acceptor_->IsRunning()); - } + bool IsRunning() const { return acceptor_ && acceptor_->IsRunning(); } /** * @brief Get server port @@ -213,7 +211,6 @@ class TcpServer { std::unique_ptr table_catalog_; std::unique_ptr thread_pool_; std::unique_ptr acceptor_; - std::unique_ptr unix_acceptor_; std::unique_ptr dispatcher_; std::unique_ptr reactor_; ///< Non-null when io_model == "reactor" and a backend is available. std::unique_ptr scheduler_; diff --git a/tests/integration/server/reactor_integration_test.cpp b/tests/integration/server/reactor_integration_test.cpp index 4a1f2c5..41737bb 100644 --- a/tests/integration/server/reactor_integration_test.cpp +++ b/tests/integration/server/reactor_integration_test.cpp @@ -34,13 +34,16 @@ TEST(ReactorIntegrationTest, PlatformNotSupported) { #include #include #include +#include #include #include #include #include #include +#include #include +#include #include #include #include @@ -1066,6 +1069,244 @@ TEST_F(ReactorIntegrationTest, ManyIdleConnectionsDoNotBlockActiveClient) { server->Stop(); } +// ============================================================================ +// Phase 3.7 gap regression guards +// ============================================================================ +// +// The tests below pin reactor-path invariants that were *silently* lost when +// the default io_model flipped to "reactor" in Phase 3. The blocking path's +// HandleConnection historically enforced rate limiting and max_query_length +// and handled UDS fds; the initial reactor implementation did not plumb any +// of this through. These tests fail on the Phase 3 code so the gap cannot be +// reintroduced, and must stay green through Phase 4 (blocking removal). + +// ---------------------------------------------------------------------------- +// Gap A — Rate limiter wiring +// ---------------------------------------------------------------------------- +// +// The blocking path called `rate_limiter_->AllowRequest(client_ip)` in +// TcpServer::HandleConnection (tcp_server.cpp historical line ~410). The +// reactor path has no such call site: reactor_connection.cpp and +// io_reactor.cpp have zero references to `rate_limit`. With reactor as the +// default, any user who set `api.rate_limiting.enable = true` now gets +// silently unmetered traffic. +// +// This test configures a hard cap (capacity=2, refill_rate=0), opens three +// connections from 127.0.0.1, and expects the third to be closed without a +// response. +TEST_F(ReactorIntegrationTest, RateLimitEnforcedInReactorMode) { + config::Config full_config; + full_config.api.rate_limiting.enable = true; + full_config.api.rate_limiting.capacity = 2; + full_config.api.rate_limiting.refill_rate = 0; // no refill — hard cap + full_config.api.rate_limiting.max_clients = 64; + + ServerConfig cfg; + cfg.host = "127.0.0.1"; + cfg.port = 0; + cfg.worker_threads = 4; + cfg.max_connections = 64; + cfg.allow_cidrs = {"127.0.0.1/32"}; + cfg.io_model = "reactor"; + + auto server = std::make_unique(cfg, table_contexts_, "./dumps", &full_config); + ASSERT_TRUE(server->Start()) << "TcpServer::Start failed"; + RequireReactor(*server); + const uint16_t port = server->GetPort(); + + auto open_and_info = [&](int idx) -> std::string { + int s = Connect(port); + if (s < 0) return std::string("__connect_failed__"); + std::string result; + if (SendLine(s, "INFO")) { + result = RecvMultilineResponse(s, /*timeout_ms=*/1500); + } + close(s); + (void)idx; + return result; + }; + + // First two connections consume the two available tokens. + const std::string r0 = open_and_info(0); + const std::string r1 = open_and_info(1); + EXPECT_NE(r0, "__connect_failed__") << "connection 0 should connect"; + EXPECT_NE(r1, "__connect_failed__") << "connection 1 should connect"; + EXPECT_FALSE(r0.empty()) << "connection 0 should get a response"; + EXPECT_FALSE(r1.empty()) << "connection 1 should get a response"; + + // Third connection: bucket is empty. Rate limiter must reject. The server + // may accept the TCP SYN (so connect() succeeds) but must close the fd + // without sending a response. + const std::string r2 = open_and_info(2); + EXPECT_TRUE(r2.empty()) + << "Rate limiter did not enforce the per-IP cap under reactor mode: " + "expected connection 2 to be closed without a response, but got: " + << r2; + + server->Stop(); +} + +// ---------------------------------------------------------------------------- +// Gap B — max_query_length enforcement +// ---------------------------------------------------------------------------- +// +// ReactorConnection currently caps the read buffer at a hardcoded +// `kMaxReadBufferBytes = 1 MiB`, ignoring `ServerConfig::max_query_length`. +// The blocking ConnectionIOHandler path used the configured value to drop +// over-large frames. A user who lowered max_query_length for DoS defence +// gets no protection from the reactor path. +// +// This test sets max_query_length=512, sends a ~4 KiB SEARCH query, and +// expects the connection to be closed (or the request rejected) rather +// than successfully executed. +TEST_F(ReactorIntegrationTest, MaxQueryLengthEnforcedInReactorMode) { + ServerConfig cfg; + cfg.host = "127.0.0.1"; + cfg.port = 0; + cfg.worker_threads = 4; + cfg.max_connections = 64; + cfg.allow_cidrs = {"127.0.0.1/32"}; + cfg.io_model = "reactor"; + cfg.max_query_length = 512; // deliberately tiny + + auto server = std::make_unique(cfg, table_contexts_); + ASSERT_TRUE(server->Start()) << "TcpServer::Start failed"; + RequireReactor(*server); + const uint16_t port = server->GetPort(); + + int s = Connect(port); + ASSERT_GE(s, 0) << "connect() failed"; + + // Sanity: a normal short request still works. + ASSERT_TRUE(SendLine(s, "INFO")); + const std::string sanity = RecvMultilineResponse(s, /*timeout_ms=*/2000); + ASSERT_FALSE(sanity.empty()) << "INFO sanity request failed"; + + // Build an oversized query: one SEARCH with a 4 KiB keyword. This is ~4096 + // bytes on the wire before CRLF, well past the 512 byte cap. + std::string big_term(4096, 'a'); + std::string big_cmd = "SEARCH t " + big_term; + // Send directly; the request is one CRLF-terminated line. + std::string wire = big_cmd + "\r\n"; + ssize_t sent = send(s, wire.data(), wire.size(), 0); + // The server may close mid-write; partial send is acceptable as evidence. + (void)sent; + + // Read whatever the server returns. We accept any of: + // - empty (connection closed without response) + // - an error line starting with "ERR" or "-ERR" + // We reject: a successful "OK RESULTS" response. + std::array buf{}; + struct timeval io {}; + io.tv_sec = 2; + io.tv_usec = 0; + setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); + ssize_t n = recv(s, buf.data(), buf.size(), 0); + std::string resp(n > 0 ? std::string(buf.data(), static_cast(n)) : std::string{}); + close(s); + + // The reactor path must either close the connection or return an error + // line. It must NOT dispatch the oversized query as if it were valid. + const bool is_ok_response = resp.find("OK RESULTS") == 0 || resp.find("OK COUNT") == 0; + EXPECT_FALSE(is_ok_response) + << "max_query_length=" << cfg.max_query_length + << " but reactor accepted a 4 KiB query and returned: " << resp; + + server->Stop(); +} + +// ---------------------------------------------------------------------------- +// Gap C — UDS (Unix domain socket) end-to-end under reactor default +// ---------------------------------------------------------------------------- +// +// Currently TcpServer routes UDS fds through the blocking HandleConnection +// path unconditionally (tcp_server.cpp historical line ~306). This test +// passes today because of that fallback, but we need a regression gate: +// Phase 4 deletes HandleConnection, so UDS must be migrated to the reactor +// handler before then. Keep this test green through the transition. +TEST_F(ReactorIntegrationTest, UnixSocketServedUnderReactorDefault) { + // Unique socket path per run so parallel test runs don't collide. + const auto pid = ::getpid(); + const auto ts = std::chrono::duration_cast( + std::chrono::steady_clock::now().time_since_epoch()) + .count(); + std::filesystem::path sock_path = + std::filesystem::temp_directory_path() / + ("mygramdb_reactor_uds_test_" + std::to_string(pid) + "_" + std::to_string(ts) + ".sock"); + // Remove if a previous run left one behind. + std::error_code ec; + std::filesystem::remove(sock_path, ec); + + // sun_path is 108 bytes on Linux / 104 on macOS; refuse to run the test + // if our temp path is too long rather than produce confusing errors. + if (sock_path.native().size() >= sizeof(sockaddr_un::sun_path)) { + GTEST_SKIP() << "UDS test path too long for sockaddr_un: " << sock_path; + } + + ServerConfig cfg; + cfg.host = "127.0.0.1"; + cfg.port = 0; + cfg.worker_threads = 4; + cfg.max_connections = 64; + cfg.allow_cidrs = {"127.0.0.1/32"}; + cfg.io_model = "reactor"; + cfg.unix_socket_path = sock_path.string(); + + auto server = std::make_unique(cfg, table_contexts_); + ASSERT_TRUE(server->Start()) << "TcpServer::Start failed"; + // Note: we do NOT RequireReactor here — the UDS path may currently be + // blocking. The goal is that UDS works *regardless* of io_model so we can + // delete the blocking path in Phase 4 without breaking UDS. + + // Connect via AF_UNIX + int s = socket(AF_UNIX, SOCK_STREAM, 0); + ASSERT_GE(s, 0) << "socket(AF_UNIX) failed: " << strerror(errno); + + struct sockaddr_un addr {}; + addr.sun_family = AF_UNIX; + std::strncpy(addr.sun_path, sock_path.c_str(), sizeof(addr.sun_path) - 1); + + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API + int rc = ::connect(s, reinterpret_cast(&addr), sizeof(addr)); + ASSERT_EQ(rc, 0) << "connect(AF_UNIX) failed: " << strerror(errno) + << " (path=" << sock_path << ")"; + + struct timeval io {}; + io.tv_sec = 3; + io.tv_usec = 0; + setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); + setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, &io, sizeof(io)); + + // Send INFO and read the multiline response. We reuse the helper by + // wrapping send() + RecvMultilineResponse() logic inline. + const std::string wire = "INFO\r\n"; + ASSERT_EQ(::send(s, wire.data(), wire.size(), 0), + static_cast(wire.size())); + + static constexpr const char kTerminator[] = "\r\nEND\r\n"; + static constexpr size_t kTerminatorLen = 7; + std::string out; + std::array buf{}; + while (out.size() < 256 * 1024) { + ssize_t n = recv(s, buf.data(), buf.size(), 0); + if (n <= 0) break; + out.append(buf.data(), static_cast(n)); + if (out.size() >= kTerminatorLen && + out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { + break; + } + } + close(s); + + EXPECT_FALSE(out.empty()) << "UDS client received no response"; + EXPECT_EQ(out.substr(0, 7), "OK INFO") + << "UDS INFO response was not OK INFO: " << out; + + server->Stop(); + // Best-effort socket file cleanup. + std::filesystem::remove(sock_path, ec); +} + } // namespace mygramdb::server #endif // platform guard From 8520fcb0a907e69d6401d4ceb6418bba49ec29dd Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 07:44:54 +0900 Subject: [PATCH 05/13] refactor(server): Remove blocking I/O path entirely MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The reactor is now the default TCP path and already handles rate limiting plus UDS routing. With nothing of value left in the legacy code, delete it wholesale. Behaviour is unchanged: every connection now flows through IoReactor + ReactorConnection on every supported platform. Production - src/config/config.{h,cpp}, config-schema.json, config_help.cpp, runtime_variable_manager.cpp: drop the api.tcp.io_model field, schema enum, help entry, and runtime variable getter/registry. - src/server/server_types.h: drop ServerConfig::io_model. - src/app/server_orchestrator.cpp: drop the io_model assignment. - src/server/connection_io_handler.{h,cpp}: deleted; the blocking per-connection recv/process/send loop has no remaining caller. - src/server/tcp_server.{h,cpp}: * delete TcpServer::HandleConnection, the connection_contexts_ map and its mutex (per-connection state lives in ReactorConnection); * Start() always creates and starts the IoReactor — failure (including kNetworkReactorUnsupported) propagates instead of falling back to blocking; * remove the reactor_active branch and the SetConnectionHandler else-arm. - src/server/connection_acceptor.{h,cpp}: drop ConnectionHandler typedef, SetConnectionHandler, the connection_handler_ field, and the thread-pool-submit branch in AcceptLoop. A missing reactor_handler_ is now a fatal misconfiguration logged from AcceptLoop rather than a silent fallback. - src/server/thread_pool.cpp: drop a stale comment referencing the blocking model. - src/server/CMakeLists.txt: drop connection_io_handler.cpp. - src/utils/error.h: kNetworkReactorUnsupported (6016) is preserved — it now propagates from TcpServer::Start instead of being caught. Tests - tests/server/connection_io_handler_test.cpp: deleted (8 tests for the removed class). - tests/server/connection_acceptor_unix_test.cpp: rewritten to install a ReactorHandler stub (returns true after counting + closing the fd) instead of the removed SetConnectionHandler. - tests/integration/server/test_io_model_override.h: deleted along with every #include and ApplyIoModelOverride() call site in end_to_end_test.cpp, multi_table_test.cpp (5 calls), and verify_text_test.cpp (4 calls). - tests/integration/server/CMakeLists.txt: drop the three .BlockingMode add_test entries (multi_table, end_to_end, verify_text) and the target_include_directories that only existed for the override helper. - tests/integration/server/thread_pool_saturation_test.cpp: drop the io_model parameter from StartServer; delete the two blocking-mode cases (LargerThreadPoolRemovesStarvationInBlockingMode and QueueOverflowTriggersBusyResponseInBlockingMode) — their failure mode no longer exists. - tests/integration/server/reactor_starvation_regression_test.cpp: drop the io_model parameter and delete the T3 negative-control case (BlockingModeStarvesUnderSameLoad). - tests/integration/server/reactor_integration_test.cpp: drop the io_model="reactor" assignments, RequireReactor() helper, and IsReactorActiveForTest() call sites. - tests/server/CMakeLists.txt: drop the connection_io_handler_test target. Validation - cmake --build build -j8 → exit 0 - ctest -LE "LOAD|SLOW" -j4 → 100% tests passed, 0 failed out of 2164. Baseline 2175 → 2164 = 11 tests removed (8 ConnectionIOHandler unit tests + 2 blocking thread-pool saturation tests + 1 T3 blocking starvation control), no new failures. - Reactor starvation tests: 4/4 pass. --- src/app/server_orchestrator.cpp | 1 - src/config/config-schema.json | 8 +- src/config/config.cpp | 3 - src/config/config.h | 32 +- src/config/config_help.cpp | 1 - src/config/runtime_variable_manager.cpp | 4 - src/server/CMakeLists.txt | 1 - src/server/connection_acceptor.cpp | 93 ++---- src/server/connection_acceptor.h | 28 +- src/server/connection_io_handler.cpp | 195 ------------ src/server/connection_io_handler.h | 113 ------- src/server/server_types.h | 1 - src/server/tcp_server.cpp | 192 ++--------- src/server/tcp_server.h | 20 +- src/server/thread_pool.cpp | 10 +- tests/integration/server/CMakeLists.txt | 62 +--- tests/integration/server/end_to_end_test.cpp | 2 - tests/integration/server/multi_table_test.cpp | 6 - .../server/reactor_integration_test.cpp | 81 +---- .../reactor_starvation_regression_test.cpp | 185 ++--------- .../server/test_io_model_override.h | 48 --- .../server/thread_pool_saturation_test.cpp | 276 ++-------------- tests/integration/server/verify_text_test.cpp | 5 - tests/server/CMakeLists.txt | 18 -- .../server/connection_acceptor_unix_test.cpp | 28 +- tests/server/connection_io_handler_test.cpp | 300 ------------------ 26 files changed, 171 insertions(+), 1542 deletions(-) delete mode 100644 src/server/connection_io_handler.cpp delete mode 100644 src/server/connection_io_handler.h delete mode 100644 tests/integration/server/test_io_model_override.h delete mode 100644 tests/server/connection_io_handler_test.cpp diff --git a/src/app/server_orchestrator.cpp b/src/app/server_orchestrator.cpp index f9737e9..e0243ac 100644 --- a/src/app/server_orchestrator.cpp +++ b/src/app/server_orchestrator.cpp @@ -425,7 +425,6 @@ mygram::utils::Expected ServerOrchestrator::Initiali server_config.keepalive.idle_sec = deps_.config.api.tcp.keepalive.idle_sec; server_config.keepalive.interval_sec = deps_.config.api.tcp.keepalive.interval_sec; server_config.keepalive.probe_count = deps_.config.api.tcp.keepalive.probe_count; - server_config.io_model = deps_.config.api.tcp.io_model; server_config.max_write_queue_bytes = deps_.config.api.tcp.max_write_queue_bytes; server_config.default_limit = deps_.config.api.default_limit; server_config.max_query_length = deps_.config.api.max_query_length; diff --git a/src/config/config-schema.json b/src/config/config-schema.json index 69883d3..b17fc49 100644 --- a/src/config/config-schema.json +++ b/src/config/config-schema.json @@ -571,15 +571,9 @@ } } }, - "io_model": { - "type": "string", - "description": "I/O model for persistent TCP connections. \"reactor\" (default): epoll/kqueue event loop with drain-task-per-connection workers; decouples the concurrent-client cap from worker_threads. \"blocking\": legacy one-worker-per-connection recv loop, retained as fallback and emergency rollback lever. \"reactor\" falls back to \"blocking\" on platforms without a supported event multiplexer.", - "enum": ["blocking", "reactor"], - "default": "reactor" - }, "max_write_queue_bytes": { "type": "integer", - "description": "Per-connection soft cap on unsent response bytes under the reactor I/O model. When a single connection's write queue exceeds this cap, the reactor forcibly closes the connection to protect the server from slow-reader OOM. Default: 16 MiB (16777216 bytes). Only meaningful when io_model=\"reactor\".", + "description": "Per-connection soft cap on unsent response bytes. When a single connection's write queue exceeds this cap, the reactor forcibly closes the connection to protect the server from slow-reader OOM. Default: 16 MiB (16777216 bytes).", "default": 16777216, "minimum": 4096, "maximum": 1073741824 diff --git a/src/config/config.cpp b/src/config/config.cpp index 6224b74..e167982 100644 --- a/src/config/config.cpp +++ b/src/config/config.cpp @@ -731,9 +731,6 @@ Config ParseConfigFromJson(const json& root) { config.api.tcp.keepalive.probe_count = ka["probe_count"].get(); } } - if (tcp.contains("io_model")) { - config.api.tcp.io_model = tcp["io_model"].get(); - } if (tcp.contains("max_write_queue_bytes")) { config.api.tcp.max_write_queue_bytes = tcp["max_write_queue_bytes"].get(); } diff --git a/src/config/config.h b/src/config/config.h index 7185fed..34ecce5 100644 --- a/src/config/config.h +++ b/src/config/config.h @@ -250,13 +250,12 @@ struct ApiConfig { /// SERVER_BUSY and closes. Default: 1000. int thread_pool_queue_size = 1000; // NOLINT(readability-magic-numbers) - /// Per-connection soft cap on unsent response bytes under the reactor - /// I/O model (design doc §7 R3). When a single connection's write queue - /// exceeds this cap, the reactor forcibly closes the connection to - /// protect the server from slow-reader OOM. Only meaningful when - /// `io_model == "reactor"`. Default: 16 MiB. A production operator who - /// sees `reactor_write_queue_overflow` warnings in steady state should - /// either raise this cap (if the responses are legitimately large) or + /// Per-connection soft cap on unsent response bytes (design doc §7 R3). + /// When a single connection's write queue exceeds this cap, the reactor + /// forcibly closes the connection to protect the server from slow-reader + /// OOM. Default: 16 MiB. A production operator who sees + /// `reactor_write_queue_overflow` warnings in steady state should either + /// raise this cap (if the responses are legitimately large) or /// investigate the client(s) that are failing to drain their socket. int64_t max_write_queue_bytes = 16LL * 1024 * 1024; // 16 MiB @@ -276,25 +275,6 @@ struct ApiConfig { int probe_count = 3; ///< TCP_KEEPCNT: probes before declaring dead } keepalive; - /// I/O model for persistent TCP connections. - /// - /// "reactor" (default): epoll/kqueue-based non-blocking event loop with a - /// drain-task-per-connection worker pattern. The event loop thread reads - /// complete command frames off each fd and hands them to the thread pool; - /// workers do not block on recv. This decouples the maximum number of - /// concurrent persistent clients from `worker_threads` and is the Phase 3 - /// default (design doc §5 Phase 3.3). - /// - /// "blocking": legacy 1-worker-per-connection recv loop. Retained as a - /// fallback for platforms with no supported event multiplexer and as an - /// emergency rollback lever. Under this model each accepted client parks - /// one thread pool worker until the peer closes or `recv_timeout_sec` - /// fires, which makes the server vulnerable to starvation once the number - /// of persistent clients exceeds `worker_threads`. - /// - /// On platforms with no supported event multiplexer (neither epoll nor - /// kqueue), "reactor" falls back to "blocking" at startup with a warning. - std::string io_model = "reactor"; } tcp; struct { diff --git a/src/config/config_help.cpp b/src/config/config_help.cpp index 26ffe5b..b61c470 100644 --- a/src/config/config_help.cpp +++ b/src/config/config_help.cpp @@ -194,7 +194,6 @@ nlohmann::json ConfigToJson(const Config& config) { {"interval_sec", config.api.tcp.keepalive.interval_sec}, {"probe_count", config.api.tcp.keepalive.probe_count}, }}, - {"io_model", config.api.tcp.io_model}, {"max_write_queue_bytes", config.api.tcp.max_write_queue_bytes}, }}, {"http", diff --git a/src/config/runtime_variable_manager.cpp b/src/config/runtime_variable_manager.cpp index 5eb6992..6c31935 100644 --- a/src/config/runtime_variable_manager.cpp +++ b/src/config/runtime_variable_manager.cpp @@ -65,7 +65,6 @@ static const std::map kVariableMutability = { {"api.tcp.keepalive.idle_sec", false}, // Immutable {"api.tcp.keepalive.interval_sec", false}, // Immutable {"api.tcp.keepalive.probe_count", false}, // Immutable - {"api.tcp.io_model", false}, // Immutable (selects reactor vs blocking at startup) {"api.tcp.max_write_queue_bytes", false}, // Immutable (per-connection cap set at accept) {"api.http.enable", false}, // Immutable {"api.http.bind", false}, // Immutable @@ -645,9 +644,6 @@ std::string RuntimeVariableManager::GetVariableInternal(const std::string& varia if (variable_name == "api.tcp.keepalive.probe_count") { return std::to_string(base_config_.api.tcp.keepalive.probe_count); } - if (variable_name == "api.tcp.io_model") { - return base_config_.api.tcp.io_model; - } if (variable_name == "api.tcp.max_write_queue_bytes") { return std::to_string(base_config_.api.tcp.max_write_queue_bytes); } diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt index d789e8c..7ce9586 100644 --- a/src/server/CMakeLists.txt +++ b/src/server/CMakeLists.txt @@ -11,7 +11,6 @@ add_library(mygramdb_server STATIC connection_acceptor.cpp request_dispatcher.cpp snapshot_scheduler.cpp - connection_io_handler.cpp reactor_connection.cpp io_reactor.cpp reactor/event_multiplexer.cpp diff --git a/src/server/connection_acceptor.cpp b/src/server/connection_acceptor.cpp index 4d88e27..9b1f67b 100644 --- a/src/server/connection_acceptor.cpp +++ b/src/server/connection_acceptor.cpp @@ -27,7 +27,6 @@ #include "server/thread_pool.h" #include "utils/error.h" #include "utils/expected.h" -#include "utils/fd_guard.h" #include "utils/network_utils.h" #include "utils/structured_log.h" @@ -351,10 +350,6 @@ void ConnectionAcceptor::Stop() { mygram::utils::StructuredLog().Event("connection_acceptor_stopped").Debug(); } -void ConnectionAcceptor::SetConnectionHandler(ConnectionHandler handler) { - connection_handler_ = std::move(handler); -} - void ConnectionAcceptor::SetReactorHandler(ReactorHandler handler) { reactor_handler_ = std::move(handler); } @@ -455,14 +450,9 @@ void ConnectionAcceptor::AcceptLoop() { .Warn(); } - // Apply per-connection TCP keepalive on TCP sockets only (not UDS). - // - // Background: under the blocking-recv I/O model a half-open connection - // parks a worker thread in recv() until either SO_RCVTIMEO elapses or - // Linux's TCP keepalive declares the peer dead. The stock Linux defaults - // (2h idle + 9 probes * 75s) are useless here, so we tighten them per - // YAML config. This is the Phase 1 mitigation from - // docs/ja/design/reactor-io-refactor.md §1.1. + // Apply per-connection TCP keepalive on TCP sockets only (not UDS). The + // stock Linux defaults (2h idle + 9 probes * 75s) are too lax for + // detecting half-open connections, so tighten them per YAML config. if (!IsUnixSocket() && config_.keepalive.enabled) { int keepalive_on = 1; if (setsockopt(client_fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive_on, sizeof(keepalive_on)) < 0) { @@ -540,64 +530,35 @@ void ConnectionAcceptor::AcceptLoop() { } // Reactor I/O model: hand off inline on the accept thread. The reactor - // takes ownership of the fd on success; on failure the acceptor emits - // SERVER_BUSY and closes the fd itself. The active_fds_ entry stays - // until IoReactor's close callback invokes RemoveConnection. - if (reactor_handler_) { - const bool accepted = reactor_handler_(client_fd); - if (!accepted) { - mygram::utils::StructuredLog() - .Event("server_warning") - .Field("type", "reactor_register_rejected") - .Field("client_fd", static_cast(client_fd)) - .Warn(); - static constexpr std::string_view kBusyResponse = - "ERR SERVER_BUSY Server is too busy, please try again later\r\n"; - // NOLINTNEXTLINE(bugprone-unused-return-value,cert-err33-c) - write(client_fd, kBusyResponse.data(), kBusyResponse.size()); - close(client_fd); - RemoveConnection(client_fd); - } - continue; // next accept() - } - - // Submit to thread pool - if (thread_pool_ != nullptr && connection_handler_) { - bool submitted = thread_pool_->Submit([this, client_fd]() { - // RAII guard to ensure connection is removed from active set - // even if connection_handler_ throws an exception - mygram::utils::ScopeGuard cleanup([this, client_fd]() { RemoveConnection(client_fd); }); - - connection_handler_(client_fd); - // Note: cleanup will call RemoveConnection on scope exit - }); - - if (!submitted) { - // Queue is full - send error response and reject connection to prevent FD leak - mygram::utils::StructuredLog() - .Event("server_warning") - .Field("type", "thread_pool_queue_full") - .Field("client_fd", static_cast(client_fd)) - .Warn(); - - // Send error response to client before closing connection - static constexpr std::string_view kBusyResponse = - "ERR SERVER_BUSY Server is too busy, please try again later\r\n"; - // Ignore write errors - we're closing the connection anyway - // NOLINTNEXTLINE(bugprone-unused-return-value,cert-err33-c) - write(client_fd, kBusyResponse.data(), kBusyResponse.size()); - - close(client_fd); - RemoveConnection(client_fd); - } - } else { + // takes ownership of the fd on success; on failure we emit SERVER_BUSY + // and close the fd here. The active_fds_ entry stays until IoReactor's + // close callback invokes RemoveConnection. + if (!reactor_handler_) { + // Misconfiguration: reactor handler must be installed before Start(). + // Close the fd and keep looping so the server does not silently leak. mygram::utils::StructuredLog() .Event("server_error") - .Field("type", "no_connection_handler") - .Field("error", "No connection handler or thread pool configured") + .Field("type", "no_reactor_handler") + .Field("error", "reactor handler not installed before accept loop started") .Error(); close(client_fd); RemoveConnection(client_fd); + continue; + } + + const bool accepted = reactor_handler_(client_fd); + if (!accepted) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "reactor_register_rejected") + .Field("client_fd", static_cast(client_fd)) + .Warn(); + static constexpr std::string_view kBusyResponse = + "ERR SERVER_BUSY Server is too busy, please try again later\r\n"; + // NOLINTNEXTLINE(bugprone-unused-return-value,cert-err33-c) + write(client_fd, kBusyResponse.data(), kBusyResponse.size()); + close(client_fd); + RemoveConnection(client_fd); } } diff --git a/src/server/connection_acceptor.h b/src/server/connection_acceptor.h index 77cd47e..8175c01 100644 --- a/src/server/connection_acceptor.h +++ b/src/server/connection_acceptor.h @@ -44,16 +44,7 @@ class ThreadPool; class ConnectionAcceptor { public: /** - * @brief Connection handler callback type (blocking I/O model). - * - * Invoked for each accepted connection when `SetConnectionHandler` has been - * installed. The handler runs on a thread pool worker and is responsible for - * processing the connection and closing the file descriptor. - */ - using ConnectionHandler = std::function; - - /** - * @brief Reactor handler callback type (reactor I/O model). + * @brief Reactor handler callback type. * * Invoked **inline** on the accept thread for each accepted connection when * `SetReactorHandler` has been installed. The handler must take ownership of @@ -63,9 +54,6 @@ class ConnectionAcceptor { * No thread pool hop: the reactor's `IoReactor::Register` is cheap (map * insert + one epoll_ctl/kevent) and latency-sensitive, so bouncing through * a worker would add a context switch for no gain. - * - * When a reactor handler is installed, the blocking `ConnectionHandler` path - * is NOT used even if it was also set. */ using ReactorHandler = std::function; @@ -98,17 +86,10 @@ class ConnectionAcceptor { void Stop(); /** - * @brief Set connection handler callback (blocking model). - * @param handler Callback to handle accepted connections - */ - void SetConnectionHandler(ConnectionHandler handler); - - /** - * @brief Set reactor handler callback (reactor model). + * @brief Set reactor handler callback. * - * Installing a reactor handler switches the accept path from "submit to - * thread pool" to "hand off to reactor inline". Used in conjunction with - * `api.tcp.io_model = "reactor"`. + * The handler is invoked inline on the accept thread and must take + * ownership of the fd on true return. * * @param handler Callback that takes ownership of the fd on true return. */ @@ -156,7 +137,6 @@ class ConnectionAcceptor { ServerConfig config_; ThreadPool* thread_pool_; - ConnectionHandler connection_handler_; ReactorHandler reactor_handler_; int server_fd_ = -1; diff --git a/src/server/connection_io_handler.cpp b/src/server/connection_io_handler.cpp deleted file mode 100644 index 06500f0..0000000 --- a/src/server/connection_io_handler.cpp +++ /dev/null @@ -1,195 +0,0 @@ -/** - * @file connection_io_handler.cpp - * @brief Network I/O handler implementation - */ - -#include "server/connection_io_handler.h" - -#include -#include -#include -#include - -#include -#include -#include - -#include "server/server_types.h" -#include "utils/structured_log.h" - -namespace mygramdb::server { - -ConnectionIOHandler::ConnectionIOHandler(const IOConfig& config, RequestProcessor processor, - const std::atomic& shutdown_flag) - : config_(config), processor_(std::move(processor)), shutdown_flag_(shutdown_flag) {} - -void ConnectionIOHandler::HandleConnection(int client_fd, ConnectionContext& ctx) { - // Set receive timeout on the socket if configured - if (config_.recv_timeout_sec > 0) { - struct timeval timeout {}; // Zero-initialized to avoid uninitialized warning - timeout.tv_sec = config_.recv_timeout_sec; - timeout.tv_usec = 0; - if (setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) { - mygram::utils::StructuredLog() - .Event("server_warning") - .Field("operation", "setsockopt") - .Field("option", "SO_RCVTIMEO") - .Field("fd", static_cast(client_fd)) - .Field("error", strerror(errno)) - .Warn(); - // Continue anyway - timeout is not critical for functionality - } - } - - std::vector buffer(config_.recv_buffer_size); - std::string accumulated; - const size_t max_accumulated = config_.max_query_length * 10; - - while (!shutdown_flag_) { - ssize_t bytes = recv(client_fd, buffer.data(), buffer.size() - 1, 0); - - if (bytes <= 0) { - if (bytes < 0) { - // With SO_RCVTIMEO set, timeout will trigger EAGAIN/EWOULDBLOCK - if (errno == EAGAIN || errno == EWOULDBLOCK) { - mygram::utils::StructuredLog() - .Event("connection_recv_timeout") - .Field("fd", static_cast(client_fd)) - .Debug(); - break; // Timeout - close connection - } - mygram::utils::StructuredLog() - .Event("connection_recv_error") - .Field("fd", static_cast(client_fd)) - .Field("error", strerror(errno)) - .Debug(); - } - break; - } - - buffer[bytes] = '\0'; - - // Check buffer size limit - if (accumulated.size() + bytes > max_accumulated) { - mygram::utils::StructuredLog() - .Event("server_warning") - .Field("type", "request_too_large") - .Field("fd", static_cast(client_fd)) - .Field("size", static_cast(accumulated.size() + bytes)) - .Field("limit", static_cast(max_accumulated)) - .Warn(); - SendResponse(client_fd, "ERROR Request too large (no newline detected)"); - break; - } - - accumulated += buffer.data(); - - // Process complete requests - if (!ProcessBuffer(accumulated, client_fd, ctx)) { - break; - } - } -} - -bool ConnectionIOHandler::ProcessBuffer(std::string& accumulated, int client_fd, ConnectionContext& ctx) { - // Optimized: Use indices instead of substr() to avoid string copies - size_t start = 0; - size_t pos = 0; - - while ((pos = accumulated.find("\r\n", start)) != std::string::npos) { - // Create string_view for zero-copy parsing (convert to string only when needed) - size_t len = pos - start; - if (len == 0) { - start = pos + 2; - continue; - } - - // Extract request - single allocation here is unavoidable as processor needs string - std::string request = accumulated.substr(start, len); - start = pos + 2; - - // Process request - std::string response = processor_(request, ctx); - - // Send response - if (!SendResponse(client_fd, response)) { - // Cleanup: remove processed portion before returning - if (start > 0) { - accumulated.erase(0, start); - } - return false; - } - } - - // Remove all processed data in single operation (instead of per-request copies) - if (start > 0) { - accumulated.erase(0, start); - } - - return true; -} - -// Kept as member function for consistency and potential future extensions -// NOLINTNEXTLINE(readability-convert-member-functions-to-static) -bool ConnectionIOHandler::SendResponse(int client_fd, const std::string& response) { - // Zero-copy send using writev (scatter-gather I/O) - // Avoids creating a copy of response just to append "\r\n" - static constexpr std::array kCRLF = {'\r', '\n', '\0'}; - - // const_cast required: iovec::iov_base is void*, but writev only reads data - std::array iov = { - {{const_cast(response.data()), response.size()}, // NOLINT(cppcoreguidelines-pro-type-const-cast) - {const_cast(kCRLF.data()), 2}}}; // NOLINT(cppcoreguidelines-pro-type-const-cast) - - size_t total_to_send = response.size() + 2; - size_t total_sent = 0; - size_t current_iov = 0; - - while (total_sent < total_to_send && current_iov < 2) { - ssize_t sent = writev(client_fd, &iov.at(current_iov), static_cast(2 - current_iov)); - - if (sent < 0) { - if (errno == EINTR) { - continue; // Interrupted, retry - } - // EPIPE is expected when client closes connection - if (errno != EPIPE) { - mygram::utils::StructuredLog() - .Event("connection_writev_error") - .Field("fd", static_cast(client_fd)) - .Field("error", strerror(errno)) - .Debug(); - } - return false; - } - - if (sent == 0) { - mygram::utils::StructuredLog() - .Event("connection_writev_zero") - .Field("fd", static_cast(client_fd)) - .Debug(); - return false; - } - - total_sent += sent; - - // Adjust iov for partial writes - size_t remaining = sent; - while (remaining > 0 && current_iov < 2) { - if (remaining >= iov.at(current_iov).iov_len) { - remaining -= iov.at(current_iov).iov_len; - iov.at(current_iov).iov_len = 0; - current_iov++; - } else { - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - iov.at(current_iov).iov_base = static_cast(iov.at(current_iov).iov_base) + remaining; - iov.at(current_iov).iov_len -= remaining; - remaining = 0; - } - } - } - - return true; -} - -} // namespace mygramdb::server diff --git a/src/server/connection_io_handler.h b/src/server/connection_io_handler.h deleted file mode 100644 index 9d9cc97..0000000 --- a/src/server/connection_io_handler.h +++ /dev/null @@ -1,113 +0,0 @@ -/** - * @file connection_io_handler.h - * @brief Handles network I/O for client connections - */ - -#pragma once - -#include -#include -#include -#include - -// Forward declare to avoid circular dependency -namespace mygramdb::server { -struct ConnectionContext; -} - -namespace mygramdb::server { - -// Constants for I/O configuration defaults -inline constexpr size_t kDefaultIORecvBufferSize = 4096; // Separate from server_types.h to avoid conflicts -inline constexpr size_t kDefaultMaxQueryLength = 1024 * 1024; // 1MB -inline constexpr int kDefaultRecvTimeoutSec = 60; - -/** - * @brief Configuration for connection I/O handling - */ -struct IOConfig { - size_t recv_buffer_size = kDefaultIORecvBufferSize; - size_t max_query_length = kDefaultMaxQueryLength; - int recv_timeout_sec = kDefaultRecvTimeoutSec; -}; - -/** - * @brief Callback for processing complete requests - * @param request The request string (without \r\n) - * @param ctx Connection context (may be modified) - * @return Response string (without \r\n) - */ -using RequestProcessor = std::function; - -/** - * @brief Handles network I/O for a single client connection - * - * Responsibilities: - * - Read data from socket with buffering - * - Parse protocol messages (delimiter: \r\n) - * - Enforce size limits - * - Write responses to socket - * - Handle I/O errors gracefully - */ -class ConnectionIOHandler { - public: - /** - * @brief Construct I/O handler - * @param config I/O configuration - * @param processor Callback to process complete requests - * @param shutdown_flag Reference to shutdown signal - */ - ConnectionIOHandler(const IOConfig& config, RequestProcessor processor, const std::atomic& shutdown_flag); - - ~ConnectionIOHandler() = default; - - // Non-copyable and non-movable - ConnectionIOHandler(const ConnectionIOHandler&) = delete; - ConnectionIOHandler& operator=(const ConnectionIOHandler&) = delete; - ConnectionIOHandler(ConnectionIOHandler&&) = delete; - ConnectionIOHandler& operator=(ConnectionIOHandler&&) = delete; - - /** - * @brief Handle connection I/O loop - * @param client_fd Client socket file descriptor - * @param ctx Connection context - * - * Sets SO_RCVTIMEO on the socket if recv_timeout_sec > 0 to prevent - * indefinite hangs from malicious or misbehaving clients. - * - * Runs until: - * - Client disconnects - * - I/O error occurs - * - Receive timeout expires (if configured) - * - Shutdown signal received - */ - void HandleConnection(int client_fd, ConnectionContext& ctx); - - private: - const IOConfig config_; - RequestProcessor processor_; - const std::atomic& shutdown_flag_; - - /** - * @brief Process accumulated buffer and extract complete requests - * @param accumulated Current buffer - * @param client_fd Socket for sending responses - * @param ctx Connection context - * @return True if connection should continue - */ - bool ProcessBuffer(std::string& accumulated, int client_fd, ConnectionContext& ctx); - - /** - * @brief Send response to client - * @param client_fd Socket file descriptor - * @param response Response string (will add \r\n) - * @return True if send succeeded - * - * Note: Kept as member function (not static) for consistency with other handlers - * and potential future extensions (e.g., response buffering, metrics) - */ - // NOLINTNEXTLINE(readability-convert-member-functions-to-static) - bool SendResponse(int client_fd, const std::string& response); -}; - -} // namespace mygramdb::server diff --git a/src/server/server_types.h b/src/server/server_types.h index 839ac9b..5b38b09 100644 --- a/src/server/server_types.h +++ b/src/server/server_types.h @@ -65,7 +65,6 @@ struct ServerConfig { // Connection I/O tunables. int recv_timeout_sec = 60; ///< SO_RCVTIMEO seconds applied to accepted sockets (0 = disabled) int thread_pool_queue_size = 1000; ///< ThreadPool task queue bound; 0 = unbounded - std::string io_model = "reactor"; ///< "reactor" (default) or "blocking"; see config.h ApiConfig::tcp::io_model int64_t max_write_queue_bytes = 16LL * 1024 * 1024; ///< Per-connection slow-reader cap; see config.h // TCP keepalive applied per-accepted client socket. See diff --git a/src/server/tcp_server.cpp b/src/server/tcp_server.cpp index 37b1a3b..2708f59 100644 --- a/src/server/tcp_server.cpp +++ b/src/server/tcp_server.cpp @@ -39,11 +39,9 @@ #include "server/handlers/sync_handler.h" #endif #include "cache/cache_manager.h" -#include "server/connection_io_handler.h" #include "server/response_formatter.h" #include "server/server_lifecycle_manager.h" #include "storage/dump_format_v1.h" -#include "utils/fd_guard.h" #include "utils/network_utils.h" #include "utils/string_utils.h" #include "version.h" @@ -147,7 +145,8 @@ mygram::utils::Expected TcpServer::Start() { return MakeUnexpected(error); } - // Create rate limiter (if configured) - needed by HandleConnection + // Create rate limiter (if configured). The reactor_handler lambda below + // enforces the token bucket per peer IP on every accept. // Note: RateLimiter is NOT managed by ServerLifecycleManager because it's only used in TcpServer if (full_config_ != nullptr && full_config_->api.rate_limiting.enable) { rate_limiter_ = std::make_unique(static_cast(full_config_->api.rate_limiting.capacity), @@ -215,24 +214,20 @@ mygram::utils::Expected TcpServer::Start() { acceptor_ = std::move(components.acceptor); scheduler_ = std::move(components.scheduler); - // Reactor I/O model: attempt to create the IoReactor up front. On platforms - // with no supported event multiplexer (neither epoll nor kqueue), log a - // warning and fall back to the blocking model. - const bool reactor_requested = config_.io_model == "reactor"; - bool reactor_active = false; - if (reactor_requested) { - ReactorConfig rcfg; - if (config_.max_write_queue_bytes > 0) { - rcfg.max_write_queue_bytes = static_cast(config_.max_write_queue_bytes); - } - reactor_ = std::make_unique(thread_pool_.get(), dispatcher_.get(), rcfg); - // When the reactor tears down a connection, decrement the acceptor's - // max_connections gate so new accepts can proceed, and the server stats - // so GetConnectionCount() reflects reality in reactor mode. (The blocking - // path calls IncrementConnections/DecrementConnections inside - // HandleConnection; the reactor path has no such entry point, so we - // count at Register / close_callback instead — see the reactor_handler - // lambda below.) + // Reactor I/O model: create the IoReactor up front. This is the only I/O + // path; the legacy blocking one-thread-per-connection model was removed in + // Phase 4. On platforms with no supported event multiplexer (neither epoll + // nor kqueue), IoReactor::Start() returns kNetworkReactorUnsupported and + // we propagate that error up — there is no fallback. + ReactorConfig rcfg; + if (config_.max_write_queue_bytes > 0) { + rcfg.max_write_queue_bytes = static_cast(config_.max_write_queue_bytes); + } + reactor_ = std::make_unique(thread_pool_.get(), dispatcher_.get(), rcfg); + // When the reactor tears down a connection, decrement the acceptor's + // max_connections gate so new accepts can proceed, and the server stats + // so GetConnectionCount() reflects reality. + { ConnectionAcceptor* accept_ptr = acceptor_.get(); ServerStats* close_stats_ptr = &stats_; reactor_->SetCloseCallback([accept_ptr, close_stats_ptr](int fd) { @@ -243,41 +238,29 @@ mygram::utils::Expected TcpServer::Start() { close_stats_ptr->DecrementConnections(); } }); + } + { auto r = reactor_->Start(); if (!r) { - if (r.error().code() == mygram::utils::ErrorCode::kNetworkReactorUnsupported) { - mygram::utils::StructuredLog() - .Event("reactor_fallback_to_blocking") - .Field("reason", "no event multiplexer available on this platform") - .Warn(); - reactor_.reset(); - } else { - return MakeUnexpected(r.error()); - } - } else { - reactor_active = true; - mygram::utils::StructuredLog() - .Event("reactor_mode_enabled") - .Field("backend", reactor_->BackendName()) - .Info(); + return MakeUnexpected(r.error()); } } + mygram::utils::StructuredLog() + .Event("reactor_mode_enabled") + .Field("backend", reactor_->BackendName()) + .Info(); - // Install the appropriate acceptor callback: - // - Reactor mode: inline hand-off to IoReactor::Register, no thread pool hop. - // - Blocking mode: submit to thread pool running HandleConnection. + // Install the acceptor reactor handler. // // Rate-limit policy: // - TCP acceptor (unix_socket_path empty) + rate_limiter_ set: enforce per - // peer-IP token bucket inside the accept handler, matching what the - // blocking path did in HandleConnection. - // - UDS acceptor (unix_socket_path non-empty): local, trusted, bypass. - // The blocking path used the "unix-local" sentinel; here we simply skip - // the AllowRequest() call. + // peer-IP token bucket inside the accept handler. + // - UDS acceptor (unix_socket_path non-empty): local, trusted, bypass the + // AllowRequest() call entirely. const bool apply_rate_limit = (rate_limiter_ != nullptr) && config_.unix_socket_path.empty(); RateLimiter* rate_limiter_ptr = apply_rate_limit ? rate_limiter_.get() : nullptr; - if (reactor_active) { + { IoReactor* reactor_ptr = reactor_.get(); RequestDispatcher* dispatcher_ptr = dispatcher_.get(); ThreadPool* pool_ptr = thread_pool_.get(); @@ -288,10 +271,9 @@ mygram::utils::Expected TcpServer::Start() { acceptor_->SetReactorHandler([reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, rate_limiter_ptr, max_write_bytes](int client_fd) -> bool { // Rate limit check (TCP only; rate_limiter_ptr is null on UDS acceptors). - // Mirrors the blocking path's HandleConnection: extract the peer IP via - // getpeername() and call AllowRequest(). On rejection we return false so - // the acceptor emits SERVER_BUSY + closes the fd (see - // ConnectionAcceptor::AcceptLoop). + // Extract the peer IP via getpeername() and call AllowRequest(). On + // rejection we return false so the acceptor emits SERVER_BUSY + closes + // the fd (see ConnectionAcceptor::AcceptLoop). if (rate_limiter_ptr != nullptr) { struct sockaddr_storage addr_storage {}; socklen_t addr_len = sizeof(addr_storage); @@ -323,19 +305,16 @@ mygram::utils::Expected TcpServer::Start() { max_write_bytes); auto reg = reactor_ptr->Register(conn); if (reg.has_value()) { - // Mirror the blocking path's HandleConnection: count this as an - // active connection so GetConnectionCount() and the + // Count this as an active connection so GetConnectionCount() and the // mygramdb_active_connections metric report the live reactor - // population. The matching decrement happens in the close - // callback installed above. + // population. The matching decrement happens in the close callback + // installed above. stats_ptr->IncrementConnections(); stats_ptr->IncrementTotalConnections(); return true; } return false; }); - } else { - acceptor_->SetConnectionHandler([this](int client_fd) { HandleConnection(client_fd); }); } mygram::utils::StructuredLog() @@ -399,109 +378,6 @@ void TcpServer::Stop() { mygram::utils::StructuredLog().Event("tcp_server_stopped").Field("total_requests", stats_.GetTotalRequests()).Debug(); } -void TcpServer::HandleConnection(int client_fd) { - // RAII guard to ensure FD is closed even if exceptions occur - mygram::utils::FDGuard fd_guard(client_fd); - - // Get client IP address for rate limiting - std::string client_ip; - struct sockaddr_storage addr_storage {}; - socklen_t addr_len = sizeof(addr_storage); - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - Required for POSIX socket API - if (getpeername(client_fd, reinterpret_cast(&addr_storage), &addr_len) == 0) { - if (addr_storage.ss_family == AF_INET) { - auto* addr_in = - reinterpret_cast(&addr_storage); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast) - char ip_str[INET_ADDRSTRLEN]; // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) - inet_ntop(AF_INET, &(addr_in->sin_addr), ip_str, INET_ADDRSTRLEN); - client_ip = ip_str; // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay) - } else if (addr_storage.ss_family == AF_UNIX) { - client_ip = "unix-local"; - } else { - client_ip = "unknown"; - } - } else { - client_ip = "unknown"; - } - - // Skip rate limit for UDS connections - if (rate_limiter_ && client_ip != "unix-local" && !rate_limiter_->AllowRequest(client_ip)) { - mygram::utils::StructuredLog() - .Event("server_warning") - .Field("type", "rate_limit_exceeded") - .Field("client_ip", client_ip) - .Warn(); - // Connection will be closed by fd_guard - return; - } - - // Initialize connection context - ConnectionContext ctx; - ctx.client_fd = client_fd; - ctx.debug_mode = false; - { - std::scoped_lock lock(contexts_mutex_); - connection_contexts_[client_fd] = ctx; - } - - // Increment active connection count and total connections received - stats_.IncrementConnections(); - stats_.IncrementTotalConnections(); - - // RAII guard to ensure stats are decremented even if exceptions occur - mygram::utils::ScopeGuard stats_cleanup([this]() { stats_.DecrementConnections(); }); - - // Create I/O handler config. recv_timeout_sec is YAML-configurable - // (api.tcp.recv_timeout_sec); fall back to the historical 60s default if - // it was left at zero for legacy/test configs (0 means "disable timeout" - // only when explicitly negative in config — clamp here to preserve the - // long-standing production behaviour). - const int configured_recv_timeout = - config_.recv_timeout_sec > 0 ? config_.recv_timeout_sec : kDefaultConnectionRecvTimeoutSec; - IOConfig io_config{.recv_buffer_size = static_cast(config_.recv_buffer_size), - .max_query_length = static_cast(config_.max_query_length), - .recv_timeout_sec = configured_recv_timeout}; - - // Request processor callback - auto processor = [this](const std::string& request, ConnectionContext& conn_ctx) -> std::string { - // Update context from map - { - std::scoped_lock lock(contexts_mutex_); - conn_ctx = connection_contexts_[conn_ctx.client_fd]; - } - - // Dispatch request - std::string response = dispatcher_->Dispatch(request, conn_ctx); - stats_.IncrementRequests(); - - // Update context back to map - { - std::scoped_lock lock(contexts_mutex_); - connection_contexts_[conn_ctx.client_fd] = conn_ctx; - } - - return response; - }; - - // Delegate to ConnectionIOHandler - ConnectionIOHandler io_handler(io_config, processor, shutdown_requested_); - io_handler.HandleConnection(client_fd, ctx); - - // Clean up connection context - { - std::scoped_lock lock(contexts_mutex_); - connection_contexts_.erase(client_fd); - } - - mygram::utils::StructuredLog() - .Event("connection_closed") - .Field("active_connections", static_cast(stats_.GetActiveConnections())) - .Debug(); - - // Note: FD guard will close the FD, stats_cleanup will decrement the connection count -} - #ifdef USE_MYSQL std::string TcpServer::StartSync(const std::string& table_name) { diff --git a/src/server/tcp_server.h b/src/server/tcp_server.h index 67e56ec..1c0591b 100644 --- a/src/server/tcp_server.h +++ b/src/server/tcp_server.h @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -19,7 +18,6 @@ #include "index/index.h" #include "query/query_parser.h" #include "server/connection_acceptor.h" -#include "server/connection_io_handler.h" #include "server/io_reactor.h" #include "server/rate_limiter.h" #include "server/request_dispatcher.h" @@ -115,15 +113,6 @@ class TcpServer { */ uint16_t GetPort() const { return acceptor_ ? acceptor_->GetPort() : 0; } - /** - * @brief Check whether the IoReactor is active. TEST-ONLY accessor. - * - * Returns true when reactor mode was requested, the platform multiplexer - * was available, and Start() successfully started the event loop. - * Do not call this from production code. - */ - bool IsReactorActiveForTest() const { return reactor_ != nullptr && reactor_->IsRunning(); } - /** * @brief Get active connection count */ @@ -212,7 +201,7 @@ class TcpServer { std::unique_ptr thread_pool_; std::unique_ptr acceptor_; std::unique_ptr dispatcher_; - std::unique_ptr reactor_; ///< Non-null when io_model == "reactor" and a backend is available. + std::unique_ptr reactor_; ///< Owns the event loop. Non-null after a successful Start(). std::unique_ptr scheduler_; std::unique_ptr cache_manager_; std::unique_ptr variable_manager_; @@ -223,8 +212,6 @@ class TcpServer { // Legacy fields (for backward compatibility during migration) std::unordered_map table_contexts_; - std::unordered_map connection_contexts_; - mutable std::mutex contexts_mutex_; #ifdef USE_MYSQL mysql::BinlogReader* binlog_reader_; @@ -250,11 +237,6 @@ class TcpServer { // Shutdown flag std::atomic shutdown_requested_{false}; - - /** - * @brief Handle client connection (callback for ConnectionAcceptor) - */ - void HandleConnection(int client_fd); }; } // namespace mygramdb::server diff --git a/src/server/thread_pool.cpp b/src/server/thread_pool.cpp index 225b35c..0aeb869 100644 --- a/src/server/thread_pool.cpp +++ b/src/server/thread_pool.cpp @@ -17,19 +17,15 @@ namespace mygramdb::server { ThreadPool::ThreadPool(size_t num_threads, size_t queue_size) : max_queue_size_(queue_size) { // Auto-size the pool when not specified. // - // Under the Phase 3 default reactor I/O model, persistent client connections - // do NOT pin worker threads — they live in the reactor's connection map and - // only consume a worker briefly (via a drain task) when a complete command + // Under the reactor I/O model, persistent client connections do NOT pin + // worker threads — they live in the reactor's connection map and only + // consume a worker briefly (via a drain task) when a complete command // frame arrives. Consequently the worker count no longer has to scale with // the concurrent-connection count; scaling by CPU count is sufficient. // // The floor of 4 keeps small VMs and containers responsive even when // `hardware_concurrency()` reports a very small value (e.g. 1-2 cores) and // gives the reactor somewhere to land burst dispatch tasks. - // - // Operators running the legacy blocking I/O model on a persistent-client - // fleet should set `api.tcp.worker_threads` explicitly (or switch back to - // `io_model: blocking` which is still supported as an emergency lever). if (num_threads == 0) { unsigned hw = std::thread::hardware_concurrency(); if (hw == 0) { diff --git a/tests/integration/server/CMakeLists.txt b/tests/integration/server/CMakeLists.txt index a4b3c15..c4ac3b1 100644 --- a/tests/integration/server/CMakeLists.txt +++ b/tests/integration/server/CMakeLists.txt @@ -26,7 +26,6 @@ target_link_libraries(multi_table_integration_test mygramdb_server GTest::gtest_main ) -target_include_directories(multi_table_integration_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) # RESOURCE_LOCK: Prevent parallel execution to avoid port binding conflicts gtest_discover_tests(multi_table_integration_test @@ -35,21 +34,6 @@ gtest_discover_tests(multi_table_integration_test PROPERTIES RESOURCE_LOCK server_port ) -# Dual-mode CI (design doc Phase 2.6, deferred to Phase 3): the gtest_discover_tests -# call above registers the binary's tests under the reactor default. Add a second -# whole-binary ctest entry that runs the same binary with MYGRAMDB_TEST_IO_MODEL=blocking -# so the blocking fallback I/O model keeps integration coverage. -add_test( - NAME multi_table_integration_test.BlockingMode - COMMAND multi_table_integration_test -) -set_tests_properties(multi_table_integration_test.BlockingMode PROPERTIES - ENVIRONMENT "MYGRAMDB_TEST_IO_MODEL=blocking" - LABELS "INTEGRATION_BLOCKING" - RESOURCE_LOCK server_port - TIMEOUT 120 -) - # End-to-End Integration Tests add_executable(end_to_end_integration_test end_to_end_test.cpp @@ -59,7 +43,6 @@ target_link_libraries(end_to_end_integration_test mygramdb_server GTest::gtest_main ) -target_include_directories(end_to_end_integration_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) # RESOURCE_LOCK: Prevent parallel execution to avoid port binding conflicts gtest_discover_tests(end_to_end_integration_test @@ -68,18 +51,6 @@ gtest_discover_tests(end_to_end_integration_test PROPERTIES RESOURCE_LOCK server_port ) -# Dual-mode CI: re-run the same binary with MYGRAMDB_TEST_IO_MODEL=blocking. -add_test( - NAME end_to_end_integration_test.BlockingMode - COMMAND end_to_end_integration_test -) -set_tests_properties(end_to_end_integration_test.BlockingMode PROPERTIES - ENVIRONMENT "MYGRAMDB_TEST_IO_MODEL=blocking" - LABELS "INTEGRATION_BLOCKING" - RESOURCE_LOCK server_port - TIMEOUT 120 -) - # Stress Tests add_executable(stress_test stress_test.cpp @@ -101,10 +72,9 @@ gtest_discover_tests(stress_test # Thread pool saturation regression tests # -# Regression gate for the blocking I/O model's starvation failure mode: -# ConnectionIOHandler holds one worker thread per persistent connection for -# its entire lifetime, so W idle clients starve every subsequent request -# until recv() idle timeouts fire. +# Positive-control suite for the reactor I/O model: confirms that idle +# persistent clients do NOT pin worker threads and that late clients are +# served promptly even when many persistent clients are connected. # # LOAD-labeled so it runs only via `make test-load` / `ctest -L LOAD`, # not in `make test-fast` / CI. @@ -154,7 +124,6 @@ target_link_libraries(verify_text_integration_test mygramdb_server GTest::gtest_main ) -target_include_directories(verify_text_integration_test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) # RESOURCE_LOCK: Prevent parallel execution to avoid port binding and file I/O conflicts gtest_discover_tests(verify_text_integration_test @@ -164,25 +133,11 @@ gtest_discover_tests(verify_text_integration_test RESOURCE_LOCK server_port ) -# Dual-mode CI: re-run the same binary with MYGRAMDB_TEST_IO_MODEL=blocking. -add_test( - NAME verify_text_integration_test.BlockingMode - COMMAND verify_text_integration_test -) -set_tests_properties(verify_text_integration_test.BlockingMode PROPERTIES - ENVIRONMENT "MYGRAMDB_TEST_IO_MODEL=blocking" - LABELS "INTEGRATION_BLOCKING" - RESOURCE_LOCK server_port - TIMEOUT 120 -) - # Reactor starvation regression tests (Phase 2.T7) # -# Goal test: reactor mode must NOT exhibit the blocking I/O model's -# starvation failure. Three tests: -# T1 — positive control: reactor with 128 persistent clients + late client -# T2 — throughput: 256 clients × 10 INFO requests, no ERR SERVER_BUSY -# T3 — negative control: blocking mode starves under 8 persistent clients +# Reactor-mode invariant checks: +# T1 — 128 persistent clients + late client served promptly +# T2 — 256 clients × 10 INFO requests, no ERR SERVER_BUSY add_executable(reactor_starvation_regression_test reactor_starvation_regression_test.cpp ) @@ -203,9 +158,8 @@ gtest_discover_tests(reactor_starvation_regression_test # Reactor I/O model integration tests (Phase 2.T6) # -# Exercises the end-to-end reactor path: config io_model="reactor" -> -# IoReactor (epoll/kqueue) -> ReactorConnection drain-task pattern -> -# RequestDispatcher. Tests skip at runtime on platforms without epoll/kqueue. +# Exercises the end-to-end reactor path: IoReactor (epoll/kqueue) -> +# ReactorConnection drain-task pattern -> RequestDispatcher. add_executable(reactor_integration_test reactor_integration_test.cpp ) diff --git a/tests/integration/server/end_to_end_test.cpp b/tests/integration/server/end_to_end_test.cpp index 4a1f841..b006411 100644 --- a/tests/integration/server/end_to_end_test.cpp +++ b/tests/integration/server/end_to_end_test.cpp @@ -15,7 +15,6 @@ #include "config/config.h" #include "server/tcp_server.h" -#include "test_io_model_override.h" using namespace mygramdb::server; using namespace mygramdb; @@ -87,7 +86,6 @@ class EndToEndTest : public ::testing::Test { config_.port = 0; // Random port config_.host = "127.0.0.1"; config_.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(config_); server_ = std::make_unique(config_, table_contexts_, "./snapshots", nullptr); ASSERT_TRUE(server_->Start()); diff --git a/tests/integration/server/multi_table_test.cpp b/tests/integration/server/multi_table_test.cpp index b806d8d..fc11894 100644 --- a/tests/integration/server/multi_table_test.cpp +++ b/tests/integration/server/multi_table_test.cpp @@ -17,7 +17,6 @@ #include "config/config.h" #include "server/tcp_server.h" -#include "test_io_model_override.h" #ifdef USE_MYSQL #include "mysql/binlog_reader.h" @@ -69,7 +68,6 @@ TEST(TcpServerMultiTableTest, MultiTableSearch) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts, "./snapshots", nullptr); ASSERT_TRUE(server.Start()); @@ -169,7 +167,6 @@ TEST(TcpServerMultiTableTest, MultiTableCount) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts); ASSERT_TRUE(server.Start()); @@ -251,7 +248,6 @@ TEST(TcpServerMultiTableTest, MultiTableGet) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts); ASSERT_TRUE(server.Start()); @@ -349,7 +345,6 @@ TEST(TcpServerMultiTableTest, MultiTableInfo) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts); ASSERT_TRUE(server.Start()); @@ -420,7 +415,6 @@ TEST(TcpServerMultiTableTest, TableIsolation) { config.port = 0; config.host = "127.0.0.1"; config.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(config); mygramdb::server::TcpServer server(config, table_contexts); ASSERT_TRUE(server.Start()); diff --git a/tests/integration/server/reactor_integration_test.cpp b/tests/integration/server/reactor_integration_test.cpp index 41737bb..1ccb532 100644 --- a/tests/integration/server/reactor_integration_test.cpp +++ b/tests/integration/server/reactor_integration_test.cpp @@ -1,16 +1,12 @@ /** * @file reactor_integration_test.cpp - * @brief Integration tests for the reactor I/O model against a real TcpServer. + * @brief Integration tests for the reactor I/O path against a real TcpServer. * * These tests exercise the end-to-end reactor path: - * config_.io_model == "reactor" - * -> IoReactor (epoll on Linux, kqueue on macOS) + * IoReactor (epoll on Linux, kqueue on macOS) * -> ReactorConnection per-fd drain-task pattern * -> RequestDispatcher -> INFO handler -> response written on worker thread * - * On platforms with no supported event multiplexer (not Linux, macOS, or - * BSD), the fixture skips all tests at runtime via GTEST_SKIP(). - * * Labeled "INTEGRATION" — included in `ctest -L INTEGRATION`. */ @@ -88,11 +84,7 @@ class ReactorIntegrationTest : public ::testing::Test { // ------------------------------------------------------------------------- /** - * @brief Start a TcpServer in reactor mode and return it. - * - * If the platform has no supported event multiplexer the reactor silently - * falls back to blocking mode. Callers that need reactor mode specifically - * should check `server->IsReactorActiveForTest()` and GTEST_SKIP if false. + * @brief Start a TcpServer and return it. */ std::unique_ptr StartServer(int worker_threads = 8, int max_connections = 512, int64_t max_write_queue_bytes = 0) { @@ -102,7 +94,6 @@ class ReactorIntegrationTest : public ::testing::Test { cfg.worker_threads = worker_threads; cfg.max_connections = max_connections; cfg.allow_cidrs = {"127.0.0.1/32"}; - cfg.io_model = "reactor"; if (max_write_queue_bytes > 0) { cfg.max_write_queue_bytes = max_write_queue_bytes; } @@ -116,17 +107,6 @@ class ReactorIntegrationTest : public ::testing::Test { return s; } - /** - * @brief Require reactor mode; skip the test if the server fell back to - * blocking (happens when no epoll/kqueue factory is available). - */ - static void RequireReactor(const TcpServer& server) { - if (!server.IsReactorActiveForTest()) { - GTEST_SKIP() << "IoReactor is not active on this build/platform " - "(no epoll/kqueue available); skipping reactor-specific test."; - } - } - // ------------------------------------------------------------------------- // Network helpers — mirrors ThreadPoolSaturationTest for API consistency // ------------------------------------------------------------------------- @@ -283,7 +263,6 @@ class ReactorIntegrationTest : public ::testing::Test { */ TEST_F(ReactorIntegrationTest, InfoCommandRoundtrip) { auto server = StartServer(); - RequireReactor(*server); uint16_t port = server->GetPort(); int s = Connect(port); @@ -306,7 +285,6 @@ TEST_F(ReactorIntegrationTest, InfoCommandRoundtrip) { */ TEST_F(ReactorIntegrationTest, MultipleSequentialCommands) { auto server = StartServer(); - RequireReactor(*server); uint16_t port = server->GetPort(); int s = Connect(port); @@ -335,7 +313,6 @@ TEST_F(ReactorIntegrationTest, MultipleSequentialCommands) { */ TEST_F(ReactorIntegrationTest, PersistentConnectionPipelining) { auto server = StartServer(); - RequireReactor(*server); uint16_t port = server->GetPort(); int s = Connect(port); @@ -368,7 +345,6 @@ TEST_F(ReactorIntegrationTest, PersistentConnectionPipelining) { */ TEST_F(ReactorIntegrationTest, ConcurrentClients100) { auto server = StartServer(/*worker_threads=*/8); - RequireReactor(*server); uint16_t port = server->GetPort(); constexpr int kClients = 100; @@ -432,7 +408,6 @@ TEST_F(ReactorIntegrationTest, ConcurrentClients100) { */ TEST_F(ReactorIntegrationTest, ConcurrentClientsMany) { auto server = StartServer(/*worker_threads=*/16); - RequireReactor(*server); uint16_t port = server->GetPort(); // Each client needs ~2 fds (client-side sock + server-side sock) plus @@ -512,7 +487,6 @@ TEST_F(ReactorIntegrationTest, ConcurrentClientsMany) { */ TEST_F(ReactorIntegrationTest, ClientDisconnectMidRequest) { auto server = StartServer(); - RequireReactor(*server); uint16_t port = server->GetPort(); // Abrupt client @@ -561,7 +535,6 @@ TEST_F(ReactorIntegrationTest, ClientDisconnectMidRequest) { */ TEST_F(ReactorIntegrationTest, ClientDisconnectDuringResponse) { auto server = StartServer(); - RequireReactor(*server); uint16_t port = server->GetPort(); // Attempt to trigger EPIPE: send INFO, read 1 byte, close immediately @@ -606,7 +579,6 @@ TEST_F(ReactorIntegrationTest, ClientDisconnectDuringResponse) { */ TEST_F(ReactorIntegrationTest, GracefulShutdownWithActiveClients) { auto server = StartServer(); - RequireReactor(*server); uint16_t port = server->GetPort(); constexpr int kPersistentClients = 10; @@ -658,16 +630,13 @@ TEST_F(ReactorIntegrationTest, GracefulShutdownWithActiveClients) { // ============================================================================ /** - * After Start(), IsReactorActiveForTest() must return true (handled by - * RequireReactor which would skip otherwise). Additionally verify that - * zero clients are connected at baseline. + * After Start(), zero clients are connected at baseline and one request + * routes through the reactor. */ TEST_F(ReactorIntegrationTest, BackendIsReactor) { auto server = StartServer(); - RequireReactor(*server); // Reactor is running; no clients yet. - EXPECT_TRUE(server->IsReactorActiveForTest()); EXPECT_EQ(server->GetConnectionCount(), 0U); // One quick request to confirm it actually routes through the reactor. @@ -679,7 +648,6 @@ TEST_F(ReactorIntegrationTest, BackendIsReactor) { close(s); server->Stop(); - EXPECT_FALSE(server->IsReactorActiveForTest()); } // ============================================================================ @@ -697,7 +665,6 @@ TEST_F(ReactorIntegrationTest, ReactorModeDoesNotStarvePersistentFleet) { // reactor degraded to one-worker-per-connection. constexpr int kWorkers = 4; auto server = StartServer(kWorkers); - RequireReactor(*server); uint16_t port = server->GetPort(); // Pin 8 persistent idle clients (> kWorkers to stress-test) @@ -745,7 +712,6 @@ TEST_F(ReactorIntegrationTest, ReactorModeDoesNotStarvePersistentFleet) { */ TEST_F(ReactorIntegrationTest, ClientSendsLargeFrame) { auto server = StartServer(); - RequireReactor(*server); uint16_t port = server->GetPort(); // --- Sub-cap frame (slightly under 1 MiB) --- @@ -851,7 +817,6 @@ TEST_F(ReactorIntegrationTest, WriteBackpressureHandledGracefully) { // non-reading peer will exceed it within a few hundred milliseconds. constexpr int64_t kCapBytes = 64 * 1024; auto server = StartServer(/*worker_threads=*/4, /*max_connections=*/64, kCapBytes); - RequireReactor(*server); uint16_t port = server->GetPort(); // ------------------------------------------------------------------------- @@ -1004,7 +969,6 @@ TEST_F(ReactorIntegrationTest, ManyIdleConnectionsDoNotBlockActiveClient) { // worker count does NOT have to scale with the idle-connection count. constexpr int kWorkers = 8; auto server = StartServer(kWorkers, /*max_connections=*/static_cast(idle_count + 64)); - RequireReactor(*server); uint16_t port = server->GetPort(); // Open idle_count persistent clients: each sends one INFO to prove the @@ -1070,27 +1034,16 @@ TEST_F(ReactorIntegrationTest, ManyIdleConnectionsDoNotBlockActiveClient) { } // ============================================================================ -// Phase 3.7 gap regression guards +// Reactor-path regression guards // ============================================================================ // -// The tests below pin reactor-path invariants that were *silently* lost when -// the default io_model flipped to "reactor" in Phase 3. The blocking path's -// HandleConnection historically enforced rate limiting and max_query_length -// and handled UDS fds; the initial reactor implementation did not plumb any -// of this through. These tests fail on the Phase 3 code so the gap cannot be -// reintroduced, and must stay green through Phase 4 (blocking removal). +// These tests pin reactor-path invariants for rate limiting, max_query_length +// enforcement, and UDS handling. They must stay green. // ---------------------------------------------------------------------------- -// Gap A — Rate limiter wiring +// Rate limiter wiring // ---------------------------------------------------------------------------- // -// The blocking path called `rate_limiter_->AllowRequest(client_ip)` in -// TcpServer::HandleConnection (tcp_server.cpp historical line ~410). The -// reactor path has no such call site: reactor_connection.cpp and -// io_reactor.cpp have zero references to `rate_limit`. With reactor as the -// default, any user who set `api.rate_limiting.enable = true` now gets -// silently unmetered traffic. -// // This test configures a hard cap (capacity=2, refill_rate=0), opens three // connections from 127.0.0.1, and expects the third to be closed without a // response. @@ -1107,11 +1060,9 @@ TEST_F(ReactorIntegrationTest, RateLimitEnforcedInReactorMode) { cfg.worker_threads = 4; cfg.max_connections = 64; cfg.allow_cidrs = {"127.0.0.1/32"}; - cfg.io_model = "reactor"; auto server = std::make_unique(cfg, table_contexts_, "./dumps", &full_config); ASSERT_TRUE(server->Start()) << "TcpServer::Start failed"; - RequireReactor(*server); const uint16_t port = server->GetPort(); auto open_and_info = [&](int idx) -> std::string { @@ -1147,15 +1098,9 @@ TEST_F(ReactorIntegrationTest, RateLimitEnforcedInReactorMode) { } // ---------------------------------------------------------------------------- -// Gap B — max_query_length enforcement +// max_query_length enforcement // ---------------------------------------------------------------------------- // -// ReactorConnection currently caps the read buffer at a hardcoded -// `kMaxReadBufferBytes = 1 MiB`, ignoring `ServerConfig::max_query_length`. -// The blocking ConnectionIOHandler path used the configured value to drop -// over-large frames. A user who lowered max_query_length for DoS defence -// gets no protection from the reactor path. -// // This test sets max_query_length=512, sends a ~4 KiB SEARCH query, and // expects the connection to be closed (or the request rejected) rather // than successfully executed. @@ -1166,12 +1111,10 @@ TEST_F(ReactorIntegrationTest, MaxQueryLengthEnforcedInReactorMode) { cfg.worker_threads = 4; cfg.max_connections = 64; cfg.allow_cidrs = {"127.0.0.1/32"}; - cfg.io_model = "reactor"; cfg.max_query_length = 512; // deliberately tiny auto server = std::make_unique(cfg, table_contexts_); ASSERT_TRUE(server->Start()) << "TcpServer::Start failed"; - RequireReactor(*server); const uint16_t port = server->GetPort(); int s = Connect(port); @@ -1249,14 +1192,10 @@ TEST_F(ReactorIntegrationTest, UnixSocketServedUnderReactorDefault) { cfg.worker_threads = 4; cfg.max_connections = 64; cfg.allow_cidrs = {"127.0.0.1/32"}; - cfg.io_model = "reactor"; cfg.unix_socket_path = sock_path.string(); auto server = std::make_unique(cfg, table_contexts_); ASSERT_TRUE(server->Start()) << "TcpServer::Start failed"; - // Note: we do NOT RequireReactor here — the UDS path may currently be - // blocking. The goal is that UDS works *regardless* of io_model so we can - // delete the blocking path in Phase 4 without breaking UDS. // Connect via AF_UNIX int s = socket(AF_UNIX, SOCK_STREAM, 0); diff --git a/tests/integration/server/reactor_starvation_regression_test.cpp b/tests/integration/server/reactor_starvation_regression_test.cpp index 54b16cb..b788631 100644 --- a/tests/integration/server/reactor_starvation_regression_test.cpp +++ b/tests/integration/server/reactor_starvation_regression_test.cpp @@ -1,23 +1,16 @@ /** * @file reactor_starvation_regression_test.cpp - * @brief Phase 2.T7 — GOAL test: reactor mode must NOT exhibit the blocking - * I/O model's starvation failure. + * @brief Reactor-mode invariant: decouples the concurrent-client count from + * the worker pool size. * - * The blocking I/O model pins one worker thread per persistent TCP connection. - * When the number of idle persistent clients >= worker pool size, no newly- - * submitted task makes progress until a pinned recv() idle timeout fires. - * In production this manifested as queue full + 5xx cascades. + * The reactor I/O model uses an epoll/kqueue event loop + drain-task-per- + * connection workers, so persistent idle clients do NOT pin worker threads. + * These tests prove the invariant holds. * - * The reactor I/O model (Phase 2) replaces this with an epoll/kqueue event - * loop + drain-task-per-connection workers, decoupling the concurrent-client - * count from the worker pool size. These tests prove the replacement works. - * - * Test 1 (positive control): reactor mode with 128 persistent clients + 1 late - * client, worker_threads=2 — late client MUST get a response within 500 ms. - * Test 2 (throughput): 256 persistent clients each sending 10 INFO requests — + * Test 1: 128 persistent clients + 1 late client, worker_threads=2 — late + * client MUST get a response within 500 ms. + * Test 2: 128 persistent clients each sending 10 INFO requests — * no ERR SERVER_BUSY, all responses are OK INFO. - * Test 3 (negative control): blocking mode with 8 idle clients, worker_threads=2 - * — late client MUST NOT get a response within 1.5 s. * * Labeled "INTEGRATION" — runs via `ctest -L INTEGRATION`. * RESOURCE_LOCK "server_port" — each test binds a real OS port. @@ -177,57 +170,23 @@ class ReactorStarvationRegressionTest : public ::testing::Test { return ""; } - /** - * @brief Read a single-line response (no internal CRLFs) terminated by `\r\n`. - * - * Used by the blocking-mode negative control test, where the late client - * must receive NO response at all — so we only need to observe the empty - * string return on timeout. - */ - std::string RecvLine(int sock, int timeout_ms = 2000) { - struct timeval tv{}; - tv.tv_sec = timeout_ms / 1000; - tv.tv_usec = (timeout_ms % 1000) * 1000; - setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); - - std::string out; - std::array buf{}; - while (out.size() < 8192) { - ssize_t n = recv(sock, buf.data(), buf.size(), 0); - if (n <= 0) { - return ""; - } - out.append(buf.data(), static_cast(n)); - if (out.find("\r\n") != std::string::npos) { - break; - } - } - auto pos = out.find("\r\n"); - if (pos != std::string::npos) { - out.resize(pos); - } - return out; - } - // ------------------------------------------------------------------------- // Server factory // ------------------------------------------------------------------------- - std::unique_ptr StartServer(const std::string& io_model, int worker_threads, - int max_connections = 512) { + std::unique_ptr StartServer(int worker_threads, int max_connections = 512) { ServerConfig cfg; cfg.host = "127.0.0.1"; cfg.port = 0; cfg.worker_threads = worker_threads; cfg.max_connections = max_connections; - cfg.io_model = io_model; cfg.allow_cidrs = {"127.0.0.1/32"}; // Disable recv timeout so idle persistent clients don't self-terminate // during the test; the starvation window is deliberately short. cfg.recv_timeout_sec = 0; auto s = std::make_unique(cfg, table_contexts_); auto res = s->Start(); - EXPECT_TRUE(res) << "Failed to start TcpServer (" << io_model - << "): " << (res ? std::string{} : res.error().to_string()); + EXPECT_TRUE(res) << "Failed to start TcpServer: " + << (res ? std::string{} : res.error().to_string()); // Give the accept loop a moment to reach its main select/epoll/kqueue call. std::this_thread::sleep_for(std::chrono::milliseconds(50)); return s; @@ -259,14 +218,13 @@ class ReactorStarvationRegressionTest : public ::testing::Test { }; // --------------------------------------------------------------------------- -// Test 1 — Positive control: reactor serves 128 persistent clients without -// starving a late client (worker_threads = 2). +// Test 1 — Reactor serves 128 persistent clients without starving a late +// client (worker_threads = 2). // --------------------------------------------------------------------------- /** - * Pin 128 persistent idle clients against a 2-worker reactor server. - * In the blocking model this is impossible: only 2 clients would ever reach - * a worker. In reactor mode the event loop dispatches all 128 initial INFO - * responses, and the 129th (late) client still gets a reply within 500 ms. + * Pin 128 persistent idle clients against a 2-worker reactor server. The + * event loop dispatches all 128 initial INFO responses, and the 129th + * (late) client still gets a reply within 500 ms. */ TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarvation) { // Need at least 256 fds: 128 pinned + 1 late + server-side fds + overhead. @@ -279,19 +237,11 @@ TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarv constexpr int kWorkers = 2; constexpr int kPinnedClients = 128; - auto server = StartServer("reactor", kWorkers, /*max_connections=*/512); + auto server = StartServer(kWorkers, /*max_connections=*/512); uint16_t port = server->GetPort(); - // Skip if the reactor backend is not available on this platform. - if (!server->IsReactorActiveForTest()) { - server->Stop(); - GTEST_SKIP() << "Reactor backend not available on this platform (fell back to " - "blocking mode). Skipping reactor-specific test."; - } - // --- Pin kPinnedClients persistent idle clients --- // Each sends INFO once (to exercise the reactor's drain path), then idles. - // In blocking mode the 3rd client onward would not get a response at all. std::vector pinned; pinned.reserve(kPinnedClients); int pin_failures = 0; @@ -342,10 +292,8 @@ TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarv << " pinned clients received their initial INFO response. " "The reactor event loop did not dispatch all connections."; - // All pinned clients are now idle (last recv() returned, no new send). - // In blocking mode the workers would be idle-looping in recv() for each. - // In reactor mode the workers are free; the event loop is the only thing - // monitoring those fds. + // All pinned clients are now idle. In reactor mode the workers are free; + // the event loop is the only thing monitoring those fds. // --- Late client --- int late = Connect(port); @@ -382,14 +330,14 @@ TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarv } // --------------------------------------------------------------------------- -// Test 2 — Throughput: 256 persistent clients × 10 INFO requests, no +// Test 2 — Throughput: 128 persistent clients × 10 INFO requests, no // ERR SERVER_BUSY, all responses are "OK INFO". // --------------------------------------------------------------------------- /** - * Open 256 connections and send 10 sequential INFO requests on each. With - * only 2 worker threads in blocking mode this would deadlock immediately. - * In reactor mode the event loop processes reads and dispatches drain tasks - * back-to-back on the small pool, and all 2560 responses arrive correctly. + * Open 128 connections and send 10 sequential INFO requests on each. In + * reactor mode the event loop processes reads and dispatches drain tasks + * back-to-back on a small worker pool, and all 1280 responses arrive + * correctly. */ TEST_F(ReactorStarvationRegressionTest, ReactorHighConcurrencyShowsNoQueueFull) { // 256 client fds + server-side fds + overhead. @@ -406,14 +354,9 @@ TEST_F(ReactorStarvationRegressionTest, ReactorHighConcurrencyShowsNoQueueFull) constexpr int kRequestsPerClient = 10; constexpr int kExpectedTotal = kClients * kRequestsPerClient; - auto server = StartServer("reactor", kWorkers, /*max_connections=*/512); + auto server = StartServer(kWorkers, /*max_connections=*/512); uint16_t port = server->GetPort(); - if (!server->IsReactorActiveForTest()) { - server->Stop(); - GTEST_SKIP() << "Reactor backend not available on this platform."; - } - // Open kClients connections. std::vector clients; clients.reserve(kClients); @@ -493,82 +436,4 @@ TEST_F(ReactorStarvationRegressionTest, ReactorHighConcurrencyShowsNoQueueFull) server->Stop(); } -// --------------------------------------------------------------------------- -// Test 3 — Negative control: blocking mode starves under the same load. -// --------------------------------------------------------------------------- -/** - * Pin 8 idle persistent clients against a 2-worker BLOCKING server. - * The late client's INFO MUST NOT arrive within 1.5 s, proving that the - * starvation mechanism is real and the reactor test is discriminating. - * - * If this test ever starts failing (blocking mode becomes responsive), either - * (a) the thread pool was enlarged beyond the pinned-client count, or - * (b) the blocking model was silently replaced with a reactor. Either way, - * the discriminating property of Test 1 is no longer valid and both tests - * need to be reviewed. - */ -TEST_F(ReactorStarvationRegressionTest, BlockingModeStarvesUnderSameLoad) { - constexpr int kWorkers = 2; - constexpr int kPinnedClients = 8; // > kWorkers → guaranteed starvation - - auto server = StartServer("blocking", kWorkers, /*max_connections=*/512); - uint16_t port = server->GetPort(); - - // The blocking model must be engaged; if somehow the reactor activated, - // skip rather than give a false-green result. - if (server->IsReactorActiveForTest()) { - server->Stop(); - GTEST_SKIP() << "Reactor is active even though io_model=blocking was requested. " - "Blocking-mode negative control is not valid in this configuration."; - } - - // --- Pin kPinnedClients persistent idle clients --- - std::vector pinned; - pinned.reserve(kPinnedClients); - for (int i = 0; i < kPinnedClients; ++i) { - int s = Connect(port); - ASSERT_GE(s, 0) << "Failed to connect pinning client " << i; - ASSERT_TRUE(SendLine(s, "INFO")); - // Receive the first response (this uses one worker during HandleConnection - // setup; the worker then loops back into blocking recv()). - std::string resp = RecvLine(s, /*timeout_ms=*/2000); - // Only the first kWorkers clients will actually get a response; the rest - // will time out because all workers are pinned. Accept either outcome — - // the important assertion is on the late client below. - (void)resp; - pinned.push_back(s); - } - - // Give workers time to return to their blocking recv() loops. - std::this_thread::sleep_for(std::chrono::milliseconds(300)); - - // --- Late client --- - int late = Connect(port); - ASSERT_GE(late, 0) << "Failed to connect late client"; - ASSERT_TRUE(SendLine(late, "INFO")); - - auto t0 = std::chrono::steady_clock::now(); - std::string resp = RecvLine(late, /*timeout_ms=*/1500); - auto elapsed_ms = - std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) - .count(); - - // This is the permanent regression gate. If this assertion ever fails, the - // blocking connection model has been replaced and Test 1 + Test 2 above are - // the definitive PASS criteria. - EXPECT_TRUE(resp.empty()) - << "Blocking-mode late INFO was served in " << elapsed_ms - << "ms despite all " << kWorkers - << " workers being pinned by " << kPinnedClients - << " idle persistent clients. Has the connection-per-worker model been " - "replaced? If so, update the negative control to expect success."; - - std::cout << "[T3] blocking_late_client_elapsed_ms=" << elapsed_ms - << " (expected: no response within 1500ms)" << std::endl; - - close(late); - for (int s : pinned) close(s); - server->Stop(); -} - } // namespace mygramdb::server diff --git a/tests/integration/server/test_io_model_override.h b/tests/integration/server/test_io_model_override.h deleted file mode 100644 index f9bf643..0000000 --- a/tests/integration/server/test_io_model_override.h +++ /dev/null @@ -1,48 +0,0 @@ -/** - * @file test_io_model_override.h - * @brief Shared helper for dual-mode CI: lets integration tests pick up an - * `io_model` override from the environment at runtime. - * - * Design doc Phase 2.6 (deferred to Phase 3): we want the same integration - * test binary to be exercised under both `io_model=reactor` (the Phase 3 - * default) and `io_model=blocking` (the fallback). Rather than duplicate - * the test fixtures, the test reads `MYGRAMDB_TEST_IO_MODEL` once at setup - * and applies it to its `ServerConfig`. CMake registers a second ctest - * entry per test binary with that environment variable set to "blocking", - * giving us "two runs, one binary". - * - * Usage in a test fixture's SetUp(): - * - * ServerConfig config_; - * mygramdb::server::test::ApplyIoModelOverride(config_); - * // ... rest of setup ... - */ -#pragma once - -#include -#include - -#include "server/server_types.h" - -namespace mygramdb::server::test { - -/** - * @brief Apply the `MYGRAMDB_TEST_IO_MODEL` environment variable to the - * given `ServerConfig`, if set. - * - * Recognised values: "reactor", "blocking". Any other value is ignored - * (the config's existing io_model is left untouched). If the environment - * variable is unset the function is a no-op. - */ -inline void ApplyIoModelOverride(ServerConfig& config) { - const char* env = std::getenv("MYGRAMDB_TEST_IO_MODEL"); - if (env == nullptr) { - return; - } - const std::string value(env); - if (value == "reactor" || value == "blocking") { - config.io_model = value; - } -} - -} // namespace mygramdb::server::test diff --git a/tests/integration/server/thread_pool_saturation_test.cpp b/tests/integration/server/thread_pool_saturation_test.cpp index 59aee8a..5b26fbf 100644 --- a/tests/integration/server/thread_pool_saturation_test.cpp +++ b/tests/integration/server/thread_pool_saturation_test.cpp @@ -1,26 +1,13 @@ /** * @file thread_pool_saturation_test.cpp - * @brief Regression tests anchoring the thread-pool / I/O-model invariants. + * @brief Regression tests anchoring the reactor I/O model's thread-pool + * invariants. * - * Historical context: under the legacy blocking I/O model, - * ConnectionIOHandler::HandleConnection() held one worker thread for the - * entire lifetime of a client connection. With a small worker pool, - * idle-but-persistent clients could pin every worker, at which point newly - * accepted connections piled up in the task queue until it overflowed and - * the acceptor began writing "ERR SERVER_BUSY" + close() on new sockets. - * - * After the Phase 3 reactor refactor, the default I/O model is "reactor", - * so persistent idle connections no longer pin workers at all. The tests - * below therefore split into two groups: - * - * 1. Reactor-default invariants (no forced io_model): verify the new - * default model serves late clients promptly even when the worker - * pool is tiny and many persistent clients are holding connections. - * 2. Blocking-mode legacy invariants (explicit io_model="blocking"): - * preserve the original starvation and queue-overflow regression - * gates for the fallback/rollback I/O model. These still matter - * because operators can flip back to blocking mode via YAML, and the - * blocking path is not going away until Phase 4. + * Under the reactor I/O model, persistent idle connections live in the + * epoll/kqueue registration map and do NOT pin worker threads. The tests + * below verify that invariant: late clients must be served promptly even + * when the worker pool is tiny and many persistent clients are holding + * connections. * * Labeled "LOAD" — excluded from `make test-fast` / CI and only run via * `make test-load` or `ctest -L LOAD`. @@ -30,16 +17,14 @@ #include #include #include -#include #include #include #include -#include +#include #include #include #include -#include #include #include #include @@ -166,17 +151,13 @@ class ThreadPoolSaturationTest : public ::testing::Test { return out; } - std::unique_ptr StartServer(int worker_threads, int max_connections = 256, - const std::string& io_model = std::string{}) { + std::unique_ptr StartServer(int worker_threads, int max_connections = 256) { ServerConfig cfg; cfg.host = "127.0.0.1"; cfg.port = 0; cfg.worker_threads = worker_threads; cfg.max_connections = max_connections; cfg.allow_cidrs = {"127.0.0.1/32"}; - if (!io_model.empty()) { - cfg.io_model = io_model; - } auto s = std::make_unique(cfg, table_contexts_); auto res = s->Start(); EXPECT_TRUE(res) << "Failed to start TcpServer: " @@ -186,52 +167,26 @@ class ThreadPoolSaturationTest : public ::testing::Test { return s; } - /** - * @brief Try to raise the per-process FD limit (for the queue-overflow - * test which opens >1000 sockets). Returns the effective cap. - */ - static rlim_t RaiseFdLimit(rlim_t desired) { - struct rlimit rl {}; - if (getrlimit(RLIMIT_NOFILE, &rl) != 0) { - return 0; - } - rlim_t target = std::min(desired, rl.rlim_max); - if (rl.rlim_cur < target) { - rl.rlim_cur = target; - setrlimit(RLIMIT_NOFILE, &rl); // Best-effort - getrlimit(RLIMIT_NOFILE, &rl); - } - return rl.rlim_cur; - } - std::unique_ptr table_ctx_; std::unordered_map table_contexts_; }; /** - * Phase 3 inversion of the historical starvation gate. - * - * Under the legacy blocking I/O model this test asserted that a late client - * could NOT be served when idle persistent clients had pinned every worker - * thread. Phase 3 makes "reactor" the default I/O model (see - * ApiConfig::tcp::io_model), and in that model persistent idle connections + * Reactor invariant: a late client MUST be served promptly even when + * `worker_threads` is tiny and matches (or is below) the idle-persistent- + * client count. Under the reactor I/O model, persistent idle connections * live in the epoll/kqueue registration map rather than parking worker - * threads. The assertion therefore flips: with the default I/O model, a - * late client MUST be served promptly even when `worker_threads` is tiny - * and matches (or is below) the idle-persistent-client count. + * threads. * * If this test ever starts failing, the reactor no longer decouples - * connection lifetime from worker lifetime — which would be a Phase 3 - * regression. The corresponding negative control (blocking mode STILL - * starves under the same load) lives in - * `tests/integration/server/reactor_starvation_regression_test.cpp`. + * connection lifetime from worker lifetime. */ TEST_F(ThreadPoolSaturationTest, LateClientServedDespitePinnedIdleClientsInDefaultMode) { // Intentionally tiny worker pool to make the "workers == idle clients" // corner case trivially reachable. Under reactor mode this is fine — the // event loop handles reads and workers only run briefly per command. constexpr int kWorkers = 2; - auto server = StartServer(kWorkers); // default io_model = reactor + auto server = StartServer(kWorkers); uint16_t port = server->GetPort(); // Open kWorkers idle persistent clients. Each issues one INFO and then @@ -251,9 +206,7 @@ TEST_F(ThreadPoolSaturationTest, LateClientServedDespitePinnedIdleClientsInDefau // Give the reactor a moment to re-arm kReadable for the pinned clients. std::this_thread::sleep_for(std::chrono::milliseconds(100)); - // Late client: should be served immediately under reactor mode. Under - // the old blocking model this was impossible and the request would time - // out; the inversion is deliberate. + // Late client: should be served immediately under reactor mode. int late = Connect(port); ASSERT_GE(late, 0); ASSERT_TRUE(SendLine(late, "INFO")); @@ -265,10 +218,9 @@ TEST_F(ThreadPoolSaturationTest, LateClientServedDespitePinnedIdleClientsInDefau .count(); EXPECT_FALSE(resp.empty()) - << "Late INFO was NOT served under the default (reactor) I/O model " - "even though the worker pool was small and all persistent clients " - "were idle. This is the Phase 3 invariant — if it fails, the " - "reactor refactor has regressed."; + << "Late INFO was NOT served under the reactor I/O model even though " + "the worker pool was small and all persistent clients were idle. " + "The reactor must not couple connection lifetime to worker lifetime."; if (!resp.empty()) { EXPECT_EQ(resp.substr(0, 7), "OK INFO"); EXPECT_LT(elapsed_ms, 500) @@ -284,72 +236,19 @@ TEST_F(ThreadPoolSaturationTest, LateClientServedDespitePinnedIdleClientsInDefau } /** - * Blocking-mode legacy invariant. - * - * Forces io_model="blocking" so the worker-count mitigation lever is - * exercised against its original failure mode. With a generously-sized - * blocking thread pool, the same client pattern that normally starves - * under io_model=blocking does NOT starve, confirming that - * `api.tcp.worker_threads` remains a usable emergency lever for operators - * who have reverted to the blocking I/O model for any reason. - */ -TEST_F(ThreadPoolSaturationTest, LargerThreadPoolRemovesStarvationInBlockingMode) { - constexpr int kWorkers = 64; - auto server = StartServer(kWorkers, /*max_connections=*/256, /*io_model=*/"blocking"); - uint16_t port = server->GetPort(); - - // Pin 4 persistent clients — well below kWorkers so there should be plenty - // of slack to serve the late client immediately. - std::vector pinned; - for (int i = 0; i < 4; ++i) { - int s = Connect(port); - ASSERT_GE(s, 0); - ASSERT_TRUE(SendLine(s, "INFO")); - ASSERT_EQ(RecvLine(s).substr(0, 7), "OK INFO"); - pinned.push_back(s); - } - std::this_thread::sleep_for(std::chrono::milliseconds(50)); - - int late = Connect(port); - ASSERT_GE(late, 0); - ASSERT_TRUE(SendLine(late, "INFO")); - - auto t0 = std::chrono::steady_clock::now(); - std::string resp = RecvLine(late, /*timeout_ms=*/1500); - auto elapsed_ms = - std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) - .count(); - - EXPECT_FALSE(resp.empty()) << "Late client starved even with worker_threads=" << kWorkers; - EXPECT_EQ(resp.substr(0, 7), "OK INFO"); - EXPECT_LT(elapsed_ms, 500) - << "Late client responded but took " << elapsed_ms << "ms (>500ms)"; - - close(late); - for (int s : pinned) { - close(s); - } - server->Stop(); -} - -/** - * Regression test for the default auto-sized thread pool under the - * default (reactor) I/O model. - * - * With the Phase 3 defaults (`io_model=reactor`, `worker_threads=0` → - * auto-size = max(hw*2, 4)), persistent idle clients do NOT pin workers — - * they live in the reactor's connection map and only consume a worker - * briefly when a complete command frame arrives. This test pins 16 - * persistent clients (well above the auto-sized worker count on typical - * CI runners) and asserts that a late client is still served quickly. + * Regression test for the auto-sized thread pool under the reactor I/O + * model. * - * If this test ever starts failing, either the reactor default regressed - * or the thread pool auto-size fell below the "4 worker floor" that the - * reactor assumes for burst absorption. + * With `worker_threads=0` → auto-size = max(hw*2, 4), persistent idle + * clients do NOT pin workers — they live in the reactor's connection map + * and only consume a worker briefly when a complete command frame arrives. + * This test pins 16 persistent clients (well above the auto-sized worker + * count on typical CI runners) and asserts that a late client is still + * served quickly. */ TEST_F(ThreadPoolSaturationTest, DefaultAutoSizeServesManyPersistentClients) { // worker_threads=0 exercises the auto-sizing path in ThreadPool's constructor. - auto server = StartServer(/*worker_threads=*/0); // default io_model = reactor + auto server = StartServer(/*worker_threads=*/0); uint16_t port = server->GetPort(); // Pin enough clients that the auto-sized pool (max(hw*2, 4)) could not @@ -380,14 +279,13 @@ TEST_F(ThreadPoolSaturationTest, DefaultAutoSizeServesManyPersistentClients) { .count(); EXPECT_FALSE(resp.empty()) - << "Late client starved under the Phase 3 defaults with " << kPinned - << " pinned persistent clients — has the reactor default regressed to " - "blocking mode, or did the thread pool auto-size floor drop below 4?"; + << "Late client starved with " << kPinned + << " pinned persistent clients — has the reactor regressed, or did the " + "thread pool auto-size floor drop below 4?"; if (!resp.empty()) { EXPECT_EQ(resp.substr(0, 7), "OK INFO"); EXPECT_LT(elapsed_ms, 500) - << "Late client responded but took " << elapsed_ms - << "ms under the default Phase 3 config"; + << "Late client responded but took " << elapsed_ms << "ms"; } close(late); @@ -397,114 +295,4 @@ TEST_F(ThreadPoolSaturationTest, DefaultAutoSizeServesManyPersistentClients) { server->Stop(); } -/** - * Blocking-mode legacy invariant: verify that the thread-pool backpressure - * path in ConnectionAcceptor::AcceptLoop fires when the task queue fills up - * under `io_model=blocking`, and that the affected sockets receive - * "ERR SERVER_BUSY" followed by a clean close. - * - * The queue_full path is unreachable under `io_model=reactor` because - * reactor-mode accept hands connections directly to IoReactor::Register - * without a thread-pool submission per accept. This test therefore forces - * blocking mode to preserve coverage of the fallback I/O model's rejection - * behaviour. - * - * Caveat: the hardcoded queue size is kThreadPoolQueueSize = 1000 - * (server_lifecycle_manager.cpp:31). Because client-side sockets and the - * server's accepted-socket fds live in the same test process, reliably - * overflowing the queue requires ~2200 open fds (1000 queued server-side + - * 1000 client-side + overhead). On systems where RLIMIT_NOFILE cannot be - * raised that high (macOS default soft limit is 256, many Linux defaults are - * 1024), the test degrades gracefully: it opens as many sockets as the - * per-process fd budget allows and either asserts the BUSY path fired (if - * we got enough sockets) or skips (if we didn't). - */ -TEST_F(ThreadPoolSaturationTest, QueueOverflowTriggersBusyResponseInBlockingMode) { - constexpr int kWorkers = 1; - // To overflow the 1000-slot queue we need at least ~1000 server-side - // accepted fds + ~1000 client-side fds in the same process + overhead. - constexpr rlim_t kDesiredFdLimit = 4096; - constexpr int kMinClientFdsToExercise = 1050; // queue overflow point - rlim_t effective_limit = RaiseFdLimit(kDesiredFdLimit); - - auto server = StartServer(kWorkers, /*max_connections=*/4096, /*io_model=*/"blocking"); - uint16_t port = server->GetPort(); - - // Pin the single worker thread with a persistent idle client. - int pinned = Connect(port); - ASSERT_GE(pinned, 0); - ASSERT_TRUE(SendLine(pinned, "INFO")); - ASSERT_EQ(RecvLine(pinned).substr(0, 7), "OK INFO"); - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - - // Burst-open sockets without sending any request. Each accepted connection - // becomes a task in the 1000-slot queue; the worker is already pinned. Once - // the queue reaches kThreadPoolQueueSize entries, the next accepts take the - // queue_full branch: acceptor writes "ERR SERVER_BUSY" and close()s the fd - // synchronously. - constexpr int kBurst = 1200; - std::vector socks; - socks.reserve(kBurst); - for (int i = 0; i < kBurst; ++i) { - int s = Connect(port, /*timeout_ms=*/500); - if (s < 0) { - // Out of FDs or connect() timed out; stop opening more. - break; - } - socks.push_back(s); - } - - // Let the server drain any pending accepts and emit BUSY responses. - std::this_thread::sleep_for(std::chrono::milliseconds(500)); - - int busy_msg = 0; - int closed_by_server = 0; - for (int s : socks) { - struct timeval to {}; - to.tv_sec = 0; - to.tv_usec = 50 * 1000; // 50 ms - setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &to, sizeof(to)); - std::array buf{}; - ssize_t n = recv(s, buf.data(), buf.size(), 0); - if (n > 0) { - std::string r(buf.data(), n); - if (r.find("ERR SERVER_BUSY") != std::string::npos) { - busy_msg++; - } - } else if (n == 0) { - // Clean close from server side: FIN received. - closed_by_server++; - } - // n < 0 with EAGAIN: socket is still open and queued (not yet serviced). - } - - std::cout << "[queue_overflow] rlimit=" << effective_limit << " opened=" << socks.size() - << " busy_msg=" << busy_msg << " closed_by_server=" << closed_by_server << std::endl; - - // Cleanup before any SKIP/assertion so server->Stop() doesn't block on a - // flood of stale accepts. - for (int s : socks) { - close(s); - } - close(pinned); - server->Stop(); - - if (static_cast(socks.size()) < kMinClientFdsToExercise) { - GTEST_SKIP() << "Per-process fd budget is too small to exceed the 1000-slot " - "task queue (opened only " - << socks.size() << " client sockets, RLIMIT_NOFILE soft=" << effective_limit - << "). Re-run with `ulimit -n 8192` or on Linux with a larger " - "nofile limit to exercise the queue_full backpressure path."; - } - - // Got enough sockets: the queue must have overflowed somewhere. - EXPECT_GT(busy_msg + closed_by_server, 0) - << "Expected the queue_full backpressure path to fire for at least one " - "connection after opening " - << socks.size() - << " idle sockets against worker_threads=1. Either the queue grew larger " - "than kThreadPoolQueueSize=1000, or the burst did not actually " - "exhaust it."; -} - } // namespace mygramdb::server diff --git a/tests/integration/server/verify_text_test.cpp b/tests/integration/server/verify_text_test.cpp index 70fc98d..c0c2b06 100644 --- a/tests/integration/server/verify_text_test.cpp +++ b/tests/integration/server/verify_text_test.cpp @@ -24,7 +24,6 @@ #include "config/config.h" #include "server/tcp_server.h" -#include "test_io_model_override.h" using namespace mygramdb::server; using namespace mygramdb; @@ -141,7 +140,6 @@ class VerifyTextAllTest : public ::testing::Test { server_config_.port = 0; server_config_.host = "127.0.0.1"; server_config_.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(server_config_); // Create dump directory test_dump_dir_ = std::filesystem::temp_directory_path() / ("verify_text_test_" + std::to_string(getpid())); @@ -323,7 +321,6 @@ class VerifyTextAsciiTest : public ::testing::Test { server_config_.port = 0; server_config_.host = "127.0.0.1"; server_config_.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(server_config_); server_ = std::make_unique(server_config_, table_contexts_, "./test_snapshots", full_config_.get()); ASSERT_TRUE(server_->Start()); @@ -412,7 +409,6 @@ class VerifyTextOffTest : public ::testing::Test { server_config_.port = 0; server_config_.host = "127.0.0.1"; server_config_.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(server_config_); server_ = std::make_unique(server_config_, table_contexts_, "./test_snapshots", full_config_.get()); ASSERT_TRUE(server_->Start()); @@ -484,7 +480,6 @@ class VerifyTextDumpConsistencyTest : public ::testing::Test { server_config_.port = 0; server_config_.host = "127.0.0.1"; server_config_.allow_cidrs = {"127.0.0.1/32"}; - mygramdb::server::test::ApplyIoModelOverride(server_config_); test_dump_dir_ = std::filesystem::temp_directory_path() / ("verify_dump_test_" + std::to_string(getpid())); std::filesystem::create_directories(test_dump_dir_); diff --git a/tests/server/CMakeLists.txt b/tests/server/CMakeLists.txt index ec8f94e..adafe1a 100644 --- a/tests/server/CMakeLists.txt +++ b/tests/server/CMakeLists.txt @@ -311,24 +311,6 @@ gtest_discover_tests(config_handler_test PROPERTIES RESOURCE_LOCK server_port ) -# ConnectionIOHandler tests - -add_executable(connection_io_handler_test - connection_io_handler_test.cpp -) - -target_link_libraries(connection_io_handler_test - mygramdb_server - GTest::gtest_main -) - -# RESOURCE_LOCK: Prevent parallel execution to avoid I/O handler conflicts -gtest_discover_tests(connection_io_handler_test - DISCOVERY_MODE POST_BUILD - DISCOVERY_TIMEOUT 30 - PROPERTIES RESOURCE_LOCK server_port -) - # RequestDispatcher tests add_executable(request_dispatcher_test diff --git a/tests/server/connection_acceptor_unix_test.cpp b/tests/server/connection_acceptor_unix_test.cpp index 9a55246..5269c21 100644 --- a/tests/server/connection_acceptor_unix_test.cpp +++ b/tests/server/connection_acceptor_unix_test.cpp @@ -64,9 +64,10 @@ TEST_F(ConnectionAcceptorUnixTest, StartAndStopUnixSocket) { ConnectionAcceptor acceptor(config, &pool); std::atomic connections{0}; - acceptor.SetConnectionHandler([&connections](int fd) { + acceptor.SetReactorHandler([&connections](int fd) { connections++; close(fd); + return true; }); auto result = acceptor.Start(); @@ -97,11 +98,10 @@ TEST_F(ConnectionAcceptorUnixTest, AcceptsUnixConnection) { ConnectionAcceptor acceptor(config, &pool); std::atomic connections{0}; - acceptor.SetConnectionHandler([&connections](int fd) { + acceptor.SetReactorHandler([&connections](int fd) { connections++; - // Small delay to keep connection alive briefly - std::this_thread::sleep_for(std::chrono::milliseconds(50)); close(fd); + return true; }); auto result = acceptor.Start(); @@ -142,7 +142,10 @@ TEST_F(ConnectionAcceptorUnixTest, StaleSocketCleanup) { config.max_connections = 10; ConnectionAcceptor acceptor(config, &pool); - acceptor.SetConnectionHandler([](int fd) { close(fd); }); + acceptor.SetReactorHandler([](int fd) { + close(fd); + return true; + }); auto result = acceptor.Start(); ASSERT_TRUE(result.has_value()) << result.error().to_string(); @@ -160,7 +163,10 @@ TEST_F(ConnectionAcceptorUnixTest, PathTooLongError) { config.max_connections = 10; ConnectionAcceptor acceptor(config, &pool); - acceptor.SetConnectionHandler([](int fd) { close(fd); }); + acceptor.SetReactorHandler([](int fd) { + close(fd); + return true; + }); auto result = acceptor.Start(); ASSERT_FALSE(result.has_value()); @@ -177,7 +183,10 @@ TEST_F(ConnectionAcceptorUnixTest, SocketFileRemovedOnStop) { config.max_connections = 10; ConnectionAcceptor acceptor(config, &pool); - acceptor.SetConnectionHandler([](int fd) { close(fd); }); + acceptor.SetReactorHandler([](int fd) { + close(fd); + return true; + }); auto result = acceptor.Start(); ASSERT_TRUE(result.has_value()); @@ -197,7 +206,10 @@ TEST_F(ConnectionAcceptorUnixTest, SocketPermissionsAreRestricted) { config.max_connections = 10; ConnectionAcceptor acceptor(config, &pool); - acceptor.SetConnectionHandler([](int fd) { close(fd); }); + acceptor.SetReactorHandler([](int fd) { + close(fd); + return true; + }); auto result = acceptor.Start(); ASSERT_TRUE(result.has_value()) << result.error().to_string(); diff --git a/tests/server/connection_io_handler_test.cpp b/tests/server/connection_io_handler_test.cpp deleted file mode 100644 index ec9a63c..0000000 --- a/tests/server/connection_io_handler_test.cpp +++ /dev/null @@ -1,300 +0,0 @@ -/** - * @file connection_io_handler_test.cpp - * @brief Unit tests for ConnectionIOHandler - */ - -#include "server/connection_io_handler.h" - -#include -#include -#include - -#include -#include -#include - -#include "server/server_types.h" - -namespace mygramdb::server { - -class ConnectionIOHandlerTest : public ::testing::Test { - protected: - void SetUp() override { - // Ignore SIGPIPE to prevent crash when writev writes to closed socket - std::signal(SIGPIPE, SIG_IGN); - - // Create socket pair for testing - if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets_) != 0) { - FAIL() << "Failed to create socket pair"; - } - - config_.recv_buffer_size = 1024; - config_.max_query_length = 4096; - config_.recv_timeout_sec = 1; - } - - void TearDown() override { - close(sockets_[0]); - close(sockets_[1]); - } - - int sockets_[2]; - IOConfig config_; - std::atomic shutdown_flag_{false}; -}; - -TEST_F(ConnectionIOHandlerTest, HandlesSingleRequest) { - std::string received_request; - int call_count = 0; - - auto processor = [&](const std::string& req, ConnectionContext& ctx) { - received_request = req; - call_count++; - return "OK"; - }; - - ConnectionIOHandler handler(config_, processor, shutdown_flag_); - - // Send request from client side - std::thread client_thread([this]() { - const char* request = "SEARCH table=test query=\"hello\"\r\n"; - send(sockets_[1], request, strlen(request), 0); - - char buffer[1024]; - ssize_t bytes = recv(sockets_[1], buffer, sizeof(buffer) - 1, 0); - ASSERT_GT(bytes, 0); - buffer[bytes] = '\0'; - EXPECT_STREQ("OK\r\n", buffer); - - // Close properly to unblock recv - shutdown(sockets_[1], SHUT_RDWR); - close(sockets_[1]); - }); - - ConnectionContext ctx; - handler.HandleConnection(sockets_[0], ctx); - - client_thread.join(); - - EXPECT_EQ(1, call_count); - EXPECT_EQ("SEARCH table=test query=\"hello\"", received_request); -} - -TEST_F(ConnectionIOHandlerTest, HandlesMultipleRequests) { - std::vector received_requests; - std::atomic response_count{0}; - - auto processor = [&](const std::string& req, ConnectionContext& ctx) { - received_requests.push_back(req); - response_count++; - return "OK " + std::to_string(response_count.load()); - }; - - ConnectionIOHandler handler(config_, processor, shutdown_flag_); - - std::thread server_thread([&]() { - ConnectionContext ctx; - handler.HandleConnection(sockets_[0], ctx); - }); - - // Give server time to start - std::this_thread::sleep_for(std::chrono::milliseconds(50)); - - // Send all requests at once - const char* requests = "SEARCH query=\"test1\"\r\nSEARCH query=\"test2\"\r\nSEARCH query=\"test3\"\r\n"; - send(sockets_[1], requests, strlen(requests), 0); - - // Read all responses - std::string all_responses; - char buffer[1024]; - int expected_responses = 3; - int received = 0; - - while (received < expected_responses) { - ssize_t bytes = recv(sockets_[1], buffer, sizeof(buffer) - 1, 0); - if (bytes <= 0) - break; - buffer[bytes] = '\0'; - all_responses += buffer; - - // Count \r\n occurrences - size_t pos = 0; - while ((pos = all_responses.find("\r\n", pos)) != std::string::npos) { - received++; - pos += 2; - } - } - - // Close connection - shutdown(sockets_[1], SHUT_RDWR); - close(sockets_[1]); - - server_thread.join(); - - ASSERT_EQ(3, received_requests.size()); - EXPECT_EQ("SEARCH query=\"test1\"", received_requests[0]); - EXPECT_EQ("SEARCH query=\"test2\"", received_requests[1]); - EXPECT_EQ("SEARCH query=\"test3\"", received_requests[2]); -} - -TEST_F(ConnectionIOHandlerTest, RejectsOversizedRequest) { - config_.max_query_length = 100; // Small limit - - auto processor = [&](const std::string& req, ConnectionContext& ctx) { return "OK"; }; - - ConnectionIOHandler handler(config_, processor, shutdown_flag_); - - std::thread client_thread([this]() { - // Send request larger than limit without newline - std::string large_request(1500, 'X'); - send(sockets_[1], large_request.c_str(), large_request.length(), 0); - - char buffer[1024]; - ssize_t bytes = recv(sockets_[1], buffer, sizeof(buffer) - 1, 0); - ASSERT_GT(bytes, 0); - buffer[bytes] = '\0'; - EXPECT_TRUE(std::string(buffer).find("ERROR") != std::string::npos); - - shutdown(sockets_[1], SHUT_RDWR); - }); - - ConnectionContext ctx; - handler.HandleConnection(sockets_[0], ctx); - - client_thread.join(); -} - -TEST_F(ConnectionIOHandlerTest, RespectsShutdownFlag) { - auto processor = [&](const std::string& req, ConnectionContext& ctx) { return "OK"; }; - - ConnectionIOHandler handler(config_, processor, shutdown_flag_); - - std::thread handler_thread([&]() { - ConnectionContext ctx; - handler.HandleConnection(sockets_[0], ctx); - }); - - // Let handler start - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - - // Signal shutdown - shutdown_flag_ = true; - - // Close socket to unblock recv - close(sockets_[1]); - - handler_thread.join(); - - // Test passes if no hang occurs - SUCCEED(); -} - -TEST_F(ConnectionIOHandlerTest, HandlesPartialReceives) { - std::string received_request; - - auto processor = [&](const std::string& req, ConnectionContext& ctx) { - received_request = req; - return "OK"; - }; - - ConnectionIOHandler handler(config_, processor, shutdown_flag_); - - std::thread client_thread([this]() { - // Send request in parts - const char* part1 = "SEARCH "; - const char* part2 = "query=\"hello\""; - const char* part3 = "\r\n"; - - send(sockets_[1], part1, strlen(part1), 0); - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - send(sockets_[1], part2, strlen(part2), 0); - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - send(sockets_[1], part3, strlen(part3), 0); - - char buffer[1024]; - recv(sockets_[1], buffer, sizeof(buffer) - 1, 0); - - shutdown(sockets_[1], SHUT_RDWR); - close(sockets_[1]); - }); - - ConnectionContext ctx; - handler.HandleConnection(sockets_[0], ctx); - - client_thread.join(); - - EXPECT_EQ("SEARCH query=\"hello\"", received_request); -} - -TEST_F(ConnectionIOHandlerTest, EnforcesReceiveTimeout) { - // Set a short timeout for testing - config_.recv_timeout_sec = 1; - - auto processor = [&](const std::string& req, ConnectionContext& ctx) { return "OK"; }; - - ConnectionIOHandler handler(config_, processor, shutdown_flag_); - - std::atomic handler_completed{false}; - auto start_time = std::chrono::steady_clock::now(); - - std::thread handler_thread([&]() { - ConnectionContext ctx; - handler.HandleConnection(sockets_[0], ctx); - handler_completed = true; - }); - - // Don't send any data - let timeout occur - // The handler should close the connection after recv_timeout_sec - - // Wait up to 3 seconds (well beyond the 1 second timeout) - handler_thread.join(); - - auto elapsed = - std::chrono::duration_cast(std::chrono::steady_clock::now() - start_time).count(); - - // Handler should have timed out and completed - EXPECT_TRUE(handler_completed); - // Should complete in roughly 1-2 seconds (not hang indefinitely) - EXPECT_LE(elapsed, 3) << "Handler should have timed out, not hung indefinitely"; - EXPECT_GE(elapsed, 1) << "Handler should have waited at least recv_timeout_sec"; -} - -TEST_F(ConnectionIOHandlerTest, TimeoutNotEnforcedWhenDisabled) { - // Disable timeout - config_.recv_timeout_sec = 0; - - auto processor = [&](const std::string& req, ConnectionContext& ctx) { return "OK"; }; - - ConnectionIOHandler handler(config_, processor, shutdown_flag_); - - std::atomic handler_started{false}; - - std::thread handler_thread([&]() { - handler_started = true; - ConnectionContext ctx; - handler.HandleConnection(sockets_[0], ctx); - }); - - // Wait for handler to start - while (!handler_started) { - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - } - - // Give it some time - with timeout=0, it should block indefinitely - std::this_thread::sleep_for(std::chrono::milliseconds(200)); - - // Send data to unblock and complete - const char* request = "TEST\r\n"; - send(sockets_[1], request, strlen(request), 0); - - // Close to complete the connection - shutdown(sockets_[1], SHUT_RDWR); - close(sockets_[1]); - - handler_thread.join(); - - // Test passes if we successfully sent data and unblocked the handler - SUCCEED(); -} - -} // namespace mygramdb::server From 5db19e37a4b2e1691dea00b150fb7f8d0c959668 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 07:55:57 +0900 Subject: [PATCH 06/13] refactor(server): Drop unused ConnectionAcceptor::thread_pool_ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit With the thread-pool-submit branch in ConnectionAcceptor::AcceptLoop gone, the thread_pool_ member is no longer referenced anywhere — accepted fds are handed off inline to the ReactorHandler on the accept thread. Remove the dead member, the constructor parameter, the forward declaration, and the `server/thread_pool.h` include. - src/server/connection_acceptor.{h,cpp}: drop ThreadPool forward decl, drop the ThreadPool* constructor parameter (now `explicit ConnectionAcceptor(ServerConfig)`), drop the thread_pool_ field, drop the null check in the constructor, drop the include. - src/server/server_lifecycle_manager.{h,cpp}: ServerLifecycleManager:: InitAcceptor no longer needs a thread_pool argument; the matching call in InitializeComponents is updated to pass nothing. - tests/server/connection_acceptor_unix_test.cpp: drop the local `ThreadPool pool(2, 100)` declarations in all 6 fixtures, drop the matching `pool.Shutdown()` calls, drop the include. Each test now constructs `ConnectionAcceptor acceptor(config)` directly. Fast suite: 2164 / 2164 pass. Also gitignore: add `.backup/` so a local-only scratch directory is never accidentally tracked. --- .gitignore | 3 ++ src/server/connection_acceptor.cpp | 12 +------- src/server/connection_acceptor.h | 7 +---- src/server/server_lifecycle_manager.cpp | 8 ++--- src/server/server_lifecycle_manager.h | 3 +- .../server/connection_acceptor_unix_test.cpp | 30 ++++--------------- 6 files changed, 16 insertions(+), 47 deletions(-) diff --git a/.gitignore b/.gitignore index eceea09..14fa8aa 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +# Local scratch / backup area (never committed) +.backup/ + # Build directories build/ build-*/ diff --git a/src/server/connection_acceptor.cpp b/src/server/connection_acceptor.cpp index 9b1f67b..5b96ed8 100644 --- a/src/server/connection_acceptor.cpp +++ b/src/server/connection_acceptor.cpp @@ -24,7 +24,6 @@ #include #include "server/server_types.h" -#include "server/thread_pool.h" #include "utils/error.h" #include "utils/expected.h" #include "utils/network_utils.h" @@ -48,16 +47,7 @@ inline struct sockaddr* ToSockaddrUn(struct sockaddr_un* addr) { } } // namespace -ConnectionAcceptor::ConnectionAcceptor(ServerConfig config, ThreadPool* thread_pool) - : config_(std::move(config)), thread_pool_(thread_pool) { - if (thread_pool_ == nullptr) { - mygram::utils::StructuredLog() - .Event("server_error") - .Field("component", "connection_acceptor") - .Field("error", "thread_pool cannot be null") - .Error(); - } -} +ConnectionAcceptor::ConnectionAcceptor(ServerConfig config) : config_(std::move(config)) {} ConnectionAcceptor::~ConnectionAcceptor() { Stop(); diff --git a/src/server/connection_acceptor.h b/src/server/connection_acceptor.h index 8175c01..799a40b 100644 --- a/src/server/connection_acceptor.h +++ b/src/server/connection_acceptor.h @@ -19,9 +19,6 @@ namespace mygramdb::server { -// Forward declarations -class ThreadPool; - /** * @brief Network connection acceptor * @@ -60,9 +57,8 @@ class ConnectionAcceptor { /** * @brief Construct a ConnectionAcceptor * @param config Server configuration - * @param thread_pool Thread pool for connection handling */ - ConnectionAcceptor(ServerConfig config, ThreadPool* thread_pool); + explicit ConnectionAcceptor(ServerConfig config); // Disable copy and move ConnectionAcceptor(const ConnectionAcceptor&) = delete; @@ -136,7 +132,6 @@ class ConnectionAcceptor { bool SetSocketOptions(int socket_fd) const; ServerConfig config_; - ThreadPool* thread_pool_; ReactorHandler reactor_handler_; int server_fd_ = -1; diff --git a/src/server/server_lifecycle_manager.cpp b/src/server/server_lifecycle_manager.cpp index 744289d..760569a 100644 --- a/src/server/server_lifecycle_manager.cpp +++ b/src/server/server_lifecycle_manager.cpp @@ -181,7 +181,7 @@ mygram::utils::Expected ServerLifec // Step 7: Initialize Acceptor (depends on thread pool) { - auto acceptor_result = InitAcceptor(components.thread_pool.get()); + auto acceptor_result = InitAcceptor(); if (!acceptor_result) { return MakeUnexpected(acceptor_result.error()); } @@ -425,14 +425,14 @@ ServerLifecycleManager::InitDispatcher(HandlerContext& handler_context, const In } } -mygram::utils::Expected, mygram::utils::Error> ServerLifecycleManager::InitAcceptor( - ThreadPool* thread_pool) { +mygram::utils::Expected, mygram::utils::Error> +ServerLifecycleManager::InitAcceptor() { using mygram::utils::ErrorCode; using mygram::utils::MakeError; using mygram::utils::MakeUnexpected; try { - auto acceptor = std::make_unique(config_, thread_pool); + auto acceptor = std::make_unique(config_); // Start the acceptor auto start_result = acceptor->Start(); diff --git a/src/server/server_lifecycle_manager.h b/src/server/server_lifecycle_manager.h index 9f2622b..d8834b5 100644 --- a/src/server/server_lifecycle_manager.h +++ b/src/server/server_lifecycle_manager.h @@ -176,8 +176,7 @@ class ServerLifecycleManager { mygram::utils::Expected InitHandlers(HandlerContext& handler_context); mygram::utils::Expected, mygram::utils::Error> InitDispatcher( HandlerContext& handler_context, const InitializedComponents& handlers); - mygram::utils::Expected, mygram::utils::Error> InitAcceptor( - ThreadPool* thread_pool); + mygram::utils::Expected, mygram::utils::Error> InitAcceptor(); mygram::utils::Expected, mygram::utils::Error> InitScheduler( TableCatalog* table_catalog); }; diff --git a/tests/server/connection_acceptor_unix_test.cpp b/tests/server/connection_acceptor_unix_test.cpp index 5269c21..4042e8f 100644 --- a/tests/server/connection_acceptor_unix_test.cpp +++ b/tests/server/connection_acceptor_unix_test.cpp @@ -16,7 +16,6 @@ #include "server/connection_acceptor.h" #include "server/server_types.h" -#include "server/thread_pool.h" namespace mygramdb::server { @@ -55,13 +54,11 @@ class ConnectionAcceptorUnixTest : public ::testing::Test { }; TEST_F(ConnectionAcceptorUnixTest, StartAndStopUnixSocket) { - ThreadPool pool(2, 100); - ServerConfig config; config.unix_socket_path = socket_path_; config.max_connections = 10; - ConnectionAcceptor acceptor(config, &pool); + ConnectionAcceptor acceptor(config); std::atomic connections{0}; acceptor.SetReactorHandler([&connections](int fd) { @@ -85,17 +82,14 @@ TEST_F(ConnectionAcceptorUnixTest, StartAndStopUnixSocket) { // Socket file should be removed after stop EXPECT_FALSE(std::filesystem::exists(socket_path_)); - pool.Shutdown(); } TEST_F(ConnectionAcceptorUnixTest, AcceptsUnixConnection) { - ThreadPool pool(2, 100); - ServerConfig config; config.unix_socket_path = socket_path_; config.max_connections = 10; - ConnectionAcceptor acceptor(config, &pool); + ConnectionAcceptor acceptor(config); std::atomic connections{0}; acceptor.SetReactorHandler([&connections](int fd) { @@ -117,7 +111,6 @@ TEST_F(ConnectionAcceptorUnixTest, AcceptsUnixConnection) { EXPECT_GE(connections.load(), 1); acceptor.Stop(); - pool.Shutdown(); } TEST_F(ConnectionAcceptorUnixTest, StaleSocketCleanup) { @@ -136,12 +129,11 @@ TEST_F(ConnectionAcceptorUnixTest, StaleSocketCleanup) { EXPECT_TRUE(std::filesystem::exists(socket_path_)); // New acceptor should clean up the stale file and start successfully - ThreadPool pool(2, 100); ServerConfig config; config.unix_socket_path = socket_path_; config.max_connections = 10; - ConnectionAcceptor acceptor(config, &pool); + ConnectionAcceptor acceptor(config); acceptor.SetReactorHandler([](int fd) { close(fd); return true; @@ -151,18 +143,15 @@ TEST_F(ConnectionAcceptorUnixTest, StaleSocketCleanup) { ASSERT_TRUE(result.has_value()) << result.error().to_string(); acceptor.Stop(); - pool.Shutdown(); } TEST_F(ConnectionAcceptorUnixTest, PathTooLongError) { - ThreadPool pool(2, 100); - ServerConfig config; // Create a path that exceeds sockaddr_un::sun_path limit (typically 104 or 108 bytes) config.unix_socket_path = "/tmp/" + std::string(200, 'x') + ".sock"; config.max_connections = 10; - ConnectionAcceptor acceptor(config, &pool); + ConnectionAcceptor acceptor(config); acceptor.SetReactorHandler([](int fd) { close(fd); return true; @@ -172,17 +161,14 @@ TEST_F(ConnectionAcceptorUnixTest, PathTooLongError) { ASSERT_FALSE(result.has_value()); EXPECT_EQ(result.error().code(), mygram::utils::ErrorCode::kNetworkUnixSocketPathTooLong); - pool.Shutdown(); } TEST_F(ConnectionAcceptorUnixTest, SocketFileRemovedOnStop) { - ThreadPool pool(2, 100); - ServerConfig config; config.unix_socket_path = socket_path_; config.max_connections = 10; - ConnectionAcceptor acceptor(config, &pool); + ConnectionAcceptor acceptor(config); acceptor.SetReactorHandler([](int fd) { close(fd); return true; @@ -195,17 +181,14 @@ TEST_F(ConnectionAcceptorUnixTest, SocketFileRemovedOnStop) { acceptor.Stop(); EXPECT_FALSE(std::filesystem::exists(socket_path_)); - pool.Shutdown(); } TEST_F(ConnectionAcceptorUnixTest, SocketPermissionsAreRestricted) { - ThreadPool pool(2, 100); - ServerConfig config; config.unix_socket_path = socket_path_; config.max_connections = 10; - ConnectionAcceptor acceptor(config, &pool); + ConnectionAcceptor acceptor(config); acceptor.SetReactorHandler([](int fd) { close(fd); return true; @@ -221,7 +204,6 @@ TEST_F(ConnectionAcceptorUnixTest, SocketPermissionsAreRestricted) { EXPECT_EQ(perms, 0770) << "Socket permissions should be 0770, got: " << std::oct << perms; acceptor.Stop(); - pool.Shutdown(); } } // namespace mygramdb::server From 117a2c675c55336ab3c63969286c7673fc736df7 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 07:56:14 +0900 Subject: [PATCH 07/13] docs: Sync architecture and load test references to reactor I/O model MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The blocking ConnectionIOHandler path is gone; all connections flow through IoReactor + ReactorConnection on epoll/kqueue. Update the architecture docs and the load test docstring to match. docs/ja/architecture.md and docs/en/architecture.md - Replace the ConnectionIOHandler subsection with new IoReactor and ReactorConnection subsections describing the event loop, the EventMultiplexer abstraction, the per-fd drain task pattern, the non-blocking write queue, and per-connection `max_write_queue_bytes` slow-reader backpressure. - Rewrite ConnectionAcceptor's "Features" bullets: it no longer dispatches into the thread pool; it hands accepted fds inline to IoReactor::Register on the accept thread. - Add an "IoReactor Event Loop Thread (single)" node to the thread model diagram and link it from the main process node. Worker pool description updated to "runs per-connection drain tasks". - "ServerLifecycleManager initialization order": ConnectionAcceptor no longer depends on ThreadPool; add IoReactor as step 8, created in TcpServer::Start() and depending on ThreadPool + RequestDispatcher. - "Between Acceptor and Handlers" section: rewrite the request flow as ConnectionAcceptor → IoReactor::Register → ReactorConnection (event loop) → drain task on ThreadPool → RequestDispatcher → handler → EnqueueResponse() with EPOLLOUT fallback. e2e/tests/load/test_load.py - Module docstring previously claimed pipelined commands were processed by ConnectionIOHandler "in a while loop". Update to describe ReactorConnection's drain task framing the `\r\n`-delimited requests. Historical release notes (docs/releases/v1.1.0.md, v1.3.5.md) still reference the old class names — left intact since they document past releases. --- docs/en/architecture.md | 44 +++++++++++++++++++++++-------------- docs/ja/architecture.md | 44 +++++++++++++++++++++++-------------- e2e/tests/load/test_load.py | 6 ++--- 3 files changed, 59 insertions(+), 35 deletions(-) diff --git a/docs/en/architecture.md b/docs/en/architecture.md index e262f85..a60c564 100644 --- a/docs/en/architecture.md +++ b/docs/en/architecture.md @@ -300,19 +300,27 @@ graph TB #### Request Dispatch Pipeline **ConnectionAcceptor** (`connection_acceptor.h`) -- **Responsibility**: Socket accept loop +- **Responsibility**: Socket accept loop (TCP or UDS) - **Features**: - - `SO_RCVTIMEO` to prevent indefinite hangs - - Dispatches connections to thread pool - - Thread-safe connection tracking + - Hands off each accepted fd to `IoReactor` inline (accept thread → reactor, no thread-pool hop) + - max_connections gate with SERVER_BUSY backpressure + - Thread-safe `active_fds_` tracking -**ConnectionIOHandler** (`connection_io_handler.h`) -- **Responsibility**: Per-connection I/O handling +**IoReactor** (`io_reactor.h`) +- **Responsibility**: Single-threaded event loop for readiness notification - **Features**: - - Reads/buffers socket data - - Parses protocol messages (delimited by `\r\n`) - - Enforces maximum query length (default 1MB) - - Writes responses to socket + - `EventMultiplexer` abstraction (Linux: epoll, macOS/BSD: kqueue) + - Per-fd `ReactorConnection` lifecycle management + - Write arm/disarm (EPOLLOUT / EVFILT_WRITE), close callback + - Graceful shutdown + +**ReactorConnection** (`reactor_connection.h`) +- **Responsibility**: Per-connection I/O state and drain-task pattern +- **Features**: + - Non-blocking `recv()` drains into `read_buf_`, frames on `\r\n` + - Schedules at most one in-flight drain task per connection on the worker pool ("clear-then-recheck" reschedule) + - Non-blocking write queue (inline fast path + EPOLLOUT fallback on EAGAIN) + - Per-connection `max_write_queue_bytes` slow-reader backpressure cap **RequestDispatcher** (`request_dispatcher.h`) - **Responsibility**: Application logic routing @@ -565,15 +573,17 @@ graph TB MainThread["Main Thread
Application::RunMainLoop()
Signal polling (SignalManager)
Config reload handling
Initialization/shutdown coordination"] BinlogThread["BinlogReader Thread (if MySQL enabled)
Reads from MySQL binlog, queues events"] EventLoop["Event Processing Loop (main thread)
Dequeues binlog events, applies to Index/DocumentStore"] - TCPThread["TCP Server Accept Thread
Listens on TCP port, accepts connections"] + TCPThread["TCP/UDS Accept Thread
Listens on socket, hands accepted fds directly to IoReactor"] + ReactorThread["IoReactor Event Loop Thread (single)
Drains epoll_wait/kevent, dispatches readiness to ReactorConnection
Owns per-fd write arm/disarm and close"] HTTPThread["HTTP Server Thread
Listens on HTTP port"] - WorkerPool["Worker Thread Pool (configurable, default = CPU count)
Thread 1: Processes client requests from queue
Thread 2: ...
Thread N: ..."] + WorkerPool["Worker Thread Pool (configurable, default = CPU count)
Thread 1: Runs per-connection drain tasks (request processing + inline send)
Thread 2: ...
Thread N: ..."] SnapshotThread["SnapshotScheduler Background Thread (if enabled)
Periodically creates snapshots"] Main --> MainThread Main --> BinlogThread Main --> EventLoop Main --> TCPThread + Main --> ReactorThread Main --> HTTPThread Main --> WorkerPool Main --> SnapshotThread @@ -719,8 +729,9 @@ Following the dependency graph, components are initialized in this order: - AdminHandler, ReplicationHandler, DebugHandler - CacheHandler, SyncHandler (MySQL) 6. **RequestDispatcher** (depends on handlers) -7. **ConnectionAcceptor** (depends on thread pool) -8. **SnapshotScheduler** (optional, depends on catalog) +7. **ConnectionAcceptor** (depends only on ServerConfig; the reactor handler is installed later in `TcpServer::Start()`) +8. **IoReactor** (created in `TcpServer::Start()`, depends on ThreadPool and RequestDispatcher) +9. **SnapshotScheduler** (optional, depends on catalog) **Note**: RateLimiter and SyncOperationManager are created in `TcpServer::Start()` before ServerLifecycleManager is instantiated. @@ -932,8 +943,9 @@ class InvalidationManager { ### Between Acceptor and Handlers -- **ConnectionAcceptor** → accepts connection → submits to **ThreadPool** -- **ThreadPool worker** → calls **ConnectionIOHandler** → calls **RequestDispatcher** → calls handler +- **ConnectionAcceptor** → accepts connection → hands the fd directly to **IoReactor::Register** (no thread-pool hop) +- **IoReactor (event loop thread)** → detects readable → **ReactorConnection::OnReadable** → extracts frames → schedules a drain task on **ThreadPool** +- **ThreadPool worker** → **ReactorConnection::DrainTask** → dispatches each frame via **RequestDispatcher** → handler → response sent through `EnqueueResponse()` (inline fast path; partial sends fall back to EPOLLOUT in the event loop) --- diff --git a/docs/ja/architecture.md b/docs/ja/architecture.md index fc8625d..bccb4f0 100644 --- a/docs/ja/architecture.md +++ b/docs/ja/architecture.md @@ -300,19 +300,27 @@ graph TB #### リクエストディスパッチパイプライン **ConnectionAcceptor** (`connection_acceptor.h`) -- **責務**: ソケット受け入れループ +- **責務**: ソケット受け入れループ (TCP または UDS) - **機能**: - - 無期限ハングを防ぐ`SO_RCVTIMEO` - - スレッドプールへの接続ディスパッチ - - スレッドセーフな接続トラッキング + - `accept()` した fd を `IoReactor` にインラインで引き渡す（accept スレッド → reactor、ワーカープールを経由しない） + - max_connections のゲート、SERVER_BUSY バックプレッシャー + - スレッドセーフな active_fds_ トラッキング -**ConnectionIOHandler** (`connection_io_handler.h`) -- **責務**: 接続ごとのI/Oハンドリング +**IoReactor** (`io_reactor.h`) +- **責務**: 単一スレッドのイベントループでの readiness 通知 - **機能**: - - ソケットデータの読み取り/バッファリング - - プロトコルメッセージの解析（`\r\n`で区切り） - - 最大クエリ長の強制（デフォルト1MB） - - ソケットへのレスポンス書き込み + - `EventMultiplexer` 抽象（Linux: epoll、macOS/BSD: kqueue） + - per-fd `ReactorConnection` のライフサイクル管理 + - 書き込みの arm/disarm (EPOLLOUT / EVFILT_WRITE)、close コールバック + - graceful shutdown + +**ReactorConnection** (`reactor_connection.h`) +- **責務**: 接続ごとの I/O 状態と drain タスクパターン +- **機能**: + - 非ブロッキング `recv()` で `read_buf_` にドレイン、`\r\n` 区切りでフレーム化 + - drain task をワーカープールに 1 本だけ in-flight でスケジュール（"clear-then-recheck" 再スケジュール） + - 非ブロッキング書き込みキュー（インライン高速パス + EAGAIN 時は EPOLLOUT フォールバック） + - per-connection `max_write_queue_bytes` でスローリーダーバックプレッシャー **RequestDispatcher** (`request_dispatcher.h`) - **責務**: アプリケーションロジックルーティング @@ -565,15 +573,17 @@ graph TB MainThread["Main Thread
Application::RunMainLoop()
シグナルポーリング (SignalManager)
設定リロード処理
初期化/シャットダウン調整"] BinlogThread["BinlogReader Thread (if MySQL enabled)
MySQLバイナリログを読み取り、イベントをキューイング"] EventLoop["Event Processing Loop (main thread)
バイナリログイベントをデキュー、Index/DocumentStoreに適用"] - TCPThread["TCP Server Accept Thread
TCPポートでリスン、接続を受け入れ"] + TCPThread["TCP/UDS Accept Thread
ソケットでリスン、accept した fd を IoReactor に直接登録"] + ReactorThread["IoReactor Event Loop Thread (1 本)
epoll_wait/kevent でドレイン、ReactorConnection に readiness を配送
per-fd の write arm/disarm と close を担当"] HTTPThread["HTTP Server Thread
HTTPポートでリスン"] - WorkerPool["Worker Thread Pool (configurable, default = CPU count)
Thread 1: キューからクライアントリクエストを処理
Thread 2: ...
Thread N: ..."] + WorkerPool["Worker Thread Pool (configurable, default = CPU count)
Thread 1: per-connection drain task を実行（リクエスト処理 + 高速送信）
Thread 2: ...
Thread N: ..."] SnapshotThread["SnapshotScheduler Background Thread (if enabled)
定期的にスナップショットを作成"] Main --> MainThread Main --> BinlogThread Main --> EventLoop Main --> TCPThread + Main --> ReactorThread Main --> HTTPThread Main --> WorkerPool Main --> SnapshotThread @@ -720,8 +730,9 @@ graph TB - AdminHandler、ReplicationHandler、DebugHandler - CacheHandler、SyncHandler（MySQL） 6. **RequestDispatcher**（ハンドラーに依存） -7. **ConnectionAcceptor**（ThreadPoolに依存） -8. **SnapshotScheduler**（オプショナル、catalogに依存） +7. **ConnectionAcceptor**（ServerConfig のみに依存。reactor handler は `TcpServer::Start()` で後付け） +8. **IoReactor**（`TcpServer::Start()` で生成、ThreadPool と RequestDispatcher に依存） +9. **SnapshotScheduler**（オプショナル、catalogに依存） **注記**: RateLimiterとSyncOperationManagerは、ServerLifecycleManagerがインスタンス化される前に`TcpServer::Start()`で作成されます。 @@ -933,8 +944,9 @@ class InvalidationManager { ### AcceptorとHandlersの間 -- **ConnectionAcceptor** → 接続を受け入れ → **ThreadPool**に投入 -- **ThreadPoolワーカー** → **ConnectionIOHandler**を呼び出し → **RequestDispatcher**を呼び出し → ハンドラを呼び出し +- **ConnectionAcceptor** → 接続を受け入れ → **IoReactor::Register** に直接渡す（thread pool ホップなし） +- **IoReactor (event loop thread)** → 読み取り可能を検知 → **ReactorConnection::OnReadable** → フレームを抽出 → drain task を **ThreadPool** にスケジュール +- **ThreadPool ワーカー** → **ReactorConnection::DrainTask** → **RequestDispatcher** にフレームをディスパッチ → ハンドラ → レスポンスを `EnqueueResponse()` → 高速パスでインライン送信、不完全送信時は EPOLLOUT で event loop に再送出 --- diff --git a/e2e/tests/load/test_load.py b/e2e/tests/load/test_load.py index a39c298..f999482 100644 --- a/e2e/tests/load/test_load.py +++ b/e2e/tests/load/test_load.py @@ -1,9 +1,9 @@ """Load and performance tests. Uses persistent TCP connections per worker to avoid ephemeral port exhaustion. -The server supports pipelined commands over a single connection (ConnectionIOHandler -processes multiple \\r\\n-delimited requests in a while loop), so each worker -keeps one socket open for the entire duration. +The server supports pipelined commands over a single connection: ReactorConnection +frames each ``\\r\\n``-delimited request inside a single drain task, so each +worker keeps one socket open for the entire duration. """ import json From ed04e249d14489655bd8a25441a90715c8f81196 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 08:53:18 +0900 Subject: [PATCH 08/13] fix(server): Drain pending reads on TCP half-close before tearing down MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A client that does `send(...); shutdown(SHUT_WR)` followed by `recv()` on the still-open read side was losing its response under the reactor I/O path. The blocking ConnectionIOHandler historically handled this case fine (it kept reading from the socket until EOF and flushed the response), so this is a regression from the switch to the reactor I/O path, uncovered by e2e/tests/load/test_connection_stress.py::test_half_close_write. Root cause — there were two bugs compounding each other: 1. src/server/io_reactor.cpp DispatchEvent treated `reactor::event::kHangup` (EV_EOF on kqueue, EPOLLRDHUP on epoll) as a *fatal* error alongside `kError`, short-circuiting straight to OnError() without ever calling OnReadable(). The half-close raises the kHangup flag on the *same* readable event as the payload bytes, so the reactor tore the connection down before reading the request. Fix: kError stays fatal, but kHangup now falls through to OnReadable(), which already knows how to drain to EOF. 2. src/server/reactor_connection.cpp OnReadable, on recv()==0, set the `closing_` flag. EnqueueResponse refuses to enqueue writes when `closing_` is set, so even if the drain task had run, the response would have been dropped on the floor. Fix: introduce a distinct `read_eof_` atomic for "peer has stopped writing" semantics. OnReadable sets `read_eof_` (not `closing_`) on orderly EOF and still extracts buffered frames into the drain queue. The drain task runs to completion, EnqueueResponse accepts the response (since `closing_` is false), the write queue drains via the inline fast path, and only then does the drain task set `closing_` and Unregister. OnWritable has matching handling for the case where the last response went out via the EPOLLOUT fallback path. Also: subsequent OnReadable calls while `read_eof_` is set no longer issue further recv() syscalls — the data side is definitely empty and we're waiting for the drain task to close us. Regression test: tests/integration/server/reactor_integration_test.cpp adds `HalfCloseStillReceivesResponse`, which mirrors the e2e test case: send INFO, shutdown(SHUT_WR), read back response bytes with raw recv(). Fails on the pre-fix code, passes with the fix. Validation: - Fast suite: 2165 / 2165 pass (baseline 2164 + the new regression guard). - e2e suite (e2e/tests/): 195 passed, 4 skipped, 0 failed (previously 1 failed on test_half_close_write). --- src/server/io_reactor.cpp | 14 +++- src/server/reactor_connection.cpp | 70 ++++++++++++++++--- src/server/reactor_connection.h | 12 ++++ .../server/reactor_integration_test.cpp | 62 ++++++++++++++++ 4 files changed, 146 insertions(+), 12 deletions(-) diff --git a/src/server/io_reactor.cpp b/src/server/io_reactor.cpp index 57dfdc9..8feac72 100644 --- a/src/server/io_reactor.cpp +++ b/src/server/io_reactor.cpp @@ -251,10 +251,20 @@ void IoReactor::DispatchEvent(const reactor::ReadyEvent& ev) { } bool keep = true; - if ((ev.events & (reactor::event::kError | reactor::event::kHangup)) != 0) { + // Hard error events short-circuit straight to OnError: the socket is no + // longer usable for either read or write. + if ((ev.events & reactor::event::kError) != 0) { keep = conn->OnError(); } else { - if ((ev.events & reactor::event::kReadable) != 0 && keep) { + // Hangup alone (EV_EOF on kqueue / EPOLLRDHUP on epoll) means the peer + // half-closed the write side of its socket. The *read* side of the + // server->client direction is still open, and the kernel may still have + // buffered payload bytes waiting to be drained. Fall through into + // OnReadable: its recv()==0 path sets read_eof_, finishes processing + // any pending frames, flushes the response via the drain task, and + // only then unregisters. Treating kHangup as a fatal error here causes + // the server to drop half-closed clients' responses on the floor. + if ((ev.events & (reactor::event::kReadable | reactor::event::kHangup)) != 0 && keep) { keep = conn->OnReadable(); } if ((ev.events & reactor::event::kWritable) != 0 && keep) { diff --git a/src/server/reactor_connection.cpp b/src/server/reactor_connection.cpp index 5f9ee39..c095310 100644 --- a/src/server/reactor_connection.cpp +++ b/src/server/reactor_connection.cpp @@ -67,6 +67,14 @@ bool ReactorConnection::OnReadable() { return false; } + // If the peer already half-closed (we saw recv()==0 on a previous readable + // event), suppress further recv() calls. The write side may still be open + // while the drain task flushes responses, so we remain registered until + // DrainTask finishes and marks us closing_. + if (read_eof_.load(std::memory_order_acquire)) { + return true; + } + // 1. Drain the socket until EAGAIN / EWOULDBLOCK. std::array chunk{}; while (true) { @@ -88,9 +96,14 @@ bool ReactorConnection::OnReadable() { continue; } if (n == 0) { - // Peer performed orderly close. - closing_.store(true, std::memory_order_release); - // Process any already-buffered frames before tearing down. + // Peer performed orderly close or half-close (shutdown(SHUT_WR)). The + // write side of the socket may still be open, so we must not tear down + // the connection here — we have to finish dispatching any already + // framed requests and flush the response. Set read_eof_ so subsequent + // OnReadable calls short-circuit, then fall through to frame + // extraction + drain task scheduling below. The drain task closes the + // connection after the last response has been queued for send. + read_eof_.store(true, std::memory_order_release); break; } // n < 0 @@ -118,19 +131,31 @@ bool ReactorConnection::OnReadable() { } // 3. If we parsed at least one frame, make sure a drain task is running. - // If none were parsed but the peer closed, we still need to tear down. + // The drain task will close the connection on behalf of the read path + // once read_eof_ is set and there is nothing left to flush. if (enqueued > 0) { if (!ScheduleDrainTask()) { return false; } } - // If the peer closed and there are no frames in flight, report close to - // the reactor. (If frames are still pending, the drain task will call - // Unregister after draining.) - if (closing_.load(std::memory_order_acquire)) { - std::lock_guard lock(frame_mutex_); - if (pending_frames_.empty() && !drain_scheduled_.load(std::memory_order_acquire)) { + // If the peer half-closed and there are no frames in flight and nothing + // pending in the write queue, we can tear down immediately. Otherwise the + // drain task (or OnWritable, after the write queue drains) will do the + // close for us. + if (read_eof_.load(std::memory_order_acquire)) { + bool nothing_to_dispatch = false; + { + std::lock_guard lock(frame_mutex_); + nothing_to_dispatch = pending_frames_.empty() && !drain_scheduled_.load(std::memory_order_acquire); + } + bool write_queue_empty = false; + { + std::lock_guard lock(write_mutex_); + write_queue_empty = write_queue_.empty(); + } + if (nothing_to_dispatch && write_queue_empty) { + closing_.store(true, std::memory_order_release); return false; } } @@ -158,6 +183,15 @@ bool ReactorConnection::OnWritable() { if (closing_.load(std::memory_order_acquire)) { return false; } + // Peer already half-closed and the drain task has no more work in + // flight: we just flushed the last response, so unregister now. + if (read_eof_.load(std::memory_order_acquire) && !drain_scheduled_.load(std::memory_order_acquire)) { + std::lock_guard frames_lock(frame_mutex_); + if (pending_frames_.empty()) { + closing_.store(true, std::memory_order_release); + return false; + } + } } // Partial drain: leave the queue armed, fire again on next writable event. return true; @@ -276,6 +310,22 @@ void ReactorConnection::DrainTask() { return; } + // If the peer half-closed (recv()==0) and we just finished dispatching the + // last buffered frame, we own the close. Wait for the write queue to + // drain first — the last response may still be in flight via + // EnqueueResponse's EPOLLOUT fallback, in which case OnWritable will + // perform the unregister once the queue empties. + if (read_eof_.load(std::memory_order_acquire) && !closing_.load(std::memory_order_acquire)) { + bool write_queue_empty = false; + { + std::lock_guard lock(write_mutex_); + write_queue_empty = write_queue_.empty(); + } + if (write_queue_empty) { + closing_.store(true, std::memory_order_release); + } + } + if (closing_.load(std::memory_order_acquire) && reactor_ != nullptr) { // Ask the reactor to unregister us. This is safe from a worker: the // IoReactor::Unregister acquires the connections_ write lock, and the diff --git a/src/server/reactor_connection.h b/src/server/reactor_connection.h index b0dd2fa..87f90b9 100644 --- a/src/server/reactor_connection.h +++ b/src/server/reactor_connection.h @@ -289,7 +289,19 @@ class ReactorConnection : public std::enable_shared_from_this bool write_armed_ = false; ///< Whether reactor_->ArmWrite was called for this fd. // Atomic flags. + /// Hard-close flag: connection must be torn down as soon as inflight work + /// completes. Set on I/O errors, overflow, or after a half-closed client's + /// pending frames have been fully dispatched *and* the write queue has + /// drained. `EnqueueResponse` refuses to accept new writes when this is set. std::atomic closing_{false}; + /// Peer-has-stopped-writing flag: set when recv() returns 0 (orderly FIN + /// from the client, including shutdown(SHUT_WR) half-close). Distinct from + /// `closing_` because the server must still be allowed to flush the + /// response for any already-buffered frames back to the peer — a TCP + /// half-close keeps the write side open. Once set, OnReadable stops + /// issuing recv() calls; the drain task closes the connection after the + /// last response has been queued for send. + std::atomic read_eof_{false}; std::atomic drain_scheduled_{false}; // Mirror of `write_queue_bytes_` for lock-free metric readers. diff --git a/tests/integration/server/reactor_integration_test.cpp b/tests/integration/server/reactor_integration_test.cpp index 1ccb532..faa7432 100644 --- a/tests/integration/server/reactor_integration_test.cpp +++ b/tests/integration/server/reactor_integration_test.cpp @@ -1246,6 +1246,68 @@ TEST_F(ReactorIntegrationTest, UnixSocketServedUnderReactorDefault) { std::filesystem::remove(sock_path, ec); } +// ---------------------------------------------------------------------------- +// Gap D — TCP half-close (shutdown(SHUT_WR)) must still receive the response +// ---------------------------------------------------------------------------- +// +// Regression guard for a bug in the initial reactor: when a client sent a +// request and then `shutdown(SHUT_WR)`, the server's recv() returned 0 and +// the reactor set `closing_`, which caused `EnqueueResponse` to reject the +// outgoing response. The client saw a RST instead of the INFO body. +// +// This test mirrors e2e/tests/load/test_connection_stress.py:: +// test_half_close_write and locks in the invariant that the server must +// finish dispatching + flushing any already-framed requests back to the peer +// before tearing the connection down, even after an orderly FIN on the +// read side. +TEST_F(ReactorIntegrationTest, HalfCloseStillReceivesResponse) { + auto server = StartServer(); + const uint16_t port = server->GetPort(); + + int s = Connect(port); + ASSERT_GE(s, 0) << "connect() failed"; + + // Send INFO and immediately half-close the write side. On kqueue this + // delivers the readable event together with EV_EOF, so IoReactor must + // route kHangup into OnReadable (not straight to OnError) and + // OnReadable's recv()==0 path must schedule a drain task that flushes the + // INFO response before unregistering. + const std::string wire = "INFO\r\n"; + ASSERT_EQ(::send(s, wire.data(), wire.size(), 0), + static_cast(wire.size())); + ASSERT_EQ(::shutdown(s, SHUT_WR), 0) << "shutdown(SHUT_WR) failed: " << strerror(errno); + + // Read raw bytes until the server closes or we time out. We cannot use + // RecvMultilineResponse here because it returns "" on EOF even if bytes + // were already accumulated — in the half-close scenario the server closes + // after flushing the response, so we must retain whatever we read before + // the EOF. + struct timeval io {}; + io.tv_sec = 3; + io.tv_usec = 0; + setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); + + std::string out; + std::array buf{}; + while (out.size() < 256 * 1024) { + ssize_t n = recv(s, buf.data(), buf.size(), 0); + if (n <= 0) break; // EOF or timeout — keep whatever we already buffered + out.append(buf.data(), static_cast(n)); + } + close(s); + + EXPECT_FALSE(out.empty()) + << "Server did not send any bytes after client half-closed write side " + "— reactor likely treated recv()==0 as a hard close and dropped " + "the buffered INFO response."; + if (!out.empty()) { + EXPECT_EQ(out.substr(0, 7), "OK INFO") + << "Unexpected INFO response after half-close: " << out.substr(0, 64); + } + + server->Stop(); +} + } // namespace mygramdb::server #endif // platform guard From d05dc7f97e9091ba88988e69c8d46d4cececc176 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 09:30:40 +0900 Subject: [PATCH 09/13] style: Apply clang-format to reactor and test files The reactor I/O model commits landed without a final clang-format pass, leaving the tree drifted from the project style config (ColumnLimit: 120, AllowShortIfStatementsOnASingleLine: Never). This commit is purely `clang-format -i` output over the affected files; no semantic changes. --- src/config/runtime_variable_manager.cpp | 20 +- src/server/io_reactor.cpp | 8 +- src/server/io_reactor.h | 2 +- src/server/reactor/epoll_multiplexer.cpp | 25 +-- src/server/reactor/event_multiplexer.h | 3 +- src/server/reactor/kqueue_multiplexer.cpp | 12 +- src/server/reactor/kqueue_multiplexer.h | 7 +- src/server/reactor_connection.cpp | 12 +- src/server/reactor_connection.h | 4 +- src/server/tcp_server.cpp | 97 +++++----- src/server/tcp_server.h | 1 - .../server/reactor_integration_test.cpp | 172 +++++++++--------- .../reactor_starvation_regression_test.cpp | 66 ++++--- .../server/thread_pool_saturation_test.cpp | 37 ++-- .../server/connection_acceptor_unix_test.cpp | 3 - tests/server/io_reactor_test.cpp | 17 +- .../server/reactor/event_multiplexer_test.cpp | 26 ++- .../server/reactor/mock_event_multiplexer.cpp | 29 ++- tests/server/reactor/mock_event_multiplexer.h | 3 +- tests/server/reactor_connection_test.cpp | 12 +- 20 files changed, 256 insertions(+), 300 deletions(-) diff --git a/src/config/runtime_variable_manager.cpp b/src/config/runtime_variable_manager.cpp index 6c31935..cb535d4 100644 --- a/src/config/runtime_variable_manager.cpp +++ b/src/config/runtime_variable_manager.cpp @@ -55,22 +55,22 @@ static const std::map kVariableMutability = { // API settings {"api.default_limit", true}, {"api.max_query_length", true}, - {"api.tcp.bind", false}, // Immutable (requires socket rebind) - {"api.tcp.port", false}, // Immutable - {"api.tcp.max_connections", false}, // Immutable - {"api.tcp.worker_threads", false}, // Immutable (thread pool is bound at startup) - {"api.tcp.recv_timeout_sec", false}, // Immutable (applied per connection at accept) + {"api.tcp.bind", false}, // Immutable (requires socket rebind) + {"api.tcp.port", false}, // Immutable + {"api.tcp.max_connections", false}, // Immutable + {"api.tcp.worker_threads", false}, // Immutable (thread pool is bound at startup) + {"api.tcp.recv_timeout_sec", false}, // Immutable (applied per connection at accept) {"api.tcp.thread_pool_queue_size", false}, // Immutable (thread pool queue sized at startup) {"api.tcp.keepalive.enabled", false}, // Immutable (applied per connection at accept) {"api.tcp.keepalive.idle_sec", false}, // Immutable {"api.tcp.keepalive.interval_sec", false}, // Immutable {"api.tcp.keepalive.probe_count", false}, // Immutable {"api.tcp.max_write_queue_bytes", false}, // Immutable (per-connection cap set at accept) - {"api.http.enable", false}, // Immutable - {"api.http.bind", false}, // Immutable - {"api.http.port", false}, // Immutable - {"api.http.enable_cors", false}, // Immutable - {"api.http.cors_allow_origin", false}, // Immutable + {"api.http.enable", false}, // Immutable + {"api.http.bind", false}, // Immutable + {"api.http.port", false}, // Immutable + {"api.http.enable_cors", false}, // Immutable + {"api.http.cors_allow_origin", false}, // Immutable // Rate limiting {"api.rate_limiting.enable", true}, diff --git a/src/server/io_reactor.cpp b/src/server/io_reactor.cpp index 8feac72..198b24b 100644 --- a/src/server/io_reactor.cpp +++ b/src/server/io_reactor.cpp @@ -175,9 +175,13 @@ void IoReactor::Unregister(int fd) { } } -void IoReactor::SetCloseCallback(std::function cb) { close_callback_ = std::move(cb); } +void IoReactor::SetCloseCallback(std::function cb) { + close_callback_ = std::move(cb); +} -void IoReactor::SetMultiplexerFactoryForTest(MultiplexerFactory f) { mux_factory_ = std::move(f); } +void IoReactor::SetMultiplexerFactoryForTest(MultiplexerFactory f) { + mux_factory_ = std::move(f); +} Expected IoReactor::ArmWrite(int fd) { std::shared_lock mux_lock(mux_lifecycle_); diff --git a/src/server/io_reactor.h b/src/server/io_reactor.h index bf11045..9e88a07 100644 --- a/src/server/io_reactor.h +++ b/src/server/io_reactor.h @@ -197,7 +197,7 @@ class IoReactor { /// without holding the connections_mutex_. std::shared_ptr Lookup(int fd) const; - ThreadPool* pool_; // non-owning + ThreadPool* pool_; // non-owning RequestDispatcher* dispatcher_; // non-owning ReactorConfig config_; diff --git a/src/server/reactor/epoll_multiplexer.cpp b/src/server/reactor/epoll_multiplexer.cpp index 33a06a9..c22339a 100644 --- a/src/server/reactor/epoll_multiplexer.cpp +++ b/src/server/reactor/epoll_multiplexer.cpp @@ -99,15 +99,13 @@ EpollMultiplexer::~EpollMultiplexer() { Expected EpollMultiplexer::Open() { if (epoll_fd_ >= 0) { return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorAlreadyOpen, - "EpollMultiplexer::Open called on already-open multiplexer")); + MakeError(ErrorCode::kNetworkReactorAlreadyOpen, "EpollMultiplexer::Open called on already-open multiplexer")); } const int fd = ::epoll_create1(EPOLL_CLOEXEC); if (fd < 0) { const int en = errno; - return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorInitFailed, FormatErrno("epoll_create1", en))); + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorInitFailed, FormatErrno("epoll_create1", en))); } epoll_fd_ = fd; return {}; @@ -120,8 +118,7 @@ Expected EpollMultiplexer::Add(int fd, uint8_t interest) { if (::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &ev) != 0) { const int en = errno; - return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorRegisterFailed, FormatErrno("epoll_ctl(ADD)", en))); + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorRegisterFailed, FormatErrno("epoll_ctl(ADD)", en))); } return {}; } @@ -133,8 +130,7 @@ Expected EpollMultiplexer::Modify(int fd, uint8_t interest) { if (::epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &ev) != 0) { const int en = errno; - return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorModifyFailed, FormatErrno("epoll_ctl(MOD)", en))); + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorModifyFailed, FormatErrno("epoll_ctl(MOD)", en))); } return {}; } @@ -148,8 +144,7 @@ Expected EpollMultiplexer::Remove(int fd) { if (en == ENOENT || en == EBADF) { return {}; } - return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorRemoveFailed, FormatErrno("epoll_ctl(DEL)", en))); + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorRemoveFailed, FormatErrno("epoll_ctl(DEL)", en))); } return {}; } @@ -157,8 +152,7 @@ Expected EpollMultiplexer::Remove(int fd) { Expected EpollMultiplexer::Poll(int timeout_ms, std::vector& out) { out.clear(); - const int n = - ::epoll_wait(epoll_fd_, events_.data(), static_cast(events_.size()), timeout_ms); + const int n = ::epoll_wait(epoll_fd_, events_.data(), static_cast(events_.size()), timeout_ms); if (n < 0) { const int en = errno; // EINTR is not an error condition: a signal interrupted the wait and the @@ -166,8 +160,7 @@ Expected EpollMultiplexer::Poll(int timeout_ms, std::vector(n)); @@ -178,7 +171,9 @@ Expected EpollMultiplexer::Poll(int timeout_ms, std::vector Poll(int timeout_ms, - std::vector& out) = 0; + virtual mygram::utils::Expected Poll(int timeout_ms, std::vector& out) = 0; /** * @brief Backend identifier for metrics and log fields. diff --git a/src/server/reactor/kqueue_multiplexer.cpp b/src/server/reactor/kqueue_multiplexer.cpp index 9b4c0d5..8dea336 100644 --- a/src/server/reactor/kqueue_multiplexer.cpp +++ b/src/server/reactor/kqueue_multiplexer.cpp @@ -88,7 +88,8 @@ Expected KqueueMultiplexer::Open() { if (::fcntl(kq, F_SETFD, FD_CLOEXEC) < 0) { const int en = errno; ::close(kq); - return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorInitFailed, FormatErrno("fcntl(F_SETFD, FD_CLOEXEC)", en))); + return MakeUnexpected( + MakeError(ErrorCode::kNetworkReactorInitFailed, FormatErrno("fcntl(F_SETFD, FD_CLOEXEC)", en))); } kqueue_fd_ = kq; @@ -96,7 +97,7 @@ Expected KqueueMultiplexer::Open() { } Expected KqueueMultiplexer::ApplyInterest(int fd, uint8_t new_interest, uint8_t old_interest, - bool is_add) { + bool is_add) { // kqueue has no single-call "set the interest set of this fd to X" primitive // the way `epoll_ctl(MOD)` does, so we diff the new interest against the // previously-armed interest and emit at most two change records: one per @@ -136,8 +137,7 @@ Expected KqueueMultiplexer::ApplyInterest(int fd, uint8_t new_inter if (::kevent(kqueue_fd_, changes.data(), nchanges, nullptr, 0, nullptr) < 0) { const int en = errno; - const ErrorCode code = - is_add ? ErrorCode::kNetworkReactorRegisterFailed : ErrorCode::kNetworkReactorModifyFailed; + const ErrorCode code = is_add ? ErrorCode::kNetworkReactorRegisterFailed : ErrorCode::kNetworkReactorModifyFailed; return MakeUnexpected( MakeError(code, FormatErrno(is_add ? "kevent(EV_ADD)" : "kevent(modify)", en), "fd=" + std::to_string(fd))); } @@ -234,8 +234,8 @@ Expected KqueueMultiplexer::Remove(int fd) { if (en == ENOENT || en == EBADF) { return {}; } - return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorRemoveFailed, FormatErrno("kevent(EV_DELETE)", en), "fd=" + std::to_string(fd))); + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorRemoveFailed, FormatErrno("kevent(EV_DELETE)", en), + "fd=" + std::to_string(fd))); } return {}; diff --git a/src/server/reactor/kqueue_multiplexer.h b/src/server/reactor/kqueue_multiplexer.h index 560b2d3..9db02c5 100644 --- a/src/server/reactor/kqueue_multiplexer.h +++ b/src/server/reactor/kqueue_multiplexer.h @@ -76,8 +76,7 @@ class KqueueMultiplexer final : public EventMultiplexer { mygram::utils::Expected Remove(int fd) override; /// @copydoc EventMultiplexer::Poll - mygram::utils::Expected Poll(int timeout_ms, - std::vector& out) override; + mygram::utils::Expected Poll(int timeout_ms, std::vector& out) override; /// Backend identifier for metrics and logging. const char* Name() const override { return "kqueue"; } @@ -99,8 +98,8 @@ class KqueueMultiplexer final : public EventMultiplexer { * single `kevent()` call. Returns `kNetworkReactorRegisterFailed` (on add) * or `kNetworkReactorModifyFailed` (on modify) if the syscall fails. */ - mygram::utils::Expected ApplyInterest(int fd, uint8_t new_interest, - uint8_t old_interest, bool is_add); + mygram::utils::Expected ApplyInterest(int fd, uint8_t new_interest, uint8_t old_interest, + bool is_add); int kqueue_fd_ = -1; diff --git a/src/server/reactor_connection.cpp b/src/server/reactor_connection.cpp index c095310..f84a652 100644 --- a/src/server/reactor_connection.cpp +++ b/src/server/reactor_connection.cpp @@ -43,8 +43,8 @@ std::shared_ptr ReactorConnection::Create(int fd, IoReactor* return std::make_shared(fd, reactor, dispatcher, thread_pool, stats, max_write_queue_bytes); } -ReactorConnection::ReactorConnection(int fd, IoReactor* reactor, RequestDispatcher* dispatcher, - ThreadPool* thread_pool, ServerStats* stats, size_t max_write_queue_bytes) +ReactorConnection::ReactorConnection(int fd, IoReactor* reactor, RequestDispatcher* dispatcher, ThreadPool* thread_pool, + ServerStats* stats, size_t max_write_queue_bytes) : fd_(fd), max_write_queue_bytes_(max_write_queue_bytes), reactor_(reactor), @@ -239,8 +239,7 @@ size_t ReactorConnection::ExtractFramesLocked() { bool ReactorConnection::ScheduleDrainTask() { bool expected = false; - if (!drain_scheduled_.compare_exchange_strong(expected, true, std::memory_order_acq_rel, - std::memory_order_acquire)) { + if (!drain_scheduled_.compare_exchange_strong(expected, true, std::memory_order_acq_rel, std::memory_order_acquire)) { // A drain task is already running or queued; it will pick up the new // frames when it next checks `pending_frames_`. return true; @@ -256,10 +255,7 @@ bool ReactorConnection::ScheduleDrainTask() { const bool submitted = thread_pool_->Submit([self]() { self->DrainTask(); }); if (!submitted) { drain_scheduled_.store(false, std::memory_order_release); - mygram::utils::StructuredLog() - .Event("reactor_drain_submit_failed") - .Field("fd", static_cast(fd_)) - .Warn(); + mygram::utils::StructuredLog().Event("reactor_drain_submit_failed").Field("fd", static_cast(fd_)).Warn(); closing_.store(true, std::memory_order_release); return false; } diff --git a/src/server/reactor_connection.h b/src/server/reactor_connection.h index 87f90b9..7783de5 100644 --- a/src/server/reactor_connection.h +++ b/src/server/reactor_connection.h @@ -159,9 +159,7 @@ class ReactorConnection : public std::enable_shared_from_this bool OnError(); /// Current bytes held in the pending write accounting (for metrics / tests). - [[nodiscard]] size_t PendingWriteBytes() const { - return pending_write_bytes_.load(std::memory_order_relaxed); - } + [[nodiscard]] size_t PendingWriteBytes() const { return pending_write_bytes_.load(std::memory_order_relaxed); } /// Whether `closing_` has been set. Exposed for tests. [[nodiscard]] bool IsClosing() const { return closing_.load(std::memory_order_acquire); } diff --git a/src/server/tcp_server.cpp b/src/server/tcp_server.cpp index 2708f59..b21270b 100644 --- a/src/server/tcp_server.cpp +++ b/src/server/tcp_server.cpp @@ -245,10 +245,7 @@ mygram::utils::Expected TcpServer::Start() { return MakeUnexpected(r.error()); } } - mygram::utils::StructuredLog() - .Event("reactor_mode_enabled") - .Field("backend", reactor_->BackendName()) - .Info(); + mygram::utils::StructuredLog().Event("reactor_mode_enabled").Field("backend", reactor_->BackendName()).Info(); // Install the acceptor reactor handler. // @@ -268,53 +265,53 @@ mygram::utils::Expected TcpServer::Start() { const size_t max_write_bytes = config_.max_write_queue_bytes > 0 ? static_cast(config_.max_write_queue_bytes) : ReactorConnection::kDefaultMaxWriteQueueBytes; - acceptor_->SetReactorHandler([reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, rate_limiter_ptr, - max_write_bytes](int client_fd) -> bool { - // Rate limit check (TCP only; rate_limiter_ptr is null on UDS acceptors). - // Extract the peer IP via getpeername() and call AllowRequest(). On - // rejection we return false so the acceptor emits SERVER_BUSY + closes - // the fd (see ConnectionAcceptor::AcceptLoop). - if (rate_limiter_ptr != nullptr) { - struct sockaddr_storage addr_storage {}; - socklen_t addr_len = sizeof(addr_storage); - std::string client_ip; - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API - if (getpeername(client_fd, reinterpret_cast(&addr_storage), &addr_len) == 0 && - addr_storage.ss_family == AF_INET) { - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API - auto* addr_in = reinterpret_cast(&addr_storage); - char ip_str[INET_ADDRSTRLEN]; // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) - inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN); - // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) - client_ip = ip_str; - } else { - client_ip = "unknown"; - } - if (!rate_limiter_ptr->AllowRequest(client_ip)) { - mygram::utils::StructuredLog() - .Event("server_warning") - .Field("type", "rate_limit_exceeded") - .Field("client_ip", client_ip) - .Warn(); + acceptor_->SetReactorHandler( + [reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, rate_limiter_ptr, max_write_bytes](int client_fd) -> bool { + // Rate limit check (TCP only; rate_limiter_ptr is null on UDS acceptors). + // Extract the peer IP via getpeername() and call AllowRequest(). On + // rejection we return false so the acceptor emits SERVER_BUSY + closes + // the fd (see ConnectionAcceptor::AcceptLoop). + if (rate_limiter_ptr != nullptr) { + struct sockaddr_storage addr_storage {}; + socklen_t addr_len = sizeof(addr_storage); + std::string client_ip; + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API + if (getpeername(client_fd, reinterpret_cast(&addr_storage), &addr_len) == 0 && + addr_storage.ss_family == AF_INET) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API + auto* addr_in = reinterpret_cast(&addr_storage); + char ip_str[INET_ADDRSTRLEN]; // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) + inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay) + client_ip = ip_str; + } else { + client_ip = "unknown"; + } + if (!rate_limiter_ptr->AllowRequest(client_ip)) { + mygram::utils::StructuredLog() + .Event("server_warning") + .Field("type", "rate_limit_exceeded") + .Field("client_ip", client_ip) + .Warn(); + return false; + } + } + + auto conn = + ReactorConnection::Create(client_fd, reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, max_write_bytes); + auto reg = reactor_ptr->Register(conn); + if (reg.has_value()) { + // Count this as an active connection so GetConnectionCount() and the + // mygramdb_active_connections metric report the live reactor + // population. The matching decrement happens in the close callback + // installed above. + stats_ptr->IncrementConnections(); + stats_ptr->IncrementTotalConnections(); + return true; + } return false; - } - } - - auto conn = ReactorConnection::Create(client_fd, reactor_ptr, dispatcher_ptr, pool_ptr, stats_ptr, - max_write_bytes); - auto reg = reactor_ptr->Register(conn); - if (reg.has_value()) { - // Count this as an active connection so GetConnectionCount() and the - // mygramdb_active_connections metric report the live reactor - // population. The matching decrement happens in the close callback - // installed above. - stats_ptr->IncrementConnections(); - stats_ptr->IncrementTotalConnections(); - return true; - } - return false; - }); + }); } mygram::utils::StructuredLog() diff --git a/src/server/tcp_server.h b/src/server/tcp_server.h index 1c0591b..e3492ee 100644 --- a/src/server/tcp_server.h +++ b/src/server/tcp_server.h @@ -138,7 +138,6 @@ class TcpServer { */ ServerStats* GetMutableStats() { return &stats_; } - /** * @brief Get dump load in progress flag pointer (for HttpServer) */ diff --git a/tests/integration/server/reactor_integration_test.cpp b/tests/integration/server/reactor_integration_test.cpp index faa7432..eef67ec 100644 --- a/tests/integration/server/reactor_integration_test.cpp +++ b/tests/integration/server/reactor_integration_test.cpp @@ -12,8 +12,7 @@ // Platform guard: compile-time skip for unsupported platforms. // macOS (kqueue) and Linux (epoll) are the two real targets. -#if !defined(__linux__) && !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \ - !defined(__OpenBSD__) +#if !defined(__linux__) && !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) #include // Provide a trivially-passing placeholder so the binary links cleanly. TEST(ReactorIntegrationTest, PlatformNotSupported) { @@ -87,7 +86,7 @@ class ReactorIntegrationTest : public ::testing::Test { * @brief Start a TcpServer and return it. */ std::unique_ptr StartServer(int worker_threads = 8, int max_connections = 512, - int64_t max_write_queue_bytes = 0) { + int64_t max_write_queue_bytes = 0) { ServerConfig cfg; cfg.host = "127.0.0.1"; cfg.port = 0; // OS assigns @@ -100,8 +99,7 @@ class ReactorIntegrationTest : public ::testing::Test { auto s = std::make_unique(cfg, table_contexts_); auto res = s->Start(); - EXPECT_TRUE(res) << "Failed to start TcpServer: " - << (res ? std::string{} : res.error().to_string()); + EXPECT_TRUE(res) << "Failed to start TcpServer: " << (res ? std::string{} : res.error().to_string()); // Give the accept loop a moment to reach its main loop. std::this_thread::sleep_for(std::chrono::milliseconds(30)); return s; @@ -117,10 +115,12 @@ class ReactorIntegrationTest : public ::testing::Test { */ int Connect(uint16_t port, int timeout_ms = 2000) { int sock = socket(AF_INET, SOCK_STREAM, 0); - if (sock < 0) return -1; + if (sock < 0) + return -1; int flags = fcntl(sock, F_GETFL, 0); - if (flags >= 0) fcntl(sock, F_SETFL, flags | O_NONBLOCK); + if (flags >= 0) + fcntl(sock, F_SETFL, flags | O_NONBLOCK); struct sockaddr_in addr {}; addr.sin_family = AF_INET; @@ -155,7 +155,8 @@ class ReactorIntegrationTest : public ::testing::Test { } // Restore flags; set I/O timeout for blocking reads - if (flags >= 0) fcntl(sock, F_SETFL, flags); + if (flags >= 0) + fcntl(sock, F_SETFL, flags); struct timeval io {}; io.tv_sec = 5; setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &io, sizeof(io)); @@ -190,12 +191,15 @@ class ReactorIntegrationTest : public ::testing::Test { std::array buf{}; while (out.size() < 65536) { ssize_t n = recv(sock, buf.data(), buf.size(), 0); - if (n <= 0) return ""; + if (n <= 0) + return ""; out.append(buf.data(), static_cast(n)); - if (out.find("\r\n") != std::string::npos) break; + if (out.find("\r\n") != std::string::npos) + break; } auto pos = out.find("\r\n"); - if (pos != std::string::npos) out.resize(pos); + if (pos != std::string::npos) + out.resize(pos); return out; } @@ -224,10 +228,10 @@ class ReactorIntegrationTest : public ::testing::Test { std::array buf{}; while (out.size() < 1 * 1024 * 1024) { ssize_t n = recv(sock, buf.data(), buf.size(), 0); - if (n <= 0) return ""; + if (n <= 0) + return ""; out.append(buf.data(), static_cast(n)); - if (out.size() >= kTerminatorLen && - out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { + if (out.size() >= kTerminatorLen && out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { return out; } } @@ -240,7 +244,8 @@ class ReactorIntegrationTest : public ::testing::Test { */ static rlim_t RaiseFdLimit(rlim_t desired) { struct rlimit rl {}; - if (getrlimit(RLIMIT_NOFILE, &rl) != 0) return 0; + if (getrlimit(RLIMIT_NOFILE, &rl) != 0) + return 0; rlim_t target = std::min(desired, rl.rlim_max); if (rl.rlim_cur < target) { rl.rlim_cur = target; @@ -389,11 +394,12 @@ TEST_F(ReactorIntegrationTest, ConcurrentClients100) { std::vector threads; threads.reserve(kClients); - for (int i = 0; i < kClients; ++i) threads.emplace_back(client_task); - for (auto& t : threads) t.join(); + for (int i = 0; i < kClients; ++i) + threads.emplace_back(client_task); + for (auto& t : threads) + t.join(); - EXPECT_EQ(failures.load(), 0) - << failures.load() << " out of " << kClients << " clients encountered errors"; + EXPECT_EQ(failures.load(), 0) << failures.load() << " out of " << kClients << " clients encountered errors"; server->Stop(); } @@ -425,8 +431,7 @@ TEST_F(ReactorIntegrationTest, ConcurrentClientsMany) { << "re-run with ulimit -n 2048"; } - std::cout << "[ConcurrentClientsMany] using " << max_clients << " clients (rlimit=" << effective << ")" - << std::endl; + std::cout << "[ConcurrentClientsMany] using " << max_clients << " clients (rlimit=" << effective << ")" << std::endl; constexpr int kCmdsPerClient = 5; std::atomic failures{0}; @@ -468,11 +473,12 @@ TEST_F(ReactorIntegrationTest, ConcurrentClientsMany) { std::vector threads; threads.reserve(max_clients); - for (int i = 0; i < max_clients; ++i) threads.emplace_back(client_task); - for (auto& t : threads) t.join(); + for (int i = 0; i < max_clients; ++i) + threads.emplace_back(client_task); + for (auto& t : threads) + t.join(); - EXPECT_EQ(failures.load(), 0) - << failures.load() << " out of " << max_clients << " clients failed"; + EXPECT_EQ(failures.load(), 0) << failures.load() << " out of " << max_clients << " clients failed"; server->Stop(); } @@ -504,7 +510,8 @@ TEST_F(ReactorIntegrationTest, ClientDisconnectMidRequest) { // until the server reports zero active connections (or timeout). auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(3); while (std::chrono::steady_clock::now() < deadline) { - if (server->GetConnectionCount() == 0) break; + if (server->GetConnectionCount() == 0) + break; std::this_thread::sleep_for(std::chrono::milliseconds(10)); } @@ -552,7 +559,8 @@ TEST_F(ReactorIntegrationTest, ClientDisconnectDuringResponse) { // Wait for the abrupt client to be cleaned up auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(3); while (std::chrono::steady_clock::now() < deadline) { - if (server->GetConnectionCount() == 0) break; + if (server->GetConnectionCount() == 0) + break; std::this_thread::sleep_for(std::chrono::milliseconds(10)); } @@ -691,11 +699,11 @@ TEST_F(ReactorIntegrationTest, ReactorModeDoesNotStarvePersistentFleet) { EXPECT_EQ(resp.substr(0, 7), "OK INFO") << "9th client starved in reactor mode with " << kPinned << " idle connections"; - EXPECT_LT(elapsed_ms, 500) - << "9th client responded but took " << elapsed_ms << "ms (>500ms) in reactor mode"; + EXPECT_LT(elapsed_ms, 500) << "9th client responded but took " << elapsed_ms << "ms (>500ms) in reactor mode"; close(late); - for (int s : pinned) close(s); + for (int s : pinned) + close(s); server->Stop(); } @@ -729,7 +737,8 @@ TEST_F(ReactorIntegrationTest, ClientSendsLargeFrame) { size_t sent_total = 0; while (sent_total < big_cmd.size()) { ssize_t n = send(s, big_cmd.data() + sent_total, big_cmd.size() - sent_total, 0); - if (n <= 0) break; + if (n <= 0) + break; sent_total += static_cast(n); } // We don't assert a specific response here — just that the connection is @@ -755,8 +764,8 @@ TEST_F(ReactorIntegrationTest, ClientSendsLargeFrame) { size_t sent_total = 0; bool got_epipe = false; while (sent_total < huge_cmd.size()) { - ssize_t n = send(s, huge_cmd.data() + sent_total, - std::min(65536, huge_cmd.size() - sent_total), MSG_NOSIGNAL); + ssize_t n = + send(s, huge_cmd.data() + sent_total, std::min(65536, huge_cmd.size() - sent_total), MSG_NOSIGNAL); if (n <= 0) { got_epipe = (errno == EPIPE || errno == ECONNRESET); break; @@ -839,11 +848,13 @@ TEST_F(ReactorIntegrationTest, WriteBackpressureHandledGracefully) { // 64 KiB cap once the slow reader's recv buffer is full. std::string burst; burst.reserve(8 * 1024); - for (int i = 0; i < 1024; ++i) burst.append("INFO\r\n"); + for (int i = 0; i < 1024; ++i) + burst.append("INFO\r\n"); ssize_t sent = 0; while (sent < static_cast(burst.size())) { ssize_t n = send(slow, burst.data() + sent, burst.size() - sent, MSG_NOSIGNAL); - if (n <= 0) break; + if (n <= 0) + break; sent += n; } // Slow reader deliberately does NOT recv(). @@ -884,13 +895,14 @@ TEST_F(ReactorIntegrationTest, WriteBackpressureHandledGracefully) { std::vector fast_threads; fast_threads.reserve(kFastClients); - for (int i = 0; i < kFastClients; ++i) fast_threads.emplace_back(fast_client_task); - for (auto& t : fast_threads) t.join(); + for (int i = 0; i < kFastClients; ++i) + fast_threads.emplace_back(fast_client_task); + for (auto& t : fast_threads) + t.join(); // Invariant: every fast client request must have succeeded. - EXPECT_EQ(fast_failures.load(), 0) - << fast_failures.load() << " fast-client failures while slow reader was " - << "backpressured; reactor should have isolated the slow reader but did not"; + EXPECT_EQ(fast_failures.load(), 0) << fast_failures.load() << " fast-client failures while slow reader was " + << "backpressured; reactor should have isolated the slow reader but did not"; EXPECT_EQ(fast_successes.load(), kFastClients * kFastCommandsPerClient); // The slow reader should eventually be force-closed by the reactor once @@ -923,9 +935,8 @@ TEST_F(ReactorIntegrationTest, WriteBackpressureHandledGracefully) { // until the buffer is empty and FIN shows up. } - EXPECT_TRUE(slow_closed) - << "Slow reader was never force-closed by the reactor within 5s " - << "despite piling up responses against a 64 KiB write queue cap"; + EXPECT_TRUE(slow_closed) << "Slow reader was never force-closed by the reactor within 5s " + << "despite piling up responses against a 64 KiB write queue cap"; close(slow); server->Stop(); @@ -981,7 +992,8 @@ TEST_F(ReactorIntegrationTest, ManyIdleConnectionsDoNotBlockActiveClient) { if (s < 0) { // Couldn't open all the sockets we wanted; run with what we got if // we still have at least kMinIdleClientsToRun. - if (static_cast(idle_socks.size()) >= kMinIdleClientsToRun) break; + if (static_cast(idle_socks.size()) >= kMinIdleClientsToRun) + break; GTEST_SKIP() << "Failed to open idle client " << i << "; fd budget exhausted"; } if (!SendLine(s, "INFO")) { @@ -997,8 +1009,7 @@ TEST_F(ReactorIntegrationTest, ManyIdleConnectionsDoNotBlockActiveClient) { } std::cout << "[ManyIdleConnectionsDoNotBlockActiveClient] " - << "idle_clients=" << idle_socks.size() << " workers=" << kWorkers - << " rlimit=" << effective << std::endl; + << "idle_clients=" << idle_socks.size() << " workers=" << kWorkers << " rlimit=" << effective << std::endl; ASSERT_GE(static_cast(idle_socks.size()), kMinIdleClientsToRun) << "Not enough idle clients opened to meaningfully stress the server"; @@ -1014,22 +1025,20 @@ TEST_F(ReactorIntegrationTest, ManyIdleConnectionsDoNotBlockActiveClient) { auto t0 = std::chrono::steady_clock::now(); std::string resp = RecvMultilineResponse(active, /*timeout_ms=*/500); - auto elapsed_ms = std::chrono::duration_cast( - std::chrono::steady_clock::now() - t0) - .count(); + auto elapsed_ms = + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0).count(); - EXPECT_FALSE(resp.empty()) - << "Active client starved with " << idle_socks.size() - << " idle persistent connections — the G1 invariant failed"; + EXPECT_FALSE(resp.empty()) << "Active client starved with " << idle_socks.size() + << " idle persistent connections — the G1 invariant failed"; if (!resp.empty()) { EXPECT_EQ(resp.substr(0, 7), "OK INFO"); - EXPECT_LT(elapsed_ms, 500) - << "Active client responded but took " << elapsed_ms << "ms (>500ms) with " - << idle_socks.size() << " idle persistent connections"; + EXPECT_LT(elapsed_ms, 500) << "Active client responded but took " << elapsed_ms << "ms (>500ms) with " + << idle_socks.size() << " idle persistent connections"; } close(active); - for (int s : idle_socks) close(s); + for (int s : idle_socks) + close(s); server->Stop(); } @@ -1067,7 +1076,8 @@ TEST_F(ReactorIntegrationTest, RateLimitEnforcedInReactorMode) { auto open_and_info = [&](int idx) -> std::string { int s = Connect(port); - if (s < 0) return std::string("__connect_failed__"); + if (s < 0) + return std::string("__connect_failed__"); std::string result; if (SendLine(s, "INFO")) { result = RecvMultilineResponse(s, /*timeout_ms=*/1500); @@ -1089,10 +1099,9 @@ TEST_F(ReactorIntegrationTest, RateLimitEnforcedInReactorMode) { // may accept the TCP SYN (so connect() succeeds) but must close the fd // without sending a response. const std::string r2 = open_and_info(2); - EXPECT_TRUE(r2.empty()) - << "Rate limiter did not enforce the per-IP cap under reactor mode: " - "expected connection 2 to be closed without a response, but got: " - << r2; + EXPECT_TRUE(r2.empty()) << "Rate limiter did not enforce the per-IP cap under reactor mode: " + "expected connection 2 to be closed without a response, but got: " + << r2; server->Stop(); } @@ -1151,9 +1160,8 @@ TEST_F(ReactorIntegrationTest, MaxQueryLengthEnforcedInReactorMode) { // The reactor path must either close the connection or return an error // line. It must NOT dispatch the oversized query as if it were valid. const bool is_ok_response = resp.find("OK RESULTS") == 0 || resp.find("OK COUNT") == 0; - EXPECT_FALSE(is_ok_response) - << "max_query_length=" << cfg.max_query_length - << " but reactor accepted a 4 KiB query and returned: " << resp; + EXPECT_FALSE(is_ok_response) << "max_query_length=" << cfg.max_query_length + << " but reactor accepted a 4 KiB query and returned: " << resp; server->Stop(); } @@ -1170,9 +1178,8 @@ TEST_F(ReactorIntegrationTest, MaxQueryLengthEnforcedInReactorMode) { TEST_F(ReactorIntegrationTest, UnixSocketServedUnderReactorDefault) { // Unique socket path per run so parallel test runs don't collide. const auto pid = ::getpid(); - const auto ts = std::chrono::duration_cast( - std::chrono::steady_clock::now().time_since_epoch()) - .count(); + const auto ts = + std::chrono::duration_cast(std::chrono::steady_clock::now().time_since_epoch()).count(); std::filesystem::path sock_path = std::filesystem::temp_directory_path() / ("mygramdb_reactor_uds_test_" + std::to_string(pid) + "_" + std::to_string(ts) + ".sock"); @@ -1207,8 +1214,7 @@ TEST_F(ReactorIntegrationTest, UnixSocketServedUnderReactorDefault) { // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) - POSIX socket API int rc = ::connect(s, reinterpret_cast(&addr), sizeof(addr)); - ASSERT_EQ(rc, 0) << "connect(AF_UNIX) failed: " << strerror(errno) - << " (path=" << sock_path << ")"; + ASSERT_EQ(rc, 0) << "connect(AF_UNIX) failed: " << strerror(errno) << " (path=" << sock_path << ")"; struct timeval io {}; io.tv_sec = 3; @@ -1219,8 +1225,7 @@ TEST_F(ReactorIntegrationTest, UnixSocketServedUnderReactorDefault) { // Send INFO and read the multiline response. We reuse the helper by // wrapping send() + RecvMultilineResponse() logic inline. const std::string wire = "INFO\r\n"; - ASSERT_EQ(::send(s, wire.data(), wire.size(), 0), - static_cast(wire.size())); + ASSERT_EQ(::send(s, wire.data(), wire.size(), 0), static_cast(wire.size())); static constexpr const char kTerminator[] = "\r\nEND\r\n"; static constexpr size_t kTerminatorLen = 7; @@ -1228,18 +1233,17 @@ TEST_F(ReactorIntegrationTest, UnixSocketServedUnderReactorDefault) { std::array buf{}; while (out.size() < 256 * 1024) { ssize_t n = recv(s, buf.data(), buf.size(), 0); - if (n <= 0) break; + if (n <= 0) + break; out.append(buf.data(), static_cast(n)); - if (out.size() >= kTerminatorLen && - out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { + if (out.size() >= kTerminatorLen && out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { break; } } close(s); EXPECT_FALSE(out.empty()) << "UDS client received no response"; - EXPECT_EQ(out.substr(0, 7), "OK INFO") - << "UDS INFO response was not OK INFO: " << out; + EXPECT_EQ(out.substr(0, 7), "OK INFO") << "UDS INFO response was not OK INFO: " << out; server->Stop(); // Best-effort socket file cleanup. @@ -1273,8 +1277,7 @@ TEST_F(ReactorIntegrationTest, HalfCloseStillReceivesResponse) { // OnReadable's recv()==0 path must schedule a drain task that flushes the // INFO response before unregistering. const std::string wire = "INFO\r\n"; - ASSERT_EQ(::send(s, wire.data(), wire.size(), 0), - static_cast(wire.size())); + ASSERT_EQ(::send(s, wire.data(), wire.size(), 0), static_cast(wire.size())); ASSERT_EQ(::shutdown(s, SHUT_WR), 0) << "shutdown(SHUT_WR) failed: " << strerror(errno); // Read raw bytes until the server closes or we time out. We cannot use @@ -1291,18 +1294,17 @@ TEST_F(ReactorIntegrationTest, HalfCloseStillReceivesResponse) { std::array buf{}; while (out.size() < 256 * 1024) { ssize_t n = recv(s, buf.data(), buf.size(), 0); - if (n <= 0) break; // EOF or timeout — keep whatever we already buffered + if (n <= 0) + break; // EOF or timeout — keep whatever we already buffered out.append(buf.data(), static_cast(n)); } close(s); - EXPECT_FALSE(out.empty()) - << "Server did not send any bytes after client half-closed write side " - "— reactor likely treated recv()==0 as a hard close and dropped " - "the buffered INFO response."; + EXPECT_FALSE(out.empty()) << "Server did not send any bytes after client half-closed write side " + "— reactor likely treated recv()==0 as a hard close and dropped " + "the buffered INFO response."; if (!out.empty()) { - EXPECT_EQ(out.substr(0, 7), "OK INFO") - << "Unexpected INFO response after half-close: " << out.substr(0, 64); + EXPECT_EQ(out.substr(0, 7), "OK INFO") << "Unexpected INFO response after half-close: " << out.substr(0, 64); } server->Stop(); diff --git a/tests/integration/server/reactor_starvation_regression_test.cpp b/tests/integration/server/reactor_starvation_regression_test.cpp index b788631..345a91e 100644 --- a/tests/integration/server/reactor_starvation_regression_test.cpp +++ b/tests/integration/server/reactor_starvation_regression_test.cpp @@ -88,7 +88,7 @@ class ReactorStarvationRegressionTest : public ::testing::Test { fcntl(sock, F_SETFL, flags | O_NONBLOCK); } - struct sockaddr_in addr{}; + struct sockaddr_in addr {}; addr.sin_family = AF_INET; addr.sin_port = htons(port); inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr); @@ -104,7 +104,7 @@ class ReactorStarvationRegressionTest : public ::testing::Test { fd_set ws; FD_ZERO(&ws); FD_SET(sock, &ws); - struct timeval tv{}; + struct timeval tv {}; tv.tv_sec = timeout_ms / 1000; tv.tv_usec = (timeout_ms % 1000) * 1000; int ready = select(sock + 1, nullptr, &ws, nullptr, &tv); @@ -146,7 +146,7 @@ class ReactorStarvationRegressionTest : public ::testing::Test { * trailing `\r\nEND\r\n`), or empty string on timeout / peer close. */ std::string RecvMultilineResponse(int sock, int timeout_ms = 5000) { - struct timeval tv{}; + struct timeval tv {}; tv.tv_sec = timeout_ms / 1000; tv.tv_usec = (timeout_ms % 1000) * 1000; setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); @@ -162,8 +162,7 @@ class ReactorStarvationRegressionTest : public ::testing::Test { return ""; } out.append(buf.data(), static_cast(n)); - if (out.size() >= kTerminatorLen && - out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { + if (out.size() >= kTerminatorLen && out.compare(out.size() - kTerminatorLen, kTerminatorLen, kTerminator) == 0) { return out; } } @@ -185,8 +184,7 @@ class ReactorStarvationRegressionTest : public ::testing::Test { cfg.recv_timeout_sec = 0; auto s = std::make_unique(cfg, table_contexts_); auto res = s->Start(); - EXPECT_TRUE(res) << "Failed to start TcpServer: " - << (res ? std::string{} : res.error().to_string()); + EXPECT_TRUE(res) << "Failed to start TcpServer: " << (res ? std::string{} : res.error().to_string()); // Give the accept loop a moment to reach its main select/epoll/kqueue call. std::this_thread::sleep_for(std::chrono::milliseconds(50)); return s; @@ -196,7 +194,7 @@ class ReactorStarvationRegressionTest : public ::testing::Test { // FD limit helper // ------------------------------------------------------------------------- static rlim_t RaiseFdLimit(rlim_t desired) { - struct rlimit rl{}; + struct rlimit rl {}; if (getrlimit(RLIMIT_NOFILE, &rl) != 0) { return 0; } @@ -261,7 +259,8 @@ TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarv } if (pin_failures > 0) { - for (int s : pinned) close(s); + for (int s : pinned) + close(s); server->Stop(); GTEST_SKIP() << "Could only open " << pinned.size() << " of " << kPinnedClients << " pinned client sockets (fd budget?). Skipping."; @@ -287,10 +286,9 @@ TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarv } } - EXPECT_EQ(pinned_ok.load(), kPinnedClients) - << "Only " << pinned_ok.load() << " of " << kPinnedClients - << " pinned clients received their initial INFO response. " - "The reactor event loop did not dispatch all connections."; + EXPECT_EQ(pinned_ok.load(), kPinnedClients) << "Only " << pinned_ok.load() << " of " << kPinnedClients + << " pinned clients received their initial INFO response. " + "The reactor event loop did not dispatch all connections."; // All pinned clients are now idle. In reactor mode the workers are free; // the event loop is the only thing monitoring those fds. @@ -303,21 +301,17 @@ TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarv auto t0 = std::chrono::steady_clock::now(); std::string late_resp = RecvMultilineResponse(late, /*timeout_ms=*/500); auto elapsed_ms = - std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) - .count(); + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0).count(); // --- Assertions --- - EXPECT_FALSE(late_resp.empty()) - << "Late client received no response within 500 ms despite reactor mode " - "being active. Starvation regression: reactor is not decoupling " - "worker count from persistent-client count."; + EXPECT_FALSE(late_resp.empty()) << "Late client received no response within 500 ms despite reactor mode " + "being active. Starvation regression: reactor is not decoupling " + "worker count from persistent-client count."; if (!late_resp.empty()) { - EXPECT_EQ(late_resp.substr(0, 7), "OK INFO") - << "Late client response was not OK INFO: " << late_resp; - EXPECT_LT(elapsed_ms, 500) - << "Late client responded (" << late_resp << ") but took " << elapsed_ms - << "ms (> 500ms limit)."; + EXPECT_EQ(late_resp.substr(0, 7), "OK INFO") << "Late client response was not OK INFO: " << late_resp; + EXPECT_LT(elapsed_ms, 500) << "Late client responded (" << late_resp << ") but took " << elapsed_ms + << "ms (> 500ms limit)."; std::cout << "[T1] late_client_latency_ms=" << elapsed_ms << " pinned_ok=" << pinned_ok.load() << " workers=" << kWorkers << std::endl; @@ -325,7 +319,8 @@ TEST_F(ReactorStarvationRegressionTest, ReactorServesPersistentFleetWithoutStarv // Cleanup close(late); - for (int s : pinned) close(s); + for (int s : pinned) + close(s); server->Stop(); } @@ -362,15 +357,16 @@ TEST_F(ReactorStarvationRegressionTest, ReactorHighConcurrencyShowsNoQueueFull) clients.reserve(kClients); for (int i = 0; i < kClients; ++i) { int s = Connect(port); - if (s < 0) break; + if (s < 0) + break; clients.push_back(s); } if (static_cast(clients.size()) < kClients) { - for (int s : clients) close(s); + for (int s : clients) + close(s); server->Stop(); - GTEST_SKIP() << "Could only open " << clients.size() << " of " << kClients - << " client sockets (fd budget?)."; + GTEST_SKIP() << "Could only open " << clients.size() << " of " << kClients << " client sockets (fd budget?)."; } // Snapshot request counter before the burst. @@ -416,13 +412,12 @@ TEST_F(ReactorStarvationRegressionTest, ReactorHighConcurrencyShowsNoQueueFull) uint64_t reqs_after = server->GetStats().GetTotalRequests(); std::cout << "[T2] total_ok=" << total_ok.load() << " total_busy=" << total_busy.load() - << " total_error=" << total_error.load() - << " stat_requests_delta=" << (reqs_after - reqs_before) << std::endl; + << " total_error=" << total_error.load() << " stat_requests_delta=" << (reqs_after - reqs_before) + << std::endl; // --- Assertions --- - EXPECT_EQ(total_busy.load(), 0) - << "Reactor mode sent ERR SERVER_BUSY " << total_busy.load() - << " times. The worker pool should not saturate when the reactor is active."; + EXPECT_EQ(total_busy.load(), 0) << "Reactor mode sent ERR SERVER_BUSY " << total_busy.load() + << " times. The worker pool should not saturate when the reactor is active."; EXPECT_EQ(total_ok.load(), kExpectedTotal) << "Expected " << kExpectedTotal << " OK INFO responses but got " << total_ok.load() @@ -432,7 +427,8 @@ TEST_F(ReactorStarvationRegressionTest, ReactorHighConcurrencyShowsNoQueueFull) << "Server stats counted fewer total requests than expected."; // Cleanup - for (int s : clients) close(s); + for (int s : clients) + close(s); server->Stop(); } diff --git a/tests/integration/server/thread_pool_saturation_test.cpp b/tests/integration/server/thread_pool_saturation_test.cpp index 5b26fbf..e6bbf70 100644 --- a/tests/integration/server/thread_pool_saturation_test.cpp +++ b/tests/integration/server/thread_pool_saturation_test.cpp @@ -160,8 +160,7 @@ class ThreadPoolSaturationTest : public ::testing::Test { cfg.allow_cidrs = {"127.0.0.1/32"}; auto s = std::make_unique(cfg, table_contexts_); auto res = s->Start(); - EXPECT_TRUE(res) << "Failed to start TcpServer: " - << (res ? std::string{} : res.error().to_string()); + EXPECT_TRUE(res) << "Failed to start TcpServer: " << (res ? std::string{} : res.error().to_string()); // Give the accept loop a moment to reach its main loop. std::this_thread::sleep_for(std::chrono::milliseconds(50)); return s; @@ -198,8 +197,7 @@ TEST_F(ThreadPoolSaturationTest, LateClientServedDespitePinnedIdleClientsInDefau ASSERT_GE(s, 0) << "Failed to open pinning client " << i; ASSERT_TRUE(SendLine(s, "INFO")); std::string resp = RecvLine(s); - ASSERT_EQ(resp.substr(0, 7), "OK INFO") - << "Pinning client " << i << " did not receive INFO reply; got: " << resp; + ASSERT_EQ(resp.substr(0, 7), "OK INFO") << "Pinning client " << i << " did not receive INFO reply; got: " << resp; pinned.push_back(s); } @@ -214,18 +212,15 @@ TEST_F(ThreadPoolSaturationTest, LateClientServedDespitePinnedIdleClientsInDefau auto t0 = std::chrono::steady_clock::now(); std::string resp = RecvLine(late, /*timeout_ms=*/1500); auto elapsed_ms = - std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) - .count(); + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0).count(); - EXPECT_FALSE(resp.empty()) - << "Late INFO was NOT served under the reactor I/O model even though " - "the worker pool was small and all persistent clients were idle. " - "The reactor must not couple connection lifetime to worker lifetime."; + EXPECT_FALSE(resp.empty()) << "Late INFO was NOT served under the reactor I/O model even though " + "the worker pool was small and all persistent clients were idle. " + "The reactor must not couple connection lifetime to worker lifetime."; if (!resp.empty()) { EXPECT_EQ(resp.substr(0, 7), "OK INFO"); - EXPECT_LT(elapsed_ms, 500) - << "Late client was served but took " << elapsed_ms - << "ms (>500ms). Reactor latency degraded?"; + EXPECT_LT(elapsed_ms, 500) << "Late client was served but took " << elapsed_ms + << "ms (>500ms). Reactor latency degraded?"; } close(late); @@ -262,8 +257,7 @@ TEST_F(ThreadPoolSaturationTest, DefaultAutoSizeServesManyPersistentClients) { int s = Connect(port); ASSERT_GE(s, 0) << "Failed to open pinning client " << i; ASSERT_TRUE(SendLine(s, "INFO")); - ASSERT_EQ(RecvLine(s).substr(0, 7), "OK INFO") - << "Pinning client " << i << " did not receive INFO reply"; + ASSERT_EQ(RecvLine(s).substr(0, 7), "OK INFO") << "Pinning client " << i << " did not receive INFO reply"; pinned.push_back(s); } std::this_thread::sleep_for(std::chrono::milliseconds(100)); @@ -275,17 +269,14 @@ TEST_F(ThreadPoolSaturationTest, DefaultAutoSizeServesManyPersistentClients) { auto t0 = std::chrono::steady_clock::now(); std::string resp = RecvLine(late, /*timeout_ms=*/1500); auto elapsed_ms = - std::chrono::duration_cast(std::chrono::steady_clock::now() - t0) - .count(); + std::chrono::duration_cast(std::chrono::steady_clock::now() - t0).count(); - EXPECT_FALSE(resp.empty()) - << "Late client starved with " << kPinned - << " pinned persistent clients — has the reactor regressed, or did the " - "thread pool auto-size floor drop below 4?"; + EXPECT_FALSE(resp.empty()) << "Late client starved with " << kPinned + << " pinned persistent clients — has the reactor regressed, or did the " + "thread pool auto-size floor drop below 4?"; if (!resp.empty()) { EXPECT_EQ(resp.substr(0, 7), "OK INFO"); - EXPECT_LT(elapsed_ms, 500) - << "Late client responded but took " << elapsed_ms << "ms"; + EXPECT_LT(elapsed_ms, 500) << "Late client responded but took " << elapsed_ms << "ms"; } close(late); diff --git a/tests/server/connection_acceptor_unix_test.cpp b/tests/server/connection_acceptor_unix_test.cpp index 4042e8f..a2c2461 100644 --- a/tests/server/connection_acceptor_unix_test.cpp +++ b/tests/server/connection_acceptor_unix_test.cpp @@ -81,7 +81,6 @@ TEST_F(ConnectionAcceptorUnixTest, StartAndStopUnixSocket) { // Socket file should be removed after stop EXPECT_FALSE(std::filesystem::exists(socket_path_)); - } TEST_F(ConnectionAcceptorUnixTest, AcceptsUnixConnection) { @@ -160,7 +159,6 @@ TEST_F(ConnectionAcceptorUnixTest, PathTooLongError) { auto result = acceptor.Start(); ASSERT_FALSE(result.has_value()); EXPECT_EQ(result.error().code(), mygram::utils::ErrorCode::kNetworkUnixSocketPathTooLong); - } TEST_F(ConnectionAcceptorUnixTest, SocketFileRemovedOnStop) { @@ -180,7 +178,6 @@ TEST_F(ConnectionAcceptorUnixTest, SocketFileRemovedOnStop) { acceptor.Stop(); EXPECT_FALSE(std::filesystem::exists(socket_path_)); - } TEST_F(ConnectionAcceptorUnixTest, SocketPermissionsAreRestricted) { diff --git a/tests/server/io_reactor_test.cpp b/tests/server/io_reactor_test.cpp index ffcee64..10fa2dd 100644 --- a/tests/server/io_reactor_test.cpp +++ b/tests/server/io_reactor_test.cpp @@ -10,6 +10,7 @@ #include "server/io_reactor.h" #include +#include #include #include @@ -19,8 +20,6 @@ #include #include -#include - #include "mock_event_multiplexer.h" #include "server/reactor/event_multiplexer.h" #include "server/reactor_connection.h" @@ -44,13 +43,12 @@ namespace { struct SocketPair { int fds[2]{-1, -1}; - SocketPair() { - EXPECT_EQ(::socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); - } + SocketPair() { EXPECT_EQ(::socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); } ~SocketPair() { for (int fd : fds) { - if (fd >= 0) ::close(fd); + if (fd >= 0) + ::close(fd); } } @@ -151,9 +149,7 @@ TEST_F(IoReactorTest, StartIsIdempotent) { // --------------------------------------------------------------------------- TEST_F(IoReactorTest, StartReturnsErrorIfFactoryReturnsNull) { - reactor_->SetMultiplexerFactoryForTest([]() { - return std::unique_ptr{nullptr}; - }); + reactor_->SetMultiplexerFactoryForTest([]() { return std::unique_ptr{nullptr}; }); auto result = reactor_->Start(); ASSERT_FALSE(result); @@ -199,8 +195,7 @@ TEST_F(IoReactorTest, RegisterDuplicateFdFails) { // Second connection with the same fd. auto conn2 = std::make_shared(client_fd, reactor_.get(), /*dispatcher=*/nullptr, pool_.get(), - /*stats=*/nullptr, - ReactorConnection::kDefaultMaxWriteQueueBytes); + /*stats=*/nullptr, ReactorConnection::kDefaultMaxWriteQueueBytes); auto r2 = reactor_->Register(conn2); ASSERT_FALSE(r2); EXPECT_EQ(r2.error().code(), ErrorCode::kInternalError); diff --git a/tests/server/reactor/event_multiplexer_test.cpp b/tests/server/reactor/event_multiplexer_test.cpp index d81f80a..6d6008e 100644 --- a/tests/server/reactor/event_multiplexer_test.cpp +++ b/tests/server/reactor/event_multiplexer_test.cpp @@ -9,6 +9,9 @@ * so the test binary compiles on every platform without dead-code warnings. */ +#include "server/reactor/event_multiplexer.h" + +#include #include #include #include @@ -18,10 +21,7 @@ #include #include -#include - #include "mock_event_multiplexer.h" -#include "server/reactor/event_multiplexer.h" #if defined(__linux__) #include "server/reactor/epoll_multiplexer.h" @@ -37,17 +37,16 @@ namespace mygramdb::server::reactor { // Type list // --------------------------------------------------------------------------- -using BackendTypes = ::testing::Types< - MockEventMultiplexer +using BackendTypes = ::testing::Types; + >; // --------------------------------------------------------------------------- // Fixture @@ -86,9 +85,7 @@ class EventMultiplexerTest : public ::testing::Test { void SetNonblocking(int /*fd*/) {} /// Remove fd from the tracked cleanup set (caller will close it manually). - void UntrackFd(int fd) { - open_fds_.erase(std::remove(open_fds_.begin(), open_fds_.end(), fd), open_fds_.end()); - } + void UntrackFd(int fd) { open_fds_.erase(std::remove(open_fds_.begin(), open_fds_.end(), fd), open_fds_.end()); } private: std::vector open_fds_; @@ -103,8 +100,7 @@ TYPED_TEST(EventMultiplexerTest, OpenReturnsAlreadyOpenOnSecondCall) { // SetUp already called Open() once. auto result = this->mux->Open(); ASSERT_FALSE(result.has_value()); - EXPECT_EQ(result.error().code(), - mygram::utils::ErrorCode::kNetworkReactorAlreadyOpen); + EXPECT_EQ(result.error().code(), mygram::utils::ErrorCode::kNetworkReactorAlreadyOpen); } // --------------------------------------------------------------------------- diff --git a/tests/server/reactor/mock_event_multiplexer.cpp b/tests/server/reactor/mock_event_multiplexer.cpp index 124110f..25363a5 100644 --- a/tests/server/reactor/mock_event_multiplexer.cpp +++ b/tests/server/reactor/mock_event_multiplexer.cpp @@ -20,7 +20,9 @@ using mygram::utils::MakeError; using mygram::utils::MakeUnexpected; } // namespace -MockEventMultiplexer::~MockEventMultiplexer() { Shutdown(); } +MockEventMultiplexer::~MockEventMultiplexer() { + Shutdown(); +} // --------------------------------------------------------------------------- // EventMultiplexer interface @@ -29,9 +31,8 @@ MockEventMultiplexer::~MockEventMultiplexer() { Shutdown(); } Expected MockEventMultiplexer::Open() { std::unique_lock lock(mu_); if (opened_) { - return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorAlreadyOpen, - "MockEventMultiplexer::Open called on already-open multiplexer")); + return MakeUnexpected(MakeError(ErrorCode::kNetworkReactorAlreadyOpen, + "MockEventMultiplexer::Open called on already-open multiplexer")); } opened_ = true; return {}; @@ -41,8 +42,7 @@ Expected MockEventMultiplexer::Add(int fd, uint8_t interest) { std::unique_lock lock(mu_); if (interest_.count(fd) != 0U) { return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorRegisterFailed, - "MockEventMultiplexer::Add: fd already registered")); + MakeError(ErrorCode::kNetworkReactorRegisterFailed, "MockEventMultiplexer::Add: fd already registered")); } interest_[fd] = interest; return {}; @@ -53,8 +53,7 @@ Expected MockEventMultiplexer::Modify(int fd, uint8_t interest) { auto it = interest_.find(fd); if (it == interest_.end()) { return MakeUnexpected( - MakeError(ErrorCode::kNetworkReactorModifyFailed, - "MockEventMultiplexer::Modify: unknown fd")); + MakeError(ErrorCode::kNetworkReactorModifyFailed, "MockEventMultiplexer::Modify: unknown fd")); } it->second = interest; return {}; @@ -67,15 +66,12 @@ Expected MockEventMultiplexer::Remove(int fd) { return {}; } -Expected MockEventMultiplexer::Poll(int timeout_ms, - std::vector& out) { +Expected MockEventMultiplexer::Poll(int timeout_ms, std::vector& out) { out.clear(); std::unique_lock lock(mu_); - auto has_events_or_done = [this]() { - return !injected_.empty() || shutdown_; - }; + auto has_events_or_done = [this]() { return !injected_.empty() || shutdown_; }; if (timeout_ms == 0) { // Non-blocking: drain whatever is already queued, then return. @@ -128,12 +124,9 @@ void MockEventMultiplexer::InjectRaw(ReadyEvent ev) { poll_cv_.notify_all(); } -bool MockEventMultiplexer::WaitForPollCalled(int min_calls, - std::chrono::milliseconds timeout) { +bool MockEventMultiplexer::WaitForPollCalled(int min_calls, std::chrono::milliseconds timeout) { std::unique_lock lock(mu_); - return poll_cv_.wait_for(lock, timeout, [this, min_calls]() { - return poll_call_count_ >= min_calls; - }); + return poll_cv_.wait_for(lock, timeout, [this, min_calls]() { return poll_call_count_ >= min_calls; }); } std::vector MockEventMultiplexer::RegisteredFds() const { diff --git a/tests/server/reactor/mock_event_multiplexer.h b/tests/server/reactor/mock_event_multiplexer.h index 24b3bba..7ef8f64 100644 --- a/tests/server/reactor/mock_event_multiplexer.h +++ b/tests/server/reactor/mock_event_multiplexer.h @@ -46,8 +46,7 @@ class MockEventMultiplexer final : public EventMultiplexer { mygram::utils::Expected Add(int fd, uint8_t interest) override; mygram::utils::Expected Modify(int fd, uint8_t interest) override; mygram::utils::Expected Remove(int fd) override; - mygram::utils::Expected Poll(int timeout_ms, - std::vector& out) override; + mygram::utils::Expected Poll(int timeout_ms, std::vector& out) override; const char* Name() const override { return "mock"; } // ------------------------------------------------------------------------- diff --git a/tests/server/reactor_connection_test.cpp b/tests/server/reactor_connection_test.cpp index ab0e536..6f89e08 100644 --- a/tests/server/reactor_connection_test.cpp +++ b/tests/server/reactor_connection_test.cpp @@ -135,8 +135,7 @@ class ReactorConnectionTest : public ::testing::Test { rc_fd_ = fds[1]; SetNonBlocking(rc_fd_); - conn_ = ReactorConnection::Create(rc_fd_, /*reactor=*/nullptr, - harness_.dispatcher.get(), pool_.get()); + conn_ = ReactorConnection::Create(rc_fd_, /*reactor=*/nullptr, harness_.dispatcher.get(), pool_.get()); } void TearDown() override { @@ -238,7 +237,8 @@ TEST_F(ReactorConnectionTest, OnReadableParsesMultipleFramesPerRead) { } char buf[256] = {}; ssize_t n = ::recv(peer_fd_, buf, sizeof(buf) - 1, 0); - if (n <= 0) break; + if (n <= 0) + break; received.append(buf, static_cast(n)); size_t pos = 0; responses = 0; @@ -401,8 +401,7 @@ TEST_F(ReactorConnectionTest, DrainTaskDispatchesAndSends) { ssize_t n = ::recv(peer_fd_, buf, sizeof(buf) - 1, 0); ASSERT_GT(n, 0); std::string response(buf, static_cast(n)); - EXPECT_TRUE(response.find("OK") == 0 || response.find("ERROR") == 0) - << "Unexpected response: " << response; + EXPECT_TRUE(response.find("OK") == 0 || response.find("ERROR") == 0) << "Unexpected response: " << response; } // --------------------------------------------------------------------------- @@ -427,7 +426,8 @@ TEST_F(ReactorConnectionTest, DrainTaskOrderingPreserved) { } char buf[1024] = {}; ssize_t n = ::recv(peer_fd_, buf, sizeof(buf) - 1, 0); - if (n <= 0) break; + if (n <= 0) + break; received.append(buf, static_cast(n)); size_t pos = 0; responses = 0; From 1d0ad99f45ddaaee8e010434bfb570e162022062 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 09:30:40 +0900 Subject: [PATCH 10/13] refactor(server): Tighten reactor hot-path and lifecycle edges MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Four small, independent improvements surfaced during code review of the reactor I/O path: - epoll/kqueue Poll() buffer grows on demand. Both backends now double their scratch buffer up to a fixed 4 KiB-entry cap whenever a Poll() fills the current capacity, so high-concurrency bursts are not fragmented across multiple Poll() rounds waiting for the next tick. Growth is monotonic; the buffer never shrinks. - ReactorConnection::OnWritable is flattened. The empty-queue branch previously wrapped the disarm + half-close teardown in a nested block with a fall-through `return true` that doubled as both the partial- drain and the fully-drained-but-not-closing return. Splitting the partial-drain early-return out removes the head-scratcher without changing semantics. - IoReactor::Register closes a narrow race with Stop(). Stop() sets running_=false, clears connections_, and then blocks on mux_lifecycle_ exclusive. If a concurrent Register interleaved between its initial running_ check and the mux_->Add call, the emplace had already been cleared by Stop() and the caller would receive a spurious success whose fd was never actually tracked. Register now re-checks running_ while still holding mux_lifecycle_ shared and rolls back the Add on the losing side. - kMaxReadBufferBytes contract documented. Clarify in the header that this constant is an OOM safety rail, not per-query size enforcement — that responsibility belongs to the downstream query parser (api.max_query_length). Deliberately decoupled from config so that lowering max_query_length at runtime cannot drop well-formed but large requests that are still in flight on an existing connection. --- src/server/io_reactor.cpp | 15 ++++++++ src/server/reactor/epoll_multiplexer.cpp | 23 ++++++++++-- src/server/reactor/epoll_multiplexer.h | 5 +-- src/server/reactor/kqueue_multiplexer.cpp | 23 ++++++++++-- src/server/reactor/kqueue_multiplexer.h | 7 ++-- src/server/reactor_connection.cpp | 43 +++++++++++++---------- src/server/reactor_connection.h | 12 ++++--- 7 files changed, 95 insertions(+), 33 deletions(-) diff --git a/src/server/io_reactor.cpp b/src/server/io_reactor.cpp index 198b24b..93be0ed 100644 --- a/src/server/io_reactor.cpp +++ b/src/server/io_reactor.cpp @@ -146,6 +146,21 @@ Expected IoReactor::Register(std::shared_ptr con connections_.erase(fd); return MakeUnexpected(r.error()); } + + // Narrow race: Stop() sets running_=false and clears connections_ + // *before* blocking on mux_lifecycle_ exclusive. If that sequence + // interleaved between our initial running_ check and this point, our + // emplace is already gone from the map and the about-to-be-destroyed + // multiplexer will never deliver events for this fd. Detect that window + // by re-checking running_ while we still hold mux_lifecycle_ shared, + // and roll back the Add so the caller sees a clean failure. + if (!running_.load(std::memory_order_acquire)) { + (void)mux_->Remove(fd); + std::unique_lock lock(connections_mutex_); + connections_.erase(fd); // no-op if Stop() already cleared the map + return MakeUnexpected( + MakeError(ErrorCode::kNetworkServerNotStarted, "IoReactor::Register raced with Stop")); + } } return {}; diff --git a/src/server/reactor/epoll_multiplexer.cpp b/src/server/reactor/epoll_multiplexer.cpp index c22339a..d4783f8 100644 --- a/src/server/reactor/epoll_multiplexer.cpp +++ b/src/server/reactor/epoll_multiplexer.cpp @@ -10,6 +10,7 @@ #include #include +#include #include #include #include @@ -28,10 +29,18 @@ using mygram::utils::Expected; using mygram::utils::MakeError; using mygram::utils::MakeUnexpected; -/// Steady-state batch size for `epoll_wait`. Matches the reactor's expected -/// worst-case concurrency per tick; the buffer only ever grows, never shrinks. +/// Starting batch size for `epoll_wait`. The buffer grows on demand up to +/// `kMaxEventsCapacity` whenever a Poll fills it completely — a full batch +/// is a strong signal that the next tick will need more headroom. constexpr std::size_t kInitialEventsCapacity = 64; +/// Upper bound on the `epoll_wait` output buffer. 4096 keeps the scratch +/// allocation bounded at ~48 KiB (`sizeof(epoll_event) * 4096`) while still +/// covering the server's expected peak concurrency of ~2000 connections +/// with comfortable headroom. Beyond this cap, excess ready events roll +/// over to the next Poll — harmless because epoll is level-triggered. +constexpr std::size_t kMaxEventsCapacity = 4096; + /// Build the `errno`-decorated error message suffix used everywhere in this /// translation unit. Captures `errno` by value to avoid TOCTOU between the /// failing syscall and the `strerror` call. @@ -168,6 +177,16 @@ Expected EpollMultiplexer::Poll(int timeout_ms, std::vector(i)]; out.push_back(ReadyEvent{ev.data.fd, EpollEventsToReady(ev.events)}); } + + // Dynamic grow: if this Poll() filled the scratch buffer, chances are we + // are running behind and the next tick will need more slots. Double the + // capacity up to `kMaxEventsCapacity` so we stop fragmenting high-concurrency + // bursts across multiple Poll() rounds. Growth is one-shot and monotonic; + // the buffer never shrinks back down. + if (static_cast(n) == events_.size() && events_.size() < kMaxEventsCapacity) { + const std::size_t new_size = std::min(events_.size() * 2, kMaxEventsCapacity); + events_.resize(new_size); + } return {}; } diff --git a/src/server/reactor/epoll_multiplexer.h b/src/server/reactor/epoll_multiplexer.h index 5df319c..92340f2 100644 --- a/src/server/reactor/epoll_multiplexer.h +++ b/src/server/reactor/epoll_multiplexer.h @@ -52,8 +52,9 @@ class EpollMultiplexer : public EventMultiplexer { int epoll_fd_{-1}; /// Reusable scratch buffer for `epoll_wait`. Sized once in the constructor - /// so the hot path never allocates. Grows only if callers supply a bigger - /// output vector (currently they do not). + /// and doubled on demand (up to a fixed cap) whenever a Poll() fills it + /// completely, so sustained bursts do not fragment across multiple Poll + /// rounds. Never shrinks back down. std::vector events_; }; diff --git a/src/server/reactor/kqueue_multiplexer.cpp b/src/server/reactor/kqueue_multiplexer.cpp index 8dea336..b74524c 100644 --- a/src/server/reactor/kqueue_multiplexer.cpp +++ b/src/server/reactor/kqueue_multiplexer.cpp @@ -12,6 +12,7 @@ #include #include +#include #include #include #include @@ -31,11 +32,18 @@ using mygram::utils::Expected; using mygram::utils::MakeError; using mygram::utils::MakeUnexpected; -/// Default size of the `kevent()` output buffer. Sized to match the reactor's -/// expected worst-case concurrency per tick; anything beyond this cap simply -/// rolls over to the next `Poll()` call because kqueue is level-triggered. +/// Starting size of the `kevent()` output buffer. Grows on demand up to +/// `kMaxEventBufferSize` whenever a Poll fills the buffer completely. constexpr std::size_t kDefaultEventBufferSize = 64; +/// Upper bound on the `kevent()` output buffer. 4096 keeps the scratch +/// allocation bounded at ~128 KiB (`sizeof(struct kevent) * 4096`) while +/// still covering the server's expected peak concurrency of ~2000 +/// connections with comfortable headroom. kqueue is level-triggered, so +/// excess ready events beyond the cap are harmlessly re-reported on the +/// next Poll. +constexpr std::size_t kMaxEventBufferSize = 4096; + /// Number of milliseconds in a second (kept as a named constant to keep the /// timespec conversion below readable under clang-tidy's magic-number rule). constexpr long kNanosPerMilli = 1'000'000L; @@ -307,6 +315,15 @@ Expected KqueueMultiplexer::Poll(int timeout_ms, std::vector(n) == events_.size() && events_.size() < kMaxEventBufferSize) { + const std::size_t new_size = std::min(events_.size() * 2, kMaxEventBufferSize); + events_.resize(new_size); + } return {}; } diff --git a/src/server/reactor/kqueue_multiplexer.h b/src/server/reactor/kqueue_multiplexer.h index 9db02c5..cd7ed47 100644 --- a/src/server/reactor/kqueue_multiplexer.h +++ b/src/server/reactor/kqueue_multiplexer.h @@ -103,9 +103,10 @@ class KqueueMultiplexer final : public EventMultiplexer { int kqueue_fd_ = -1; - /// Reusable output buffer for `kevent()`. Sized at construction so the - /// steady-state event loop never allocates. Touched only by the event-loop - /// thread via `Poll()`; no locking. + /// Reusable output buffer for `kevent()`. Sized at construction and + /// doubled on demand (up to a fixed cap) whenever a Poll() fills it + /// completely, so sustained bursts do not fragment across multiple Poll + /// rounds. Touched only by the event-loop thread via `Poll()`; no locking. std::vector events_; /// Mutex protecting `interest_`. IoReactor now allows concurrent Poll (on diff --git a/src/server/reactor_connection.cpp b/src/server/reactor_connection.cpp index f84a652..cb7c6a7 100644 --- a/src/server/reactor_connection.cpp +++ b/src/server/reactor_connection.cpp @@ -172,28 +172,33 @@ bool ReactorConnection::OnWritable() { return false; } - if (write_queue_.empty()) { - // Fully drained: disarm kWritable so the event loop stops spinning on - // this fd. If we had never actually armed (edge case — OnWritable fired - // spuriously), skip the disarm call. - if (write_armed_ && reactor_ != nullptr) { - (void)reactor_->DisarmWrite(fd_); - write_armed_ = false; - } - if (closing_.load(std::memory_order_acquire)) { + if (!write_queue_.empty()) { + // Partial drain: leave the queue armed, fire again on next writable event. + return true; + } + + // Fully drained: disarm kWritable so the event loop stops spinning on + // this fd. If we had never actually armed (edge case — OnWritable fired + // spuriously), skip the disarm call. + if (write_armed_ && reactor_ != nullptr) { + (void)reactor_->DisarmWrite(fd_); + write_armed_ = false; + } + + if (closing_.load(std::memory_order_acquire)) { + return false; + } + + // Peer already half-closed and the drain task has no more work in flight: + // we just flushed the last response, so unregister now. + if (read_eof_.load(std::memory_order_acquire) && !drain_scheduled_.load(std::memory_order_acquire)) { + std::lock_guard frames_lock(frame_mutex_); + if (pending_frames_.empty()) { + closing_.store(true, std::memory_order_release); return false; } - // Peer already half-closed and the drain task has no more work in - // flight: we just flushed the last response, so unregister now. - if (read_eof_.load(std::memory_order_acquire) && !drain_scheduled_.load(std::memory_order_acquire)) { - std::lock_guard frames_lock(frame_mutex_); - if (pending_frames_.empty()) { - closing_.store(true, std::memory_order_release); - return false; - } - } } - // Partial drain: leave the queue armed, fire again on next writable event. + return true; } diff --git a/src/server/reactor_connection.h b/src/server/reactor_connection.h index 7783de5..f3943e5 100644 --- a/src/server/reactor_connection.h +++ b/src/server/reactor_connection.h @@ -83,10 +83,14 @@ class ReactorConnection : public std::enable_shared_from_this /// Default read buffer reservation. Grows on demand up to kMaxReadBufferBytes. static constexpr size_t kDefaultReadBufferBytes = 4096; - /// Hard cap on the read accumulation buffer. A single frame larger than - /// this is rejected (peer is either misbehaving or under attack). 1 MiB is - /// comfortably above the configured MygramDB query length limit (~64 KiB) - /// while still providing OOM protection. + /// Hard cap on the read accumulation buffer. This is an OOM safety rail + /// only — per-query size enforcement (`api.max_query_length`) is the + /// responsibility of the downstream query parser, which rejects oversized + /// requests with a structured error. 1 MiB is comfortably above the + /// default `max_query_length` (~64 KiB) and is deliberately decoupled + /// from config so that lowering `max_query_length` at runtime cannot make + /// the reactor drop well-formed but large requests that are still in + /// flight on an existing connection. static constexpr size_t kMaxReadBufferBytes = 1 * 1024 * 1024; // 1 MiB /// Hard upper bound on unsent response bytes; once exceeded the reactor From 7aea9d9b60a21365ee4a9b6866d3abc784f4ba3a Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 09:34:26 +0900 Subject: [PATCH 11/13] style: Reflow a long return MakeUnexpected line in IoReactor::Register The Register race-guard return statement was manually wrapped at column 80 but fits on a single line under the project's 120-column limit. clang-format --dry-run --Werror (= make format-check, which CI runs) was flagging the mismatch. No semantic change. --- src/server/io_reactor.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/server/io_reactor.cpp b/src/server/io_reactor.cpp index 93be0ed..4fc39ac 100644 --- a/src/server/io_reactor.cpp +++ b/src/server/io_reactor.cpp @@ -158,8 +158,7 @@ Expected IoReactor::Register(std::shared_ptr con (void)mux_->Remove(fd); std::unique_lock lock(connections_mutex_); connections_.erase(fd); // no-op if Stop() already cleared the map - return MakeUnexpected( - MakeError(ErrorCode::kNetworkServerNotStarted, "IoReactor::Register raced with Stop")); + return MakeUnexpected(MakeError(ErrorCode::kNetworkServerNotStarted, "IoReactor::Register raced with Stop")); } } From ceca9916d01c7290be6ae30cef7289a88e980016 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 09:47:52 +0900 Subject: [PATCH 12/13] docs(release): prepare release v1.5.3 Release-prep documentation update for v1.5.3 (reactor I/O model rollout plus three hardening fixes): - CHANGELOG.md: add [1.5.3] - 2026-04-12 section covering the reactor I/O model (epoll/kqueue), slow-reader backpressure, four bug fixes (half-close drain regression, rate limiting silently disabled, UDS acceptor broken, Grafana PromQL), and the removal of the blocking I/O path; fix previously missing/stale [Unreleased] and [1.5.2] compare links at the bottom of the file - docs/releases/v1.5.3.md: new detailed release notes (new file) - docs/releases/README.md: promote v1.5.3 to Latest release entry --- CHANGELOG.md | 33 +++++- docs/releases/README.md | 3 +- docs/releases/v1.5.3.md | 248 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 282 insertions(+), 2 deletions(-) create mode 100644 docs/releases/v1.5.3.md diff --git a/CHANGELOG.md b/CHANGELOG.md index f3b6d69..6109bb3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +## [1.5.3] - 2026-04-12 + +### Added + +- **Reactor I/O model (epoll/kqueue)** — New event-driven TCP path replaces the blocking one-thread-per-connection loop; a single event-loop thread plus a bounded worker pool serves thousands of persistent connections +- **Per-connection slow-reader backpressure** — `api.tcp.max_write_queue_bytes` (default 16 MiB) force-closes clients whose enqueued response bytes exceed the cap +- **Reactor error codes** — `kNetworkReactorUnsupported`/`PollFailed`/`RegisterFailed`/`ModifyFailed`/`RemoveFailed`/`QueueFull`/`AlreadyOpen` (6016–6023) + +### Fixed + +- **TCP half-close drain regression** — `shutdown(SHUT_WR)` + `recv()` clients now receive their response; `kHangup` events no longer short-circuit to `OnError`, and `read_eof_` is tracked separately from `closing_` so the drain task can enqueue the response +- **Rate limiting silently disabled under reactor** — `api.rate_limiting.enable = true` is now honored on every accepted connection; the reactor handler calls `getpeername()` + `AllowRequest()` before `Register()` and returns `SERVER_BUSY` on rejection +- **Unix domain socket acceptor could not start** — Removed the dead secondary `unix_acceptor_` that collided with the primary acceptor's own UDS bind; UDS now flows end-to-end through the primary acceptor's reactor handler +- **Grafana memory usage PromQL** — Use `ignoring(type)` on the division so `mygramdb_memory_used_bytes{type="total"}` matches the denominator label set + +### Changed + +- **Blocking I/O path removed entirely** — `ConnectionIOHandler`, `TcpServer::HandleConnection`, the `api.tcp.io_model` feature flag, `connection_contexts_` map, `ConnectionAcceptor::SetConnectionHandler`, and the `BlockingMode` ctest entries are all deleted +- **Thread-pool auto-size floor reverted** — Dropped the emergency `hw*4`/64-worker mitigation for blocking-mode starvation; restored `max(hw*2, 4)` +- **Reactor hot-path polish** — epoll/kqueue poll buffers grow on demand up to 4 KiB entries; `Register`/`Stop` race closed by re-checking `running_` under `mux_lifecycle_` shared; `OnWritable` empty-queue teardown flattened + +### Testing + +- New unit tests: `event_multiplexer_test`, `io_reactor_test`, `reactor_connection_test` +- New integration tests: `reactor_integration_test` (write backpressure, many-idle-connections, half-close, rate limit, UDS, max query length), `reactor_starvation_regression_test`, `thread_pool_saturation_test` (migrated, assertion inverted for reactor default) +- e2e `test_half_close_write` now passes (previously failing on reactor path) + +**Detailed Release Notes**: [docs/releases/v1.5.3.md](docs/releases/v1.5.3.md) + ## [1.5.2] - 2026-04-09 ### Added @@ -444,7 +473,9 @@ Initial release with core search engine functionality and MySQL replication supp --- -[Unreleased]: https://github.com/libraz/mygram-db/compare/v1.5.1...HEAD +[Unreleased]: https://github.com/libraz/mygram-db/compare/v1.5.3...HEAD +[1.5.3]: https://github.com/libraz/mygram-db/compare/v1.5.2...v1.5.3 +[1.5.2]: https://github.com/libraz/mygram-db/compare/v1.5.1...v1.5.2 [1.5.1]: https://github.com/libraz/mygram-db/compare/v1.5.0...v1.5.1 [1.5.0]: https://github.com/libraz/mygram-db/compare/v1.4.0...v1.5.0 [1.4.0]: https://github.com/libraz/mygram-db/compare/v1.3.9...v1.4.0 diff --git a/docs/releases/README.md b/docs/releases/README.md index 3bfa24d..6dd7ce2 100644 --- a/docs/releases/README.md +++ b/docs/releases/README.md @@ -4,7 +4,8 @@ This directory contains detailed release notes for each version of MygramDB. ## Available Versions -- [v1.5.2](v1.5.2.md) - Latest release (2026-04-09) - MySQL 9.x compatibility, VECTOR type support, Auth fix +- [v1.5.3](v1.5.3.md) - Latest release (2026-04-12) - Reactor I/O Model (epoll/kqueue), Half-close Fix, Rate Limit & UDS Hardening +- [v1.5.2](v1.5.2.md) - 2026-04-09 - MySQL 9.x compatibility, VECTOR type support, Auth fix - [v1.5.1](v1.5.1.md) - 2026-04-01 - Multi-distro packaging (EL10, Ubuntu DEB), Package verification, Build fixes - [v1.5.0](v1.5.0.md) - 2026-03-23 - verify_text Post-Filter, Docker Benchmark, Namespace Cleanup - [v1.4.0](v1.4.0.md) - 2026-03-16 - Unix Socket, Prometheus Metrics, Benchmark Suite & Bug Fixes diff --git a/docs/releases/v1.5.3.md b/docs/releases/v1.5.3.md new file mode 100644 index 0000000..ac29390 --- /dev/null +++ b/docs/releases/v1.5.3.md @@ -0,0 +1,248 @@ +# MygramDB v1.5.3 Release Notes + +**Release Date:** 2026-04-12 +**Type:** Feature / Bug Fix / Refactor +**Previous Version:** v1.5.2 + +--- + +## Overview + +Version 1.5.3 replaces the legacy blocking one-thread-per-connection TCP path with an event-driven **reactor I/O model** built on `epoll` (Linux) and `kqueue` (macOS/BSD). The reactor is now the only supported TCP path; the blocking code has been removed entirely. A small server can now serve thousands of idle persistent connections with a single event-loop thread plus a bounded worker pool, eliminating the one-thread-per-connection starvation failure mode. + +The release also ships the hardening fixes that landed while the reactor was being rolled out: a half-close drain regression, a silently disabled rate limiter, and a broken Unix-domain-socket path are all fixed. A Grafana dashboard PromQL bug is fixed as well. + +**Highlights:** + +- **Reactor I/O model is the default (and only) TCP path** — `epoll`/`kqueue`-backed event loop with a bounded, per-connection non-blocking write queue +- **Blocking I/O path removed entirely** — `ConnectionIOHandler` and the `api.tcp.io_model` feature flag are gone; configuration rejects the field +- **Half-close responses delivered correctly** — `shutdown(SHUT_WR)` + `recv()` clients now receive their response instead of being torn down on the hangup event +- **Rate limiting enforced under reactor** — `api.rate_limiting.enable = true` is now honored on every accepted connection; regression from the reactor flip +- **Unix domain socket restored** — UDS listener works end-to-end under the reactor default (previously failed with a spurious "already listening" error) +- **Slow-reader backpressure** — new `api.tcp.max_write_queue_bytes` (default 16 MiB) force-closes clients whose write queue exceeds the cap instead of stalling the event loop +- **Grafana memory usage panel fix** — PromQL label-set mismatch corrected so the memory usage percentage renders again + +--- + +## New Features + +### 1. Reactor I/O Model (epoll / kqueue) + +**Type:** Feature +**Commit:** `c66e8b1` + +The new reactor replaces the blocking `recv()`/`send()` loop that ran one thread per connection. Readiness events come from `epoll` on Linux and `kqueue` on macOS/BSD behind a platform-agnostic `EventMultiplexer` interface. A single event-loop thread owns the multiplexer; accepted fds are handed off inline from `ConnectionAcceptor` to `IoReactor::Register`. + +Per-connection state lives in `ReactorConnection`, which implements a drain-task pattern: when the socket becomes readable the reactor schedules work on the existing `ThreadPool`, and the "clear-then-recheck" reschedule idiom ensures bytes that arrive while the drain task is running are picked up without dropping readable-edge notifications. Writes use a non-blocking queue (`std::deque` plus a `front_offset` for partial head sends) with an inline fast path and an `EPOLLOUT` fallback. + +**New components:** + +- `src/server/reactor/event_multiplexer.{h,cpp}` — Platform-agnostic readiness interface +- `src/server/reactor/epoll_multiplexer.{h,cpp}` — Level-triggered epoll backend (Linux) +- `src/server/reactor/kqueue_multiplexer.{h,cpp}` — kqueue backend (macOS/BSD) +- `src/server/io_reactor.{h,cpp}` — Single-threaded event loop, connection registration, arm/disarm-write, graceful shutdown +- `src/server/reactor_connection.{h,cpp}` — Per-connection drain-task state, bounded write queue, slow-reader cap + +**Integration:** + +- `src/server/tcp_server.cpp` — Always creates and starts `IoReactor` on `Start()`; reactor init failure now propagates instead of silently falling back +- `src/server/connection_acceptor.cpp` — Routes accepted fds through the installed `ReactorHandler` on the accept thread (no thread-pool submit) +- `src/server/server_lifecycle_manager.cpp` — Drains the reactor ahead of the thread pool during shutdown + +**Thread-pool auto-size revert:** With the reactor default, the emergency `hw*4`/64-worker floor added to mitigate blocking-mode starvation is no longer needed. `src/server/thread_pool.cpp` restores the original `max(hw*2, 4)` formula. + +**New error codes** (`src/utils/error.h`, 6016–6023): `kNetworkReactorUnsupported`, `kNetworkReactorPollFailed`, `kNetworkReactorRegisterFailed`, `kNetworkReactorModifyFailed`, `kNetworkReactorRemoveFailed`, `kNetworkReactorQueueFull`, `kNetworkReactorAlreadyOpen`. + +### 2. Per-Connection Slow-Reader Backpressure + +**Type:** Feature +**Commit:** `c66e8b1` + +Added `api.tcp.max_write_queue_bytes` (default: 16 MiB, immutable at runtime). When a client's enqueued-but-not-yet-sent response bytes exceed the cap, the reactor logs `reactor_write_queue_overflow` and force-closes the connection. This prevents a single slow or stalled reader from consuming unbounded server memory while the event loop tries to drain it. + +**Files:** + +- `src/config/config.{h,cpp}`, `config-schema.json`, `config_help.cpp` +- `src/server/server_types.h` — New `max_write_queue_bytes` field on `ServerConfig` + +--- + +## Bug Fixes + +### 1. TCP Half-Close Drain Regression + +**Type:** Bug Fix +**Severity:** High — Clients using `shutdown(SHUT_WR)` + `recv()` never received their response +**Commit:** `ed04e24` + +**Problem:** A client pattern of `send(...); shutdown(SHUT_WR); recv()` was losing its response under the reactor path. The blocking `ConnectionIOHandler` used to handle this fine by reading until EOF and then flushing. Regression uncovered by `e2e/tests/load/test_connection_stress.py::test_half_close_write`. + +Two bugs compounded: + +1. `IoReactor::DispatchEvent` treated `reactor::event::kHangup` (`EV_EOF` on kqueue, `EPOLLRDHUP` on epoll) as fatal alongside `kError`, short-circuiting to `OnError()` without ever calling `OnReadable()`. The half-close raises the hangup flag on the *same* readable event as the payload bytes, so the reactor tore the connection down before reading the request. + +2. `ReactorConnection::OnReadable`, on `recv() == 0`, set the `closing_` flag. `EnqueueResponse` refuses writes when `closing_` is set, so even if the drain task had run, the response would have been dropped. + +**Solution:** + +- `kHangup` now falls through to `OnReadable()`, which already drains to EOF. `kError` remains fatal. +- Introduced a distinct `read_eof_` atomic for "peer has stopped writing" semantics. `OnReadable` sets `read_eof_` (not `closing_`) on orderly EOF and still extracts buffered frames into the drain queue. The drain task runs to completion, `EnqueueResponse` accepts the response, the write queue drains, and only then does the drain task set `closing_` and `Unregister`. +- Subsequent `OnReadable` calls while `read_eof_` is set skip further `recv()` syscalls. + +**Files:** + +- `src/server/io_reactor.cpp` +- `src/server/reactor_connection.{h,cpp}` + +**Regression test:** `tests/integration/server/reactor_integration_test.cpp::HalfCloseStillReceivesResponse` — mirrors the e2e case: send `INFO`, `shutdown(SHUT_WR)`, read response bytes with raw `recv()`. Fails on the pre-fix code. + +### 2. Rate Limiting Silently Disabled Under Reactor + +**Type:** Bug Fix +**Severity:** High — `api.rate_limiting.enable = true` was unenforced on every accepted connection +**Commit:** `6717a9d` + +**Problem:** The blocking `ConnectionIOHandler` path enforced `api.rate_limiting` via `TcpServer::HandleConnection` (`getpeername` + `AllowRequest` + close-on-reject). The reactor path had no equivalent — zero references to `rate_limit` in `reactor_connection.cpp` / `io_reactor.cpp`. Any user with rate limiting enabled got unmetered traffic the moment the default `io_model` flipped to reactor. + +**Solution:** The `reactor_handler` lambda in `TcpServer::Start` now captures a `RateLimiter*` (null if rate limiting is disabled or if the acceptor is a UDS acceptor), calls `getpeername()` on each accepted fd, extracts the peer IPv4 address, and calls `AllowRequest()` before `Register()`. On rejection it returns `false` so `ConnectionAcceptor::AcceptLoop` emits `SERVER_BUSY` and closes the fd, matching the existing accept-side backpressure path. + +**UDS bypass:** The blocking path used the `"unix-local"` sentinel to skip rate limiting for UDS clients. The reactor path computes the bypass once at `Start()` time (`rate_limiter_ptr = null` whenever the acceptor is UDS) rather than on every accept. + +**File:** `src/server/tcp_server.cpp` + +**Regression test:** `RateLimitEnforcedInReactorMode` — capacity=2, refill=0; third connection must be closed without a response. + +### 3. Unix Domain Socket Acceptor Could Not Start + +**Type:** Bug Fix +**Severity:** High — Every `TcpServer::Start` with `unix_socket_path` set failed deterministically +**Commit:** `6717a9d` + +**Problem:** `TcpServer::Start` unconditionally created a *secondary* `unix_acceptor_` whenever `config_.unix_socket_path` was non-empty. But the primary `acceptor_` constructed in `ServerLifecycleManager::InitAcceptor` received the same `ServerConfig`, and `ConnectionAcceptor::Start` checks `unix_socket_path.empty()` before the TCP branch — so the primary was *already* in UDS mode and had already bound the path. The secondary hit its own stale-socket probe on the same path and failed with "Another server is already listening on: …". No integration test exercised `unix_socket_path` end-to-end, so this never surfaced until one was added. + +**Solution:** Deleted the dead `unix_acceptor_` code path entirely (`tcp_server.h` field, `Start()` setup block, `Stop()` teardown, `IsRunning()` check). The primary acceptor already routes UDS client fds through the `reactor_handler` installed on it, so UDS flows through the reactor for free. + +**File:** `src/server/tcp_server.{h,cpp}` + +**Regression test:** `UnixSocketServedUnderReactorDefault` — `AF_UNIX` client connects, sends `INFO`, expects `"OK INFO"`. + +### 4. Grafana Dashboard Memory Usage PromQL + +**Type:** Bug Fix +**Severity:** Medium — Memory usage percentage panel rendered as "No data" +**Commit:** `10b32cb` + +**Problem:** The memory usage percentage panel divided `mygramdb_memory_used_bytes` by `mygramdb_memory_system_total_bytes` without reconciling the differing label sets: the numerator carries a `type="total"` label that the denominator lacks, so the Prometheus query engine returned no samples. + +**Solution:** Use `ignoring(type)` on the division so the two vectors match on the remaining labels. + +**File:** Grafana dashboard JSON + +--- + +## Refactoring + +### 1. Remove Blocking I/O Path Entirely + +**Commit:** `8520fcb` + +With the reactor default shipping rate limiting and UDS routing fixes, nothing of value remained in the legacy blocking path. The feature flag, the handler, and the per-connection context map are all deleted. + +**Removed:** + +- `src/server/connection_io_handler.{h,cpp}` — Deleted; no remaining caller +- `TcpServer::HandleConnection`, `connection_contexts_` map and its mutex (per-connection state now lives in `ReactorConnection`) +- The `reactor_active` fallback branch in `TcpServer::Start` and the `SetConnectionHandler` else-arm +- `ServerConfig::io_model`, the `api.tcp.io_model` config field, its schema enum, help entry, and runtime variable getter +- `ConnectionHandler` typedef, `SetConnectionHandler`, and the `connection_handler_` field on `ConnectionAcceptor` +- `tests/server/connection_io_handler_test.cpp` (8 tests), `test_io_model_override.h`, and all `ApplyIoModelOverride()` call sites +- Three `.BlockingMode` ctest entries (`multi_table`, `end_to_end`, `verify_text`) +- Two blocking-mode thread-pool saturation tests (`LargerThreadPoolRemovesStarvationInBlockingMode`, `QueueOverflowTriggersBusyResponseInBlockingMode`) +- The T3 blocking-mode starvation negative-control test + +`kNetworkReactorUnsupported` (6016) is preserved — it now propagates from `TcpServer::Start` instead of being caught and fallback-handled. + +### 2. Drop Unused `ConnectionAcceptor::thread_pool_` + +**Commit:** `5db19e3` + +With the thread-pool-submit branch gone from `ConnectionAcceptor::AcceptLoop`, the `thread_pool_` member is unreferenced. Accepted fds are handed off inline to the `ReactorHandler` on the accept thread. + +- `ConnectionAcceptor` constructor is now `explicit ConnectionAcceptor(ServerConfig)` +- `ServerLifecycleManager::InitAcceptor` no longer takes a `thread_pool` argument +- 6 test fixtures in `connection_acceptor_unix_test.cpp` drop the local `ThreadPool pool` declarations + +### 3. Reactor Hot-Path and Lifecycle Tightening + +**Commit:** `1d0ad99` + +Four small, independent improvements surfaced during reactor code review: + +- **epoll/kqueue `Poll()` buffer grows on demand.** Both backends double their scratch buffer up to a 4 KiB-entry cap when a `Poll()` fills capacity, so high-concurrency bursts are not fragmented across multiple `Poll()` rounds. Growth is monotonic; the buffer never shrinks. +- **`ReactorConnection::OnWritable` flattened.** The empty-queue branch previously wrapped the disarm + half-close teardown in a nested block with a fall-through `return true` that doubled as both the partial-drain and the fully-drained-but-not-closing return. Splitting the partial-drain early-return out removes the head-scratcher without changing semantics. +- **`IoReactor::Register` closes a narrow race with `Stop()`.** If a concurrent `Register` interleaved between its initial `running_` check and the `mux_->Add` call, the emplace had already been cleared by `Stop()` and the caller would receive a spurious success whose fd was never tracked. `Register` now re-checks `running_` while still holding `mux_lifecycle_` shared and rolls back the `Add` on the losing side. +- **`kMaxReadBufferBytes` contract documented.** Clarify in the header that this constant is an OOM safety rail, not per-query size enforcement — that responsibility belongs to the downstream query parser (`api.max_query_length`). Deliberately decoupled from config so that lowering `max_query_length` at runtime cannot drop well-formed but large requests still in flight on an existing connection. + +--- + +## Testing + +### New Unit Tests + +- `tests/server/reactor/event_multiplexer_test.cpp` — `MockEventMultiplexer` covers register/modify/remove/poll semantics against a deterministic fake +- `tests/server/io_reactor_test.cpp` — Start/stop lifecycle, register-after-stop rejection, `ArmWrite` before `Register` error, close-callback exactly-once +- `tests/server/reactor_connection_test.cpp` — Drain-task "clear-then-recheck" reschedule, `EnqueueResponse` cap enforcement, partial-send `front_offset` tracking, `write_armed` transitions, close during in-flight drain + +### New Integration Tests + +- `tests/integration/server/reactor_integration_test.cpp` — Happy-path (SEARCH/INFO), many concurrent clients, and: + - `WriteBackpressureHandledGracefully` — 64 KiB cap + slow reader (`SO_RCVBUF=4096`) must log `reactor_write_queue_overflow` and force-close without stalling four parallel fast clients + - `ManyIdleConnectionsDoNotBlockActiveClient` — `kWorkers=8` + thousands of idle persistent clients must still serve a new active client in under 500 ms + - `HalfCloseStillReceivesResponse`, `RateLimitEnforcedInReactorMode`, `MaxQueryLengthEnforcedInReactorMode`, `UnixSocketServedUnderReactorDefault` (regression guards) +- `tests/integration/server/reactor_starvation_regression_test.cpp` — `LateClientServedUnderLoad`, `NoBusyErrorUnderSustainedLoad` +- `tests/integration/server/thread_pool_saturation_test.cpp` — Migrated into its own binary with the assertion inverted (`LateClientServedDespitePinnedIdleClientsInDefaultMode`) now that the reactor is the default + +Test helpers use `poll()` instead of `select()` so tests work past the `FD_SETSIZE=1024` cliff on macOS when opening many fds. + +### Test Suite Totals + +| Metric | Before | After | Delta | +|---|---|---|---| +| Fast suite (`ctest -LE "LOAD\|SLOW"`) | 2164 | 2165 | +1 regression guard | +| e2e suite | 1 failed (`test_half_close_write`) | 195 passed, 4 skipped, 0 failed | Fixed | + +--- + +## Documentation Updates + +- `docs/en/architecture.md` / `docs/ja/architecture.md` — Replaced the `ConnectionIOHandler` subsection with new `IoReactor` and `ReactorConnection` subsections. Added an "IoReactor Event Loop Thread (single)" node to the thread model diagram. Updated `ServerLifecycleManager` initialization order: acceptor no longer depends on `ThreadPool`; `IoReactor` is now step 8, created in `TcpServer::Start()` and depending on `ThreadPool` + `RequestDispatcher`. Rewrote "Between Acceptor and Handlers" request flow as `ConnectionAcceptor → IoReactor::Register → ReactorConnection → drain task on ThreadPool → RequestDispatcher → handler → EnqueueResponse() with EPOLLOUT fallback`. +- `e2e/tests/load/test_load.py` — Module docstring updated to describe `ReactorConnection`'s drain task framing `\r\n`-delimited requests (previously claimed pipelined commands were processed by `ConnectionIOHandler` "in a while loop"). +- Historical release notes (`docs/releases/v1.1.0.md`, `v1.3.5.md`) reference the old class names — left intact since they document past releases. + +--- + +## Migration Guide + +### From v1.5.2 + +**No breaking changes to wire protocol or on-disk formats.** Direct upgrade is safe. + +**Configuration cleanup required** if you explicitly set `api.tcp.io_model`: + +- `api.tcp.io_model` has been **removed** from the config schema +- If your config file contains this field, remove it — leaving it will cause schema validation to reject the config +- The reactor is now the only TCP path + +**Optional new setting:** + +- `api.tcp.max_write_queue_bytes` — Per-connection write queue cap (default: `16777216` = 16 MiB). Clients whose enqueued response bytes exceed this cap are force-closed with a `reactor_write_queue_overflow` log entry. Tune downward to reduce memory exposure to slow readers; tune upward only if you see legitimate clients being closed. Immutable at runtime. + +**Platform requirements:** + +- Linux: requires `epoll` (kernel 2.6+ — already required) +- macOS/BSD: requires `kqueue` (always present) +- Other POSIX platforms will fail `TcpServer::Start` with `kNetworkReactorUnsupported` (6016). There is no blocking fallback. + +**Rate limiting users:** If you have `api.rate_limiting.enable = true` in your config and were running v1.5.2 with the reactor (where rate limiting was silently disabled), you will see enforcement resume in v1.5.3. Review your `capacity` / `refill_rate` settings against current traffic to avoid unexpected `SERVER_BUSY` responses. + +**Unix-domain-socket users:** UDS now works end-to-end under the reactor. If you had worked around the v1.5.2 breakage by disabling `unix_socket_path`, you can re-enable it. From c99cc38ab8b3155852b89c9b8ae4c051e1e85d82 Mon Sep 17 00:00:00 2001 From: libraz Date: Sun, 12 Apr 2026 10:00:11 +0900 Subject: [PATCH 13/13] test(server): Loosen reactor backpressure deadline for coverage runs The WriteBackpressureHandledGracefully test uses a deadline to detect FIN after the reactor force-closes the slow-reader fd on write-queue overflow (64 KiB cap). The original 5s deadline was too tight under coverage instrumentation, which slows request dispatch by 3-10x and in turn delays both tripping the cap and the close-propagation path after Unregister. The Linux Build, Test and Coverage job was the only CI job to fail on PR #6 (develop->main, v1.5.3); the non-coverage Linux Build and Test job passed. Logs confirmed reactor_write_queue_overflow fired correctly but the test gave up at exactly the 5s deadline before FIN arrived. - Bump deadline from 5s to 15s - Update EXPECT_TRUE assertion message to reflect the new deadline - Add comment explaining the generous deadline and coverage context No change to pass-path behavior; a passing run finishes in well under a second on unninstrumented builds. --- tests/integration/server/reactor_integration_test.cpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/tests/integration/server/reactor_integration_test.cpp b/tests/integration/server/reactor_integration_test.cpp index eef67ec..fd3c0a0 100644 --- a/tests/integration/server/reactor_integration_test.cpp +++ b/tests/integration/server/reactor_integration_test.cpp @@ -912,7 +912,13 @@ TEST_F(ReactorIntegrationTest, WriteBackpressureHandledGracefully) { // reactor's perspective, but the client still has to consume any bytes // that were sent BEFORE the cap fired — so we drain aggressively with a // large buffer so the FIN shows up within the deadline. - auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5); + // + // The deadline is generous (15s) because under coverage instrumentation + // request dispatch is 3–10x slower, which in turn slows both the + // dispatch loop that eventually trips the 64 KiB cap and the + // close-propagation path after Unregister. A passing run normally + // finishes in well under a second. + auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(15); bool slow_closed = false; while (std::chrono::steady_clock::now() < deadline) { std::array drain{}; @@ -935,7 +941,7 @@ TEST_F(ReactorIntegrationTest, WriteBackpressureHandledGracefully) { // until the buffer is empty and FIN shows up. } - EXPECT_TRUE(slow_closed) << "Slow reader was never force-closed by the reactor within 5s " + EXPECT_TRUE(slow_closed) << "Slow reader was never force-closed by the reactor within 15s " << "despite piling up responses against a 64 KiB write queue cap"; close(slow);