Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(renderer): terminate inspector targets on owner shutdown
ldm0d73651aea6d3
diff --git a/moli-renderer-v8/src/devtools/target.rs b/moli-renderer-v8/src/devtools/target.rsindex 9c624ab6d..2954f3068 100644--- a/moli-renderer-v8/src/devtools/target.rs+++ b/moli-renderer-v8/src/devtools/target.rs@@ -1,4 +1,9 @@use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken};+use parking_lot::Mutex;+use std::{+ collections::HashMap,+ sync::{Arc, Weak},+};use super::{ingress::{io::RendererInspectorIoIngress, main::RendererInspectorMainIngress},@@ -6,6 +11,82 @@ use super::{};use crate::runtime::PageId;+#[derive(Default)]+pub(crate) struct RendererDevToolsTargetShutdownRegistry {+ shared: Arc<Mutex<RendererDevToolsTargetShutdownRegistryState>>,+}++#[derive(Default)]+struct RendererDevToolsTargetShutdownRegistryState {+ terminal: bool,+ next_registration_id: u64,+ targets: HashMap<u64, RendererDevToolsTargetHandle>,+}++pub(crate) struct RendererDevToolsTargetShutdownRegistration {+ shared: Weak<Mutex<RendererDevToolsTargetShutdownRegistryState>>,+ registration_id: u64,+}++impl RendererDevToolsTargetShutdownRegistry {+ pub(crate) fn register(+ &self,+ target: RendererDevToolsTargetHandle,+ ) -> Result<RendererDevToolsTargetShutdownRegistration, &'static str> {+ let registration_id = {+ let mut state = self.shared.lock();+ if state.terminal {+ drop(state);+ target.close("Inspector target rejected after renderer owner shutdown");+ return Err("renderer owner is shut down");+ }+ state.next_registration_id = state+ .next_registration_id+ .checked_add(1)+ .ok_or("renderer DevTools target registration ID overflow")?;+ let registration_id = state.next_registration_id;+ let previous = state.targets.insert(registration_id, target);+ debug_assert!(previous.is_none());+ registration_id+ };+ Ok(RendererDevToolsTargetShutdownRegistration {+ shared: Arc::downgrade(&self.shared),+ registration_id,+ })+ }++ pub(crate) fn terminate_all(&self) {+ let targets = {+ let mut state = self.shared.lock();+ state.terminal = true;+ std::mem::take(&mut state.targets)+ };+ for target in targets.into_values() {+ target.close("Inspector target closed with its renderer owner");+ }+ }+}++impl std::fmt::Debug for RendererDevToolsTargetShutdownRegistry {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ let state = self.shared.lock();+ formatter+ .debug_struct("RendererDevToolsTargetShutdownRegistry")+ .field("terminal", &state.terminal)+ .field("target_count", &state.targets.len())+ .finish()+ }+}++impl Drop for RendererDevToolsTargetShutdownRegistration {+ fn drop(&mut self) {+ let Some(shared) = self.shared.upgrade() else {+ return;+ };+ shared.lock().targets.remove(&self.registration_id);+ }+}+/// Cloneable control-plane handle for one renderer DevTools target.////// The handle is safe to retain outside the isolate owner stack. It exposes@@ -186,4 +267,62 @@ mod tests {"terminal Page.crash must reject late ordinary IO work");}++ #[tokio::test]+ async fn renderer_owner_shutdown_closes_every_registered_target() {+ let registry = RendererDevToolsTargetShutdownRegistry::default();+ let pause = RendererInspectorPauseBridge::default();+ let main = RendererInspectorMainIngress::new(+ RendererInspectorSessionExecutorRouteId::new(2),+ pause.pause_loop_wake(),+ );+ let io = RendererInspectorIoIngress::new(pause.pause_loop_wake(), None);+ let target = RendererDevToolsTargetHandle::new(pause, main.clone(), io.clone());+ let registration = registry+ .register(target)+ .expect("live owner must register its Inspector target");+ assert_eq!(registry.shared.lock().targets.len(), 1);++ let pending = io.enqueue_command(+ RendererDevToolsAgentToken::allocate(),+ RendererDevToolsIoCommandEnvelope::performance_get_metrics(+ RendererInspectorIngressTicket::new(+ None,+ Some("session-owner-shutdown".to_owned()),+ RendererInspectorCommandRoute::Io,+ ),+ ),+ );+ registry.terminate_all();+ assert!(matches!(+ pending.wait_for_first_dispatch().await,+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(_))+ ));+ assert!(registry.shared.lock().terminal);+ assert!(registry.shared.lock().targets.is_empty());++ drop(registration);+ let late_pause = RendererInspectorPauseBridge::default();+ let late_main = RendererInspectorMainIngress::new(+ RendererInspectorSessionExecutorRouteId::new(3),+ late_pause.pause_loop_wake(),+ );+ let late_io = RendererInspectorIoIngress::new(late_pause.pause_loop_wake(), None);+ let late_target = RendererDevToolsTargetHandle::new(late_pause, late_main, late_io.clone());+ assert!(registry.register(late_target).is_err());+ let rejected = late_io.enqueue_command(+ RendererDevToolsAgentToken::allocate(),+ RendererDevToolsIoCommandEnvelope::performance_get_metrics(+ RendererInspectorIngressTicket::new(+ None,+ Some("session-late-owner-shutdown".to_owned()),+ RendererInspectorCommandRoute::Io,+ ),+ ),+ );+ assert!(matches!(+ rejected.wait_for_first_dispatch().await,+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(_))+ ));+ }}diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rsindex 567bd342e..152c64769 100644--- a/moli-renderer-v8/src/runtime/owner.rs+++ b/moli-renderer-v8/src/runtime/owner.rs@@ -1007,6 +1007,8 @@ pub(super) struct RendererOwnerState {pub(super) render_runtime_admission: std::sync::OnceLock<RenderRuntimeHandle>,pub(super) inspector_io_wake_tx: mpsc::UnboundedSender<RendererInspectorIoOwnerWake>,pub(super) browser_context_runtime: RendererBrowserContextRuntime,+ pub(super) devtools_target_shutdown_registry:+ crate::devtools::target::RendererDevToolsTargetShutdownRegistry,pub(super) owner_local_host_id: RendererOwnerLocalHostId,layout_policy: Mutex<RendererOwnerLayoutPolicyState>,context_shutdown_notify: tokio::sync::Notify,@@ -1810,6 +1812,7 @@ impl RendererOwnerHandle {render_runtime_admission: std::sync::OnceLock::new(),inspector_io_wake_tx,browser_context_runtime,+ devtools_target_shutdown_registry: Default::default(),owner_local_host_id,layout_policy: Mutex::new(RendererOwnerLayoutPolicyState::default()),context_shutdown_notify: tokio::sync::Notify::new(),@@ -2333,6 +2336,7 @@ impl RendererOwnerHandle {// one side of this boundary: rejected with ownership returned to the// caller, or durably enqueued for the renderer terminal drain.self.render_runtime.close_admission();+ self.state.devtools_target_shutdown_registry.terminate_all();self.state.page_table.terminate_and_cancel_all_contexts(RendererPageContextCancelReason::ContextDropped);diff --git a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs b/moli-renderer-v8/src/runtime/owner_local_store/mod.rsindex c0855e951..63fd7879d 100644--- a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs+++ b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs@@ -1124,8 +1124,10 @@ impl RendererOwnerLocalStore {let v8_foreground_task_sender = page_runtime_task_source.v8_foreground_task_sender().ok_or_else(|| anyhow!("owner-reserved Page is missing its V8 foreground source"))?;- let bootstrap =- RendererDocumentIsolateHandle::new_owner_reserved_page(v8_foreground_task_sender)?;+ let bootstrap = RendererDocumentIsolateHandle::new_owner_reserved_page(+ v8_foreground_task_sender,+ &owner.owner_state.devtools_target_shutdown_registry,+ )?;let host_handle = bootstrap.clone_renderer_document_isolate_handle_for_owner_retention();let reservation_id = self.next_renderer_document_isolate_reservation_id;self.next_renderer_document_isolate_reservation_id = selfdiff --git a/moli-renderer-v8/src/script_vm/document_isolate.rs b/moli-renderer-v8/src/script_vm/document_isolate.rsindex 94ba8750e..956af5473 100644--- a/moli-renderer-v8/src/script_vm/document_isolate.rs+++ b/moli-renderer-v8/src/script_vm/document_isolate.rs@@ -10,6 +10,9 @@ use super::{};use crate::{context_bootstrap::ContextBootstrapAssets,+ devtools::target::{+ RendererDevToolsTargetShutdownRegistration, RendererDevToolsTargetShutdownRegistry,+ },document_runtime::DocumentRuntime,exception_reporting::v8_message_listener,module_runtime::{@@ -356,24 +359,31 @@ impl RendererDocumentIsolateHandle {Self::new_with_foreground_wake(V8ForegroundTaskWake::page(v8_foreground_task_sender),RendererDocumentIsolateTeardown::standalone_test(),+ None,)}pub(crate) fn new_owner_reserved_page(v8_foreground_task_sender: RendererPageV8ForegroundTaskSender,+ devtools_target_shutdown_registry: &RendererDevToolsTargetShutdownRegistry,) -> Result<RendererDocumentIsolateBootstrap> {Self::new_with_foreground_wake(V8ForegroundTaskWake::page(v8_foreground_task_sender),RendererDocumentIsolateTeardown::owner_reserved_page(),+ Some(devtools_target_shutdown_registry),)}fn new_with_foreground_wake(foreground_wake: V8ForegroundTaskWake,renderer_document_isolate_teardown: RendererDocumentIsolateTeardown,+ devtools_target_shutdown_registry: Option<&RendererDevToolsTargetShutdownRegistry>,) -> Result<RendererDocumentIsolateBootstrap> {let (renderer_document_isolate, bridge_bindings) =- RendererDocumentIsolateHolder::new_holder(foreground_wake)?;+ RendererDocumentIsolateHolder::new_holder(+ foreground_wake,+ devtools_target_shutdown_registry,+ )?;let renderer_document_isolate = Self {inner: Rc::new(RefCell::new(renderer_document_isolate)),};@@ -496,6 +506,9 @@ impl RendererDocumentIsolateHandle {}pub(super) struct RendererDocumentIsolateHolder {+ // Unregister before destroying the Inspector backend so owner shutdown+ // never observes a target whose isolate has already been disposed.+ _devtools_target_shutdown_registration: Option<RendererDevToolsTargetShutdownRegistration>,// Inspector backend/session teardown touches V8 objects, so it must drop before the// isolate. `ScriptVm::drop` normally performs explicit context destruction;// this field order is the final safety net for partial construction paths.@@ -509,7 +522,10 @@ pub(super) struct RendererDocumentIsolateHolder {}impl RendererDocumentIsolateHolder {- fn new_holder(foreground_wake: V8ForegroundTaskWake) -> Result<(Self, NativeBridgeBindings)> {+ fn new_holder(+ foreground_wake: V8ForegroundTaskWake,+ devtools_target_shutdown_registry: Option<&RendererDevToolsTargetShutdownRegistry>,+ ) -> Result<(Self, NativeBridgeBindings)> {let timing_enabled = moli_trace::cdp_nav_timing_enabled();let total_start = timing_enabled.then(std::time::Instant::now);@@ -607,6 +623,10 @@ impl RendererDocumentIsolateHolder {let inspector_start = timing_enabled.then(std::time::Instant::now);let inspector_backend = RendererInspectorIsolateBackend::new(&mut isolate);+ let devtools_target_shutdown_registration = devtools_target_shutdown_registry+ .map(|registry| registry.register(inspector_backend.devtools_target()))+ .transpose()+ .map_err(|error| anyhow!(error))?;if timing_enabled {tracing::info!(target: "moli_cdp_nav_timing",@@ -632,6 +652,7 @@ impl RendererDocumentIsolateHolder {Ok((Self::new(+ devtools_target_shutdown_registration,inspector_backend,isolate_bootstrap,platform_registration,@@ -642,12 +663,14 @@ impl RendererDocumentIsolateHolder {}pub(super) fn new(+ devtools_target_shutdown_registration: Option<RendererDevToolsTargetShutdownRegistration>,inspector_backend: RendererInspectorIsolateBackend,bootstrap: IsolateBootstrapCache,platform_registration: V8PlatformIsolateRegistration,isolate: v8::OwnedIsolate,) -> Self {Self {+ _devtools_target_shutdown_registration: devtools_target_shutdown_registration,inspector_backend: Some(inspector_backend),bootstrap,_platform_registration: platform_registration,diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rsindex 8ccdbd52a..d87698e41 100644--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs@@ -649,7 +649,7 @@ impl RendererInspectorIsolateBackend {}}- pub(super) fn devtools_target(&self) -> RendererDevToolsTargetHandle {+ pub(in crate::script_vm) fn devtools_target(&self) -> RendererDevToolsTargetHandle {self.target.clone()}