Orbit Framework 2.0.0
A high-performance asynchronous C++20 HTTP server framework.
Loading...
Searching...
No Matches
ConnectionPool.hpp
Go to the documentation of this file.
1#pragma once
3#include <algorithm>
4#include <chrono>
5#include <functional>
6#include <memory>
7#include <mutex>
8#include <queue>
9#include <stdexcept>
10#include <thread>
11#include <vector>
13
14namespace orbit::database {
15
24template <typename ClientType>
28 std::function<bool(ClientType&)> health_check;
29 std::chrono::milliseconds initial_backoff{100};
30 std::chrono::milliseconds max_backoff{30000};
33 std::function<void(std::chrono::milliseconds, std::function<void()>)> schedule;
34};
35
41template <typename ClientType>
42class ConnectionPool : public std::enable_shared_from_this<ConnectionPool<ClientType>> {
43public:
44 using ClientFactory = std::function<std::shared_ptr<ClientType>()>;
45 using Connector = std::function<void(std::shared_ptr<ClientType>, std::function<void(bool)>)>;
46
54 ConnectionPool(size_t max_size, ClientFactory factory, PoolOptions<ClientType> options = {})
55 : max_size_(max_size), factory_(std::move(factory)), options_(std::move(options)) {
56 if (!options_.schedule) {
57 options_.schedule = [](std::chrono::milliseconds delay, std::function<void()> task) {
58 std::thread([delay, task = std::move(task)] {
59 std::this_thread::sleep_for(delay);
60 task();
61 }).detach();
62 };
63 }
64 }
65
73 void init(Connector connector, std::function<void(bool success)> on_ready) {
74 {
75 std::lock_guard<std::mutex> lock(mutex_);
76 connector_ = connector;
77 }
78 if (max_size_ == 0) {
79 on_ready(true);
80 return;
81 }
82
83 auto self = this->shared_from_this();
84 auto success_count = std::make_shared<size_t>(0);
85 auto fail_count = std::make_shared<size_t>(0);
86
87 for (size_t i = 0; i < max_size_; ++i) {
88 auto client = factory_();
89 connector(client, [self, client, on_ready, success_count, fail_count](bool success) {
90 bool all_done = false;
91 bool all_ok = false;
92 {
93 std::lock_guard<std::mutex> lock(self->mutex_);
94 if (success) {
95 (*success_count)++;
96 } else {
97 (*fail_count)++;
98 }
99 all_done = *success_count + *fail_count == self->max_size_;
100 all_ok = *fail_count == 0;
101 }
102 if (success) {
103 self->release(client);
104 } else if (self->options_.health_check) {
105 self->replace(self->options_.initial_backoff);
106 }
107 if (all_done) on_ready(all_ok);
108 });
109 }
110 }
111
120 void acquire(std::function<void(std::shared_ptr<ClientType>)> callback) {
121 std::shared_ptr<ClientType> client;
122 size_t dropped = 0;
123 {
124 std::lock_guard<std::mutex> lock(mutex_);
125 while (!idle_connections_.empty()) {
126 auto candidate = idle_connections_.front();
127 idle_connections_.pop();
128 if (!options_.health_check || options_.health_check(*candidate)) {
129 client = std::move(candidate);
130 break;
131 }
132 ++dropped;
133 }
134 if (!client) wait_queue_.push(std::move(callback));
135 }
136 for (size_t i = 0; i < dropped; ++i) replace(std::chrono::milliseconds(0));
137 // Invoke callback outside the lock to prevent deadlocks
138 if (client) callback(client);
139 }
140
149 void release(std::shared_ptr<ClientType> client) {
150 if (options_.health_check && !options_.health_check(*client)) {
151 replace(std::chrono::milliseconds(0));
152 return;
153 }
154 std::function<void(std::shared_ptr<ClientType>)> next_callback;
155 {
156 std::lock_guard<std::mutex> lock(mutex_);
157 if (!wait_queue_.empty()) {
158 next_callback = std::move(wait_queue_.front());
159 wait_queue_.pop();
160 } else {
161 idle_connections_.push(client);
162 return;
163 }
164 }
165 // Dispatch immediately to next waiter outside the lock
166 if (next_callback) {
167 next_callback(client);
168 }
169 }
170
172 size_t idle_count() {
173 std::lock_guard<std::mutex> lock(mutex_);
174 return idle_connections_.size();
175 }
176
178 size_t waiting_count() {
179 std::lock_guard<std::mutex> lock(mutex_);
180 return wait_queue_.size();
181 }
182
185 std::lock_guard<std::mutex> lock(mutex_);
186 return reconnecting_;
187 }
188
189private:
190 size_t max_size_;
193
194 std::mutex mutex_;
196 size_t reconnecting_ = 0;
197 std::queue<std::shared_ptr<ClientType>> idle_connections_;
198 std::queue<std::function<void(std::shared_ptr<ClientType>)>> wait_queue_;
199
200 // Connects a new client in place of a dropped or failed one, after
201 // @p delay; a failed attempt is retried with twice the delay (capped).
202 void replace(std::chrono::milliseconds delay) {
203 Connector connector;
204 {
205 std::lock_guard<std::mutex> lock(mutex_);
206 if (!connector_) return; // init() was never called: nothing to connect with
207 connector = connector_;
209 }
210 std::weak_ptr<ConnectionPool> weak = this->shared_from_this();
211 auto attempt = [weak, connector, delay]() {
212 auto self = weak.lock();
213 if (!self) return; // the pool is gone
214 auto client = self->factory_();
215 connector(client, [weak, client, delay](bool success) {
216 auto self = weak.lock();
217 if (!self) return;
218 {
219 std::lock_guard<std::mutex> lock(self->mutex_);
220 --self->reconnecting_;
221 }
222 if (success) {
223 self->release(client);
224 } else {
225 auto next = std::max(self->options_.initial_backoff, delay * 2);
226 self->replace(std::min(next, self->options_.max_backoff));
227 }
228 });
229 };
230 if (delay.count() == 0) {
231 attempt();
232 } else {
233 options_.schedule(delay, attempt);
234 }
235 }
236};
237
238} // namespace database
A thread-safe connection pool for managing reusable database client connections.
Definition ConnectionPool.hpp:42
std::function< std::shared_ptr< ClientType >()> ClientFactory
Definition ConnectionPool.hpp:44
size_t max_size_
Definition ConnectionPool.hpp:190
size_t reconnecting_
Definition ConnectionPool.hpp:196
PoolOptions< ClientType > options_
Definition ConnectionPool.hpp:192
std::mutex mutex_
Definition ConnectionPool.hpp:194
ClientFactory factory_
Definition ConnectionPool.hpp:191
size_t idle_count()
Idle clients ready to be acquired.
Definition ConnectionPool.hpp:172
void acquire(std::function< void(std::shared_ptr< ClientType >)> callback)
Acquires a database connection asynchronously from the pool.
Definition ConnectionPool.hpp:120
size_t reconnecting_count()
Replacements being connected (or waiting out a backoff).
Definition ConnectionPool.hpp:184
void release(std::shared_ptr< ClientType > client)
Releases a connection back to the pool.
Definition ConnectionPool.hpp:149
void init(Connector connector, std::function< void(bool success)> on_ready)
Initializes the pool by establishing the initial set of connections.
Definition ConnectionPool.hpp:73
std::queue< std::function< void(std::shared_ptr< ClientType >)> > wait_queue_
Definition ConnectionPool.hpp:198
void replace(std::chrono::milliseconds delay)
Definition ConnectionPool.hpp:202
size_t waiting_count()
Acquirers waiting for a client.
Definition ConnectionPool.hpp:178
ConnectionPool(size_t max_size, ClientFactory factory, PoolOptions< ClientType > options={})
Constructs a new ConnectionPool.
Definition ConnectionPool.hpp:54
Connector connector_
Definition ConnectionPool.hpp:195
std::function< void(std::shared_ptr< ClientType >, std::function< void(bool)>)> Connector
Definition ConnectionPool.hpp:45
std::queue< std::shared_ptr< ClientType > > idle_connections_
Definition ConnectionPool.hpp:197
Definition ConnectionPool.hpp:14
Definition json.hpp:5363
Health checking and reconnecting for a ConnectionPool.
Definition ConnectionPool.hpp:25
std::function< bool(ClientType &)> health_check
Definition ConnectionPool.hpp:28
std::chrono::milliseconds initial_backoff
Definition ConnectionPool.hpp:29
std::chrono::milliseconds max_backoff
Definition ConnectionPool.hpp:30
std::function< void(std::chrono::milliseconds, std::function< void()>)> schedule
Definition ConnectionPool.hpp:33