#pragma once // Keep-alive connection pool. Owns idle socket fds keyed by pool key, // enforces per-client, per-host, and idle caps with bounded acquire waits. #include #include #include #include #include #include #include namespace molo::clients { struct PooledConnection { int fd = -1; std::chrono::steady_clock::time_point idle_since; std::chrono::steady_clock::time_point expires_at; }; struct PoolStats { std::size_t in_use = 0; std::size_t idle = 0; std::size_t created = 0; std::size_t reused = 0; std::size_t closed = 0; std::size_t evicted_idle_overflow = 0; }; class ConnectionPool { public: ConnectionPool(); ~ConnectionPool(); ConnectionPool(const ConnectionPool&) = delete; ConnectionPool& operator=(const ConnectionPool&) = delete; // Takes an idle connection for key, or nullopt when none is reusable. std::optional acquire(const std::string& key); // Returns a connection to the idle set (reusable=true) or closes it. void release(const std::string& key, int fd, bool reusable); // Records that the caller opened a fresh connection outside the pool. // Returns false when the per-host or total cap forbids a new connection. bool reserve(const std::string& key); // Drops a reservation made by reserve() (connect failed). void drop_reservation(const std::string& key); // Closes a connection that bypassed release() (I/O error mid-use). void discard(int fd); void close_all(); PoolStats stats() const; private: void prune_locked(const std::string& key, std::chrono::steady_clock::time_point now); mutable std::mutex mutex_; std::map> idle_; std::map in_use_; std::size_t total_ = 0; PoolStats stats_; }; } // namespace molo::clients