1use crate::http::Request;
23use std::sync::{Arc, Mutex};
24
25#[derive(Clone)]
31pub struct RequestPool {
32 pool: Arc<Mutex<Vec<Request>>>,
33 max_size: usize,
34 created_count: Arc<Mutex<usize>>,
35 borrowed_count: Arc<Mutex<usize>>,
36 returned_count: Arc<Mutex<usize>>,
37}
38
39impl RequestPool {
40 pub fn new(max_size: usize) -> Self {
49 Self {
50 pool: Arc::new(Mutex::new(Vec::with_capacity(max_size))),
51 max_size,
52 created_count: Arc::new(Mutex::new(0)),
53 borrowed_count: Arc::new(Mutex::new(0)),
54 returned_count: Arc::new(Mutex::new(0)),
55 }
56 }
57
58 pub fn get(&self) -> PooledRequest {
63 let request = {
64 let mut pool = match self.pool.lock() {
65 Ok(p) => p,
66 Err(_) => {
67 return PooledRequest {
69 request: Some(Request::default()),
70 pool: self.clone(),
71 };
72 }
73 };
74 match pool.pop() {
75 Some(mut req) => {
76 req.reset();
78 req
79 }
80 None => {
81 if let Ok(mut count) = self.created_count.lock() {
83 *count += 1;
84 }
85 Request::default()
86 }
87 }
88 };
89
90 if let Ok(mut count) = self.borrowed_count.lock() {
91 *count += 1;
92 }
93
94 PooledRequest {
95 request: Some(request),
96 pool: self.clone(),
97 }
98 }
99
100 fn return_request(&self, mut request: Request) {
105 if let Ok(mut pool) = self.pool.lock() {
106 if pool.len() < self.max_size {
107 request.reset();
109 pool.push(request);
110 if let Ok(mut count) = self.returned_count.lock() {
111 *count += 1;
112 }
113 }
114 }
115 }
117
118 pub fn stats(&self) -> PoolStats {
120 let pool_size = self.pool.lock().map(|p| p.len()).unwrap_or(0);
121 let created = self.created_count.lock().map(|c| *c).unwrap_or(0);
122 let borrowed = self.borrowed_count.lock().map(|b| *b).unwrap_or(0);
123 let returned = self.returned_count.lock().map(|r| *r).unwrap_or(0);
124
125 PoolStats {
126 pool_size,
127 max_size: self.max_size,
128 created_count: created,
129 borrowed_count: borrowed,
130 returned_count: returned,
131 hit_rate: if borrowed > 0 && borrowed >= created {
132 (borrowed - created) as f64 / borrowed as f64 * 100.0
133 } else {
134 0.0
135 },
136 }
137 }
138
139 pub fn clear(&self) {
143 if let Ok(mut pool) = self.pool.lock() {
144 pool.clear();
145 }
146 }
147
148 pub fn warm_up(&self, count: usize) {
153 let count = count.min(self.max_size);
154 let mut pool = match self.pool.lock() {
155 Ok(p) => p,
156 Err(_) => return, };
158
159 for _ in 0..count {
160 if pool.len() < self.max_size {
161 pool.push(Request::default());
162 if let Ok(mut created) = self.created_count.lock() {
163 *created += 1;
164 }
165 }
166 }
167 }
168}
169
170pub struct PooledRequest {
175 request: Option<Request>,
176 pool: RequestPool,
177}
178
179impl PooledRequest {
180 pub fn get_mut(&mut self) -> Option<&mut Request> {
182 self.request.as_mut()
183 }
184
185 pub fn get(&self) -> Option<&Request> {
187 self.request.as_ref()
188 }
189
190 pub fn into_inner(mut self) -> Option<Request> {
195 self.request.take()
196 }
197}
198
199impl std::ops::Deref for PooledRequest {
200 type Target = Request;
201
202 fn deref(&self) -> &Self::Target {
203 self.request
204 .as_ref()
205 .expect("PooledRequest: request already taken")
206 }
207}
208
209impl std::ops::DerefMut for PooledRequest {
210 fn deref_mut(&mut self) -> &mut Self::Target {
211 self.request
212 .as_mut()
213 .expect("PooledRequest: request already taken")
214 }
215}
216
217impl Drop for PooledRequest {
218 fn drop(&mut self) {
219 if let Some(request) = self.request.take() {
220 self.pool.return_request(request);
221 }
222 }
223}
224
225#[derive(Debug, Clone)]
227pub struct PoolStats {
228 pub pool_size: usize,
230 pub max_size: usize,
232 pub created_count: usize,
234 pub borrowed_count: usize,
236 pub returned_count: usize,
238 pub hit_rate: f64,
240}
241
242static REQUEST_POOL: std::sync::OnceLock<RequestPool> = std::sync::OnceLock::new();
247
248pub fn global_request_pool() -> &'static RequestPool {
254 REQUEST_POOL.get_or_init(|| {
255 let core_count = num_cpus::get();
256 let pool_size = (core_count * 4).max(16).min(512);
257
258 let pool = RequestPool::new(pool_size);
259 pool.warm_up(pool_size / 2); pool
261 })
262}
263
264pub fn init_global_pool(
269 max_size: usize,
270 warm_up_count: usize,
271) -> std::result::Result<(), &'static str> {
272 let pool = RequestPool::new(max_size);
273 pool.warm_up(warm_up_count);
274
275 REQUEST_POOL
276 .set(pool)
277 .map_err(|_| "Global pool already initialized")
278}
279
280#[cfg(test)]
281mod tests {
282 use super::*;
283
284 #[test]
285 fn test_pool_basic_functionality() {
286 let pool = RequestPool::new(5);
287
288 let mut req1 = pool.get();
290 req1.method = "GET".to_string();
291 req1.uri = "/test".to_string();
292
293 let stats = pool.stats();
294 assert_eq!(stats.created_count, 1);
295 assert_eq!(stats.borrowed_count, 1);
296 assert_eq!(stats.pool_size, 0);
297
298 drop(req1);
300
301 let stats = pool.stats();
302 assert_eq!(stats.returned_count, 1);
303 assert_eq!(stats.pool_size, 1);
304
305 let req2 = pool.get();
307 assert!(req2.method.is_empty()); assert!(req2.uri.is_empty());
309
310 let stats = pool.stats();
311 assert_eq!(stats.created_count, 1); assert_eq!(stats.borrowed_count, 2);
313 assert_eq!(stats.pool_size, 0);
314 assert!(stats.hit_rate > 0.0);
315 }
316
317 #[test]
318 fn test_pool_max_size() {
319 let pool = RequestPool::new(2);
320
321 let req1 = pool.get();
323 let req2 = pool.get();
324 let req3 = pool.get();
325
326 drop(req1);
327 drop(req2);
328 drop(req3);
329
330 let stats = pool.stats();
331 assert_eq!(stats.pool_size, 2); assert_eq!(stats.returned_count, 2);
333 }
334
335 #[test]
336 fn test_request_reset() {
337 let pool = RequestPool::new(5);
338
339 {
340 let mut req = pool.get();
341 req.method = "POST".to_string();
342 req.uri = "/api/test".to_string();
343 req.headers
344 .insert("Content-Type".to_string(), "application/json".to_string());
345 req.query.insert("param".to_string(), "value".to_string());
346 } let req = pool.get();
351 assert!(req.method.is_empty());
352 assert!(req.uri.is_empty());
353 assert!(req.headers.is_empty());
354 assert!(req.query.is_empty());
355 assert!(req.body_as_string().is_empty());
356 }
357
358 #[test]
359 fn test_pool_warm_up() {
360 let pool = RequestPool::new(10);
361 pool.warm_up(5);
362
363 let stats = pool.stats();
364 assert_eq!(stats.pool_size, 5);
365 assert_eq!(stats.created_count, 5);
366 assert_eq!(stats.borrowed_count, 0);
367 }
368
369 #[test]
370 fn test_global_pool() {
371 let pool1 = global_request_pool();
372 let pool2 = global_request_pool();
373
374 assert!(std::ptr::eq(pool1, pool2));
376
377 let _req = pool1.get();
378 let stats = pool1.stats();
379 assert!(stats.max_size >= 16); }
381}