use chromiumoxide::{Browser, Page};
use std::time::Duration;
const RESET_NAVIGATION_TIMEOUT: Duration = Duration::from_secs(5);
pub struct TabPool {
pages: parking_lot::Mutex<Vec<Page>>,
max_size: usize,
}
impl TabPool {
#[must_use]
pub fn new(max_size: usize) -> Self {
Self {
pages: parking_lot::Mutex::new(Vec::with_capacity(max_size)),
max_size,
}
}
pub async fn acquire(&self, browser: &Browser) -> Result<Page, chromiumoxide::error::CdpError> {
{
let mut pages = self.pages.lock();
if let Some(page) = pages.pop() {
return Ok(page);
}
}
browser.new_page("about:blank").await
}
pub async fn release(&self, page: Page) {
{
let pages = self.pages.lock();
if pages.len() >= self.max_size {
return; }
}
let _ = page
.execute(chromiumoxide::cdp::browser_protocol::fetch::DisableParams::default())
.await;
let ok = matches!(
tokio::time::timeout(RESET_NAVIGATION_TIMEOUT, page.goto("about:blank")).await,
Ok(Ok(_))
);
if !ok {
return; }
let mut pages = self.pages.lock();
if pages.len() < self.max_size {
pages.push(page);
}
}
pub fn clear(&self) {
self.pages.lock().clear();
}
#[must_use]
pub fn pool_size(&self) -> usize {
self.pages.lock().len()
}
#[must_use]
pub fn max_size(&self) -> usize {
self.max_size
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.pool_size() == 0
}
#[must_use]
pub fn is_full(&self) -> bool {
self.pool_size() >= self.max_size
}
}
impl std::fmt::Debug for TabPool {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TabPool")
.field("pool_size", &self.pool_size())
.field("max_size", &self.max_size)
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn new_pool_is_empty() {
let pool = TabPool::new(5);
assert!(pool.is_empty());
assert_eq!(pool.pool_size(), 0);
}
#[test]
fn new_pool_not_full() {
let pool = TabPool::new(5);
assert!(!pool.is_full());
}
#[test]
fn max_size_zero_disables_reuse() {
let pool = TabPool::new(0);
assert_eq!(pool.max_size(), 0);
assert!(pool.is_empty());
assert!(pool.is_full()); }
#[test]
fn max_size_positive() {
let pool = TabPool::new(100);
assert_eq!(pool.max_size(), 100);
assert!(!pool.is_full());
}
#[test]
fn debug_format_contains_size_and_max() {
let pool = TabPool::new(10);
let s = format!("{:?}", pool);
assert!(s.contains("pool_size"));
assert!(s.contains("max_size"));
assert!(s.contains("0"));
assert!(s.contains("10"));
}
#[test]
fn clear_empty_pool_no_op() {
let pool = TabPool::new(5);
pool.clear();
assert!(pool.is_empty());
assert_eq!(pool.pool_size(), 0);
}
#[test]
fn clear_resets_head_to_zero() {
let pool = TabPool::new(5);
pool.clear();
assert_eq!(pool.pool_size(), 0);
}
#[test]
fn is_full_when_size_equals_max() {
let pool = TabPool::new(0);
assert!(pool.is_full());
let pool2 = TabPool::new(1);
assert!(!pool2.is_full());
}
#[test]
fn reset_navigation_timeout_is_5s() {
assert_eq!(RESET_NAVIGATION_TIMEOUT, Duration::from_secs(5));
}
}