Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

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.rs
index 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.rs
index 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.rs
index 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 = self
diff --git a/moli-renderer-v8/src/script_vm/document_isolate.rs b/moli-renderer-v8/src/script_vm/document_isolate.rs
index 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.rs
index 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()
}