use super::*;
pub struct BrowserInstance {
browser: Option<Arc<Browser>>,
instance_id: u64,
return_sender: Option<Arc<mpsc::Sender<ReturnMessage>>>,
state: Arc<BrowserPoolState>,
}
impl BrowserInstance {
pub fn browser(&self) -> &Arc<Browser> {
self.browser
.as_ref()
.expect("Browser instance already released")
}
pub async fn release(mut self) {
if let Some(browser) = self.browser.take() {
if let Some(sender) = &self.return_sender {
if let Err(mpsc::error::SendError(msg)) = sender
.send(ReturnMessage {
instance_id: self.instance_id,
browser,
})
.await
{
error!(
"Return channel closed during release of browser instance {}; reclaiming in_use slot directly",
msg.instance_id
);
self.state
.return_instance(msg.instance_id, msg.browser)
.await;
}
}
}
}
fn reclaim_slot(&self, instance_id: u64, browser: Arc<Browser>) {
if self.state.try_reclaim_in_use_slot(instance_id) {
return;
}
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
let state = Arc::clone(&self.state);
handle.spawn(async move {
state.return_instance(instance_id, browser).await;
});
}
Err(_) => {
error!(
"No tokio runtime to reclaim browser instance {} in_use slot; pool capacity may leak",
instance_id
);
}
}
}
}
impl Drop for BrowserInstance {
fn drop(&mut self) {
if let Some(browser) = self.browser.take() {
if let Some(sender) = &self.return_sender {
match sender.try_send(ReturnMessage {
instance_id: self.instance_id,
browser,
}) {
Ok(_) => {}
Err(mpsc::error::TrySendError::Full(msg)) => {
error!(
"Return channel full for browser instance {}; reclaiming in_use slot directly to avoid permit leak",
msg.instance_id
);
self.reclaim_slot(msg.instance_id, msg.browser);
}
Err(mpsc::error::TrySendError::Closed(msg)) => {
error!(
"Return channel closed for browser instance {}; reclaiming in_use slot directly to avoid permit leak",
msg.instance_id
);
self.reclaim_slot(msg.instance_id, msg.browser);
}
}
}
}
}
}
pub struct PooledPage {
page: Option<Page>,
context_id: Option<BrowserContextId>,
browser_instance: Option<BrowserInstance>,
tab_pool: Option<Arc<TabPool>>,
}
impl PooledPage {
pub fn page(&self) -> &Page {
self.page
.as_ref()
.expect("PooledPage already released (page taken)")
}
pub fn browser(&self) -> &Arc<Browser> {
self.browser_instance
.as_ref()
.expect("PooledPage already released (browser_instance taken)")
.browser()
}
pub async fn release(mut self) {
if let Some(page) = self.page.take() {
match self.tab_pool.as_ref() {
Some(tab_pool) => tab_pool.release(page).await,
None => drop(page),
}
}
if let Some(context_id) = self.context_id.take() {
if let Some(instance) = self.browser_instance.as_ref() {
if let Err(e) = instance.browser().dispose_browser_context(context_id).await {
error!("Failed to dispose browser context on release: {}", e);
}
}
}
if let Some(instance) = self.browser_instance.take() {
instance.release().await;
}
}
fn spawn_tab_return(tab_pool: Arc<TabPool>, page: Page) {
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
handle.spawn(async move {
tab_pool.release(page).await;
});
}
Err(_) => {
debug!("tokio runtime unavailable, dropping Page directly");
}
}
}
fn spawn_context_cleanup(
context_id: BrowserContextId,
instance: BrowserInstance,
) -> Option<BrowserInstance> {
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
handle.spawn(async move {
let browser = instance.browser().clone();
if let Err(e) = browser.dispose_browser_context(context_id).await {
error!("Failed to dispose browser context on drop: {}", e);
}
instance.release().await;
});
None
}
Err(_) => {
error!(
"tokio runtime unavailable, isolated browser context cannot be disposed; context may leak until browser exits"
);
Some(instance)
}
}
}
}
impl Drop for PooledPage {
fn drop(&mut self) {
if let Some(page) = self.page.take() {
if let Some(tab_pool) = self.tab_pool.clone() {
Self::spawn_tab_return(tab_pool, page);
}
}
if let Some(context_id) = self.context_id.take() {
if let Some(instance) = self.browser_instance.take() {
if let Some(instance) = Self::spawn_context_cleanup(context_id, instance) {
self.browser_instance = Some(instance);
}
}
}
}
}
pub struct BrowserPool {
state: Arc<BrowserPoolState>,
}
impl Drop for BrowserPool {
fn drop(&mut self) {
if self.state.shutdown.load(Ordering::Acquire) {
return;
}
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
let state = Arc::clone(&self.state);
handle.spawn(async move {
state.shutdown_all().await;
});
}
Err(_) => {
log::warn!("{}", crate::i18n::tr_log("playwright-pool-drop-no-runtime"));
}
}
}
}
impl BrowserPool {
#[cfg(test)]
pub(super) fn state_for_test(&self) -> &Arc<BrowserPoolState> {
&self.state
}
#[cfg(feature = "engine-moli")]
pub fn set_memory_watermark(
&self,
watermark: Option<Arc<crate::engines::memory_watermark::MemoryWatermark>>,
) {
*self.state.memory.write() = watermark;
}
pub fn new(config: BrowserPoolConfig, browser_config: Arc<dyn BrowserConfigTrait>) -> Self {
let download_manager =
Arc::new(BrowserDownloadManager::new(BrowserDownloadConfig::default()));
Self::with_download_manager(config, browser_config, download_manager)
}
pub fn with_download_manager(
config: BrowserPoolConfig,
browser_config: Arc<dyn BrowserConfigTrait>,
download_manager: Arc<BrowserDownloadManager>,
) -> Self {
let state = Arc::new(BrowserPoolState::new(
config,
browser_config,
download_manager,
));
Self { state }
}
pub async fn acquire(&self) -> Result<BrowserInstance, EngineError> {
let (instance_id, browser) = self.state.acquire().await?;
let return_sender = Some(self.state.clone_return_sender());
Ok(BrowserInstance {
browser: Some(browser),
instance_id,
return_sender,
state: self.state.clone(),
})
}
pub async fn acquire_page(&self) -> Result<PooledPage, EngineError> {
if self.state.config.context_isolation {
self.acquire_page_isolated().await
} else {
self.acquire_page_tab_pool().await
}
}
async fn acquire_page_isolated(&self) -> Result<PooledPage, EngineError> {
let (instance_id, browser) = self.state.acquire().await?;
let context_id = match browser
.create_browser_context(CreateBrowserContextParams::default())
.await
{
Ok(id) => id,
Err(e) => {
let err_msg = format!("Failed to create browser context: {}", e);
self.state
.reclaim_after_page_acquire_failure(instance_id, browser, &err_msg)
.await;
return Err(EngineError::BrowserError(err_msg));
}
};
let params = CreateTargetParams {
browser_context_id: Some(context_id.clone()),
..CreateTargetParams::new("about:blank")
};
let page = match browser.new_page(params).await {
Ok(page) => page,
Err(e) => {
if let Err(dispose_err) = browser.dispose_browser_context(context_id).await {
error!(
"Failed to dispose browser context after page creation failure: {}",
dispose_err
);
}
let err_msg = format!("Failed to create page in isolated context: {}", e);
self.state
.reclaim_after_page_acquire_failure(instance_id, browser, &err_msg)
.await;
return Err(EngineError::BrowserError(err_msg));
}
};
let return_sender = Some(self.state.clone_return_sender());
Ok(PooledPage {
page: Some(page),
context_id: Some(context_id),
browser_instance: Some(BrowserInstance {
browser: Some(browser),
instance_id,
return_sender,
state: self.state.clone(),
}),
tab_pool: None,
})
}
async fn acquire_page_tab_pool(&self) -> Result<PooledPage, EngineError> {
let (instance_id, browser, tab_pool) = self.state.acquire_with_tab_pool().await?;
let page = match tab_pool.acquire(&browser).await {
Ok(page) => page,
Err(e) => {
let err_msg = e.to_string();
self.state
.reclaim_after_page_acquire_failure(instance_id, browser, &err_msg)
.await;
return Err(EngineError::BrowserError(err_msg));
}
};
let return_sender = Some(self.state.clone_return_sender());
Ok(PooledPage {
page: Some(page),
context_id: None,
browser_instance: Some(BrowserInstance {
browser: Some(browser),
instance_id,
return_sender,
state: self.state.clone(),
}),
tab_pool: Some(tab_pool),
})
}
pub async fn start_background_tasks(&self) {
{
let state = self.state.clone();
let health_check_interval =
Duration::from_secs(self.state.config.health_check_interval_secs);
let handle = tokio::spawn(async move {
let mut interval = tokio::time::interval(health_check_interval);
loop {
interval.tick().await;
if state.shutdown.load(Ordering::Acquire) {
break;
}
state.cleanup_idle_instances().await;
state.health_check_all().await;
debug!(
"Browser pool cleanup completed (total: {})",
state.total_instances.load(Ordering::Relaxed)
);
}
});
let mut task = self.state.cleanup_task.lock().await;
*task = Some(handle);
}
{
let state = self.state.clone();
let receiver = self.state.return_receiver.lock().await.take();
let Some(mut receiver) = receiver else {
warn!("Return receiver already taken (start_background_tasks called twice?)");
return;
};
let handle = tokio::spawn(async move {
while let Some(msg) = receiver.recv().await {
if state.shutdown.load(Ordering::Acquire) {
break;
}
state.return_instance(msg.instance_id, msg.browser).await;
}
});
let mut task = self.state.return_task.lock().await;
*task = Some(handle);
}
}
pub async fn stop_background_tasks(&self) {
{
let mut task = self.state.cleanup_task.lock().await;
if let Some(handle) = task.take() {
handle.abort();
}
}
{
let mut task = self.state.return_task.lock().await;
if let Some(handle) = task.take() {
handle.abort();
}
}
}
pub async fn shutdown(&self) {
self.stop_background_tasks().await;
self.state.shutdown_all().await;
}
pub async fn stats(&self) -> BrowserPoolStats {
let available_count = self.state.available.read().await.len();
let in_use_count = self.state.in_use.read().await.len();
BrowserPoolStats {
total_instances: self.state.total_instances.load(Ordering::Relaxed),
available_instances: available_count,
in_use_instances: in_use_count,
max_instances: self.state.config.max_instances,
}
}
pub async fn health_check(&self) {
self.state.health_check_all().await;
}
pub async fn cleanup_idle(&self) {
self.state.cleanup_idle_instances().await;
}
pub fn config(&self) -> &BrowserPoolConfig {
&self.state.config
}
}
impl Clone for BrowserPool {
fn clone(&self) -> Self {
Self {
state: self.state.clone(),
}
}
}