use crate::http::Request;
use std::sync::{Arc, Mutex};
#[derive(Clone)]
pub struct RequestPool {
pool: Arc<Mutex<Vec<Request>>>,
max_size: usize,
created_count: Arc<Mutex<usize>>,
borrowed_count: Arc<Mutex<usize>>,
returned_count: Arc<Mutex<usize>>,
}
impl RequestPool {
pub fn new(max_size: usize) -> Self {
Self {
pool: Arc::new(Mutex::new(Vec::with_capacity(max_size))),
max_size,
created_count: Arc::new(Mutex::new(0)),
borrowed_count: Arc::new(Mutex::new(0)),
returned_count: Arc::new(Mutex::new(0)),
}
}
pub fn get(&self) -> PooledRequest {
let request = {
let mut pool = match self.pool.lock() {
Ok(p) => p,
Err(_) => {
return PooledRequest {
request: Some(Request::default()),
pool: self.clone(),
};
}
};
match pool.pop() {
Some(mut req) => {
req.reset();
req
}
None => {
if let Ok(mut count) = self.created_count.lock() {
*count += 1;
}
Request::default()
}
}
};
if let Ok(mut count) = self.borrowed_count.lock() {
*count += 1;
}
PooledRequest {
request: Some(request),
pool: self.clone(),
}
}
fn return_request(&self, mut request: Request) {
if let Ok(mut pool) = self.pool.lock() {
if pool.len() < self.max_size {
request.reset();
pool.push(request);
if let Ok(mut count) = self.returned_count.lock() {
*count += 1;
}
}
}
}
pub fn stats(&self) -> PoolStats {
let pool_size = self.pool.lock().map(|p| p.len()).unwrap_or(0);
let created = self.created_count.lock().map(|c| *c).unwrap_or(0);
let borrowed = self.borrowed_count.lock().map(|b| *b).unwrap_or(0);
let returned = self.returned_count.lock().map(|r| *r).unwrap_or(0);
PoolStats {
pool_size,
max_size: self.max_size,
created_count: created,
borrowed_count: borrowed,
returned_count: returned,
hit_rate: if borrowed > 0 && borrowed >= created {
(borrowed - created) as f64 / borrowed as f64 * 100.0
} else {
0.0
},
}
}
pub fn clear(&self) {
if let Ok(mut pool) = self.pool.lock() {
pool.clear();
}
}
pub fn warm_up(&self, count: usize) {
let count = count.min(self.max_size);
let mut pool = match self.pool.lock() {
Ok(p) => p,
Err(_) => return, };
for _ in 0..count {
if pool.len() < self.max_size {
pool.push(Request::default());
if let Ok(mut created) = self.created_count.lock() {
*created += 1;
}
}
}
}
}
pub struct PooledRequest {
request: Option<Request>,
pool: RequestPool,
}
impl PooledRequest {
pub fn get_mut(&mut self) -> Option<&mut Request> {
self.request.as_mut()
}
pub fn get(&self) -> Option<&Request> {
self.request.as_ref()
}
pub fn into_inner(mut self) -> Option<Request> {
self.request.take()
}
}
impl std::ops::Deref for PooledRequest {
type Target = Request;
fn deref(&self) -> &Self::Target {
self.request
.as_ref()
.expect("PooledRequest: request already taken")
}
}
impl std::ops::DerefMut for PooledRequest {
fn deref_mut(&mut self) -> &mut Self::Target {
self.request
.as_mut()
.expect("PooledRequest: request already taken")
}
}
impl Drop for PooledRequest {
fn drop(&mut self) {
if let Some(request) = self.request.take() {
self.pool.return_request(request);
}
}
}
#[derive(Debug, Clone)]
pub struct PoolStats {
pub pool_size: usize,
pub max_size: usize,
pub created_count: usize,
pub borrowed_count: usize,
pub returned_count: usize,
pub hit_rate: f64,
}
static REQUEST_POOL: std::sync::OnceLock<RequestPool> = std::sync::OnceLock::new();
pub fn global_request_pool() -> &'static RequestPool {
REQUEST_POOL.get_or_init(|| {
let core_count = num_cpus::get();
let pool_size = (core_count * 4).max(16).min(512);
let pool = RequestPool::new(pool_size);
pool.warm_up(pool_size / 2); pool
})
}
pub fn init_global_pool(
max_size: usize,
warm_up_count: usize,
) -> std::result::Result<(), &'static str> {
let pool = RequestPool::new(max_size);
pool.warm_up(warm_up_count);
REQUEST_POOL
.set(pool)
.map_err(|_| "Global pool already initialized")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_pool_basic_functionality() {
let pool = RequestPool::new(5);
let mut req1 = pool.get();
req1.method = "GET".to_string();
req1.uri = "/test".to_string();
let stats = pool.stats();
assert_eq!(stats.created_count, 1);
assert_eq!(stats.borrowed_count, 1);
assert_eq!(stats.pool_size, 0);
drop(req1);
let stats = pool.stats();
assert_eq!(stats.returned_count, 1);
assert_eq!(stats.pool_size, 1);
let req2 = pool.get();
assert!(req2.method.is_empty()); assert!(req2.uri.is_empty());
let stats = pool.stats();
assert_eq!(stats.created_count, 1); assert_eq!(stats.borrowed_count, 2);
assert_eq!(stats.pool_size, 0);
assert!(stats.hit_rate > 0.0);
}
#[test]
fn test_pool_max_size() {
let pool = RequestPool::new(2);
let req1 = pool.get();
let req2 = pool.get();
let req3 = pool.get();
drop(req1);
drop(req2);
drop(req3);
let stats = pool.stats();
assert_eq!(stats.pool_size, 2); assert_eq!(stats.returned_count, 2);
}
#[test]
fn test_request_reset() {
let pool = RequestPool::new(5);
{
let mut req = pool.get();
req.method = "POST".to_string();
req.uri = "/api/test".to_string();
req.headers
.insert("Content-Type".to_string(), "application/json".to_string());
req.query.insert("param".to_string(), "value".to_string());
}
let req = pool.get();
assert!(req.method.is_empty());
assert!(req.uri.is_empty());
assert!(req.headers.is_empty());
assert!(req.query.is_empty());
assert!(req.body_as_string().is_empty());
}
#[test]
fn test_pool_warm_up() {
let pool = RequestPool::new(10);
pool.warm_up(5);
let stats = pool.stats();
assert_eq!(stats.pool_size, 5);
assert_eq!(stats.created_count, 5);
assert_eq!(stats.borrowed_count, 0);
}
#[test]
fn test_global_pool() {
let pool1 = global_request_pool();
let pool2 = global_request_pool();
assert!(std::ptr::eq(pool1, pool2));
let _req = pool1.get();
let stats = pool1.stats();
assert!(stats.max_size >= 16); }
}