From 248ac028ca4d2ec2d7973904ce19957dbaec60f1 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sun, 15 Nov 2026 03:39:47 +0800 Subject: [PATCH] fix(workers): preserve Inspector attachments while scripts load --- .../src/domains/runtime/tests/mod.rs | 1 + .../tests/worker_loading_attachment.rs | 214 ++++++++++++++++++ .../src/runtime/browser_context_runtime.rs | 15 +- .../dedicated_workers.rs | 131 +++++++++-- .../src/worker/inspector_task_runner.rs | 46 +++- 5 files changed, 379 insertions(+), 28 deletions(-) create mode 100644 moli-protocol/src/domains/runtime/tests/worker_loading_attachment.rs diff --git a/moli-protocol/src/domains/runtime/tests/mod.rs b/moli-protocol/src/domains/runtime/tests/mod.rs index 1dc5da8f1b6..07429929573 100644 --- a/moli-protocol/src/domains/runtime/tests/mod.rs +++ b/moli-protocol/src/domains/runtime/tests/mod.rs @@ -221,3 +221,4 @@ mod service_worker; mod shared_worker; mod worker_emulation; +mod worker_loading_attachment; diff --git a/moli-protocol/src/domains/runtime/tests/worker_loading_attachment.rs b/moli-protocol/src/domains/runtime/tests/worker_loading_attachment.rs new file mode 100644 index 00000000000..8c7c0c426e1 --- /dev/null +++ b/moli-protocol/src/domains/runtime/tests/worker_loading_attachment.rs @@ -0,0 +1,214 @@ +use super::*; +use serde_json::Value; +use std::{sync::Arc, time::Duration}; +use tokio::sync::Notify; + +async fn command( + ctx: &mut TestContext, + id: u64, + session: Option<&str>, + method: &str, + params: Value, +) -> Value { + let mut request = json!({"id":id, "method":method, "params":params}); + if let Some(session) = session { + request["sessionId"] = json!(session); + } + ctx.process_and_wait_for_response_async(request).await; + let response = take_response_by_id(ctx, id); + assert!(response.get("error").is_none(), "{response}"); + assert!( + response["result"].get("exceptionDetails").is_none(), + "{response}" + ); + response["result"].clone() +} + +#[tokio::test(flavor = "multi_thread")] +async fn dedicated_worker_early_attachment_survives_script_loading() { + check_loading_attachment(false).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn dedicated_worker_loading_does_not_restore_detached_inspector_session() { + check_loading_attachment(true).await; +} + +async fn check_loading_attachment(detach_first: bool) { + let release = Arc::new(Notify::new()); + let requested = Arc::new(Notify::new()); + let worker_release = release.clone(); + let worker_requested = requested.clone(); + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let base = format!("http://{}", listener.local_addr().unwrap()); + let app = Router::new() + .route( + "/page", + get(|| async { + ( + [(CONTENT_TYPE.as_str(), "text/html")], + "worker attachment", + ) + }), + ) + .route( + "/worker.js", + get(move || { + let release = worker_release.clone(); + let requested = worker_requested.clone(); + async move { + requested.notify_one(); + release.notified().await; + ( + [(CONTENT_TYPE.as_str(), "text/javascript")], + "globalThis.attachmentProbe = 42; postMessage('ready');", + ) + } + }), + ); + let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() }); + let mut ctx = TestContext::new(); + with_loaded_http_document_async(&mut ctx, &format!("{base}/page"), "SID-page", "TID-page") + .await; + command( + &mut ctx, + 80100, + None, + "Target.setDiscoverTargets", + json!({"discover":true}), + ) + .await; + command( + &mut ctx, + 80101, + Some("SID-page"), + "Runtime.enable", + json!({}), + ) + .await; + command(&mut ctx, 80102, Some("SID-page"), "Runtime.evaluate", json!({ + "expression":"globalThis.workerReady = false; globalThis.worker = new Worker('/worker.js'); worker.onmessage = () => {workerReady = true;}; 'started'", + "returnByValue":true + })).await; + tokio::time::timeout(Duration::from_secs(5), requested.notified()) + .await + .unwrap(); + wait_until_message( + &mut ctx, + None, + "loading DedicatedWorker target", + |message| { + message["method"] == "Target.targetCreated" + && message["params"]["targetInfo"]["type"] == "worker" + && message["params"]["targetInfo"]["openerId"] == "TID-page" + }, + ) + .await; + let target = ctx + .sent + .iter() + .find(|message| { + message["method"] == "Target.targetCreated" + && message["params"]["targetInfo"]["type"] == "worker" + && message["params"]["targetInfo"]["openerId"] == "TID-page" + }) + .unwrap()["params"]["targetInfo"]["targetId"] + .as_str() + .unwrap() + .to_owned(); + let original_session = command( + &mut ctx, + 80103, + None, + "Target.attachToTarget", + json!({"targetId":target,"flatten":true}), + ) + .await["sessionId"] + .as_str() + .unwrap() + .to_owned(); + let session = if detach_first { + command( + &mut ctx, + 80104, + None, + "Target.detachFromTarget", + json!({"sessionId":original_session}), + ) + .await; + command( + &mut ctx, + 80105, + None, + "Target.attachToTarget", + json!({"targetId":target,"flatten":true}), + ) + .await["sessionId"] + .as_str() + .unwrap() + .to_owned() + } else { + original_session.clone() + }; + release.notify_one(); + for index in 0..256 { + let value = command( + &mut ctx, + 80200 + index, + Some("SID-page"), + "Runtime.evaluate", + json!({"expression":"workerReady","returnByValue":true}), + ) + .await; + if value["result"]["value"] == true { + break; + } + assert!(index < 255, "worker script did not run"); + tokio::time::sleep(Duration::from_millis(10)).await; + } + if detach_first { + let (runtime, instance) = ctx.with_fixture(|conn| { + let context = conn.browser_context.as_ref().unwrap(); + ( + context.renderer_runtime(), + context + .dedicated_worker_target(&target) + .unwrap() + .renderer_instance_id, + ) + }); + let late = runtime + .dispatch_dedicated_worker_runtime_protocol_message( + instance, + Some(original_session), + json!({"id":1,"method":"Runtime.enable"}).to_string(), + ) + .await; + assert!( + late.is_err(), + "detached early session must not be installed in the live renderer: {late:?}" + ); + } + ctx.sent.clear(); + command(&mut ctx, 81000, Some(&session), "Runtime.enable", json!({})).await; + wait_until_message( + &mut ctx, + Some(session.as_str()), + "early attachment execution context", + |message| { + message["method"] == "Runtime.executionContextCreated" + && message["sessionId"] == session + }, + ) + .await; + let value = command( + &mut ctx, + 81001, + Some(&session), + "Runtime.evaluate", + json!({"expression":"attachmentProbe","returnByValue":true}), + ) + .await; + assert_eq!(value["result"]["value"], 42); + server.abort(); +} diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime.rs b/moli-renderer-v8/src/runtime/browser_context_runtime.rs index e158729f58e..74e4bdef79d 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime.rs @@ -215,9 +215,14 @@ struct RendererBrowserContextRuntimeInner { } #[derive(Clone, Debug)] -struct DedicatedWorkerDevToolsTarget { - handle: crate::worker::WorkerDevToolsHandle, - output_journal: Option, +enum DedicatedWorkerDevToolsTarget { + Loading { + inspector_sessions: Vec>, + }, + Running { + handle: crate::worker::WorkerDevToolsHandle, + output_journal: Option, + }, } #[derive(Debug)] @@ -353,7 +358,9 @@ fn terminate_browser_context_resource_producers(inner: &RendererBrowserContextRu let dedicated_worker_targets = std::mem::take(&mut *inner.dedicated_worker_devtools_targets.lock()); for target in dedicated_worker_targets.into_values() { - let _ = target.handle.terminate_for_devtools(); + if let DedicatedWorkerDevToolsTarget::Running { handle, .. } = target { + let _ = handle.terminate_for_devtools(); + } } if let Some(shared_worker_runtime) = inner.shared_worker_runtime.get() { shared_worker_runtime.terminate_all_for_context_shutdown(); diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs index d7cdfa3bf63..f8ae8d0aa6d 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs @@ -12,10 +12,18 @@ impl RendererBrowserContextRuntime { /// lifetime. The JavaScript-facing worker id is Page-local and therefore /// cannot safely key protocol targets after Page replacement. pub(crate) fn allocate_dedicated_worker_instance_id(&self) -> u64 { - self.inner + let instance_id = self + .inner .next_dedicated_worker_instance_id .fetch_add(1, std::sync::atomic::Ordering::Relaxed) - .saturating_add(1) + .saturating_add(1); + self.inner.dedicated_worker_devtools_targets.lock().insert( + instance_id, + DedicatedWorkerDevToolsTarget::Loading { + inspector_sessions: Vec::new(), + }, + ); + instance_id } pub(crate) fn attach_dedicated_worker_devtools_handle( @@ -24,13 +32,23 @@ impl RendererBrowserContextRuntime { handle: &WorkerHandle, output_journal: Option, ) { - self.inner.dedicated_worker_devtools_targets.lock().insert( - instance_id, - DedicatedWorkerDevToolsTarget { - handle: handle.devtools_handle(), - output_journal, - }, - ); + let mut targets = self.inner.dedicated_worker_devtools_targets.lock(); + let Some(target) = targets.get_mut(&instance_id) else { + return; + }; + let DedicatedWorkerDevToolsTarget::Loading { inspector_sessions } = target else { + return; + }; + let handle = handle.devtools_handle(); + // Keep attachment updates and handle publication under one lock. A + // concurrent detach must either remove a pending id or retire its token. + for session in inspector_sessions.drain(..) { + let _ = handle.attach_runtime_inspector_session(session); + } + *target = DedicatedWorkerDevToolsTarget::Running { + handle, + output_journal, + }; } pub(crate) fn unregister_dedicated_worker_devtools_handle(&self, instance_id: u64) { @@ -57,7 +75,10 @@ impl RendererBrowserContextRuntime { .dedicated_worker_devtools_targets .lock() .get(&instance_id) - .map(|target| target.handle.clone()) + .and_then(|target| match target { + DedicatedWorkerDevToolsTarget::Running { handle, .. } => Some(handle.clone()), + DedicatedWorkerDevToolsTarget::Loading { .. } => None, + }) } fn dedicated_worker_devtools_target( @@ -109,10 +130,14 @@ impl RendererBrowserContextRuntime { raw_json: String, response: RendererRuntimeInspectorResponseSender, ) -> Result { - let Some(target) = self.dedicated_worker_devtools_target(instance_id) else { + let Some(DedicatedWorkerDevToolsTarget::Running { + handle, + output_journal, + }) = self.dedicated_worker_devtools_target(instance_id) + else { return Err(WorkerInspectorError::DedicatedUnavailable.into()); }; - let Some(output_journal) = target.output_journal else { + let Some(output_journal) = output_journal else { return Err(WorkerInspectorError::DedicatedUnavailable.into()); }; let response = response @@ -122,7 +147,7 @@ impl RendererBrowserContextRuntime { .take_session_response_settlement_receiver() .expect("a Worker DevTools response must own one settlement receiver"); let (response_tx, response_rx) = oneshot::channel(); - let dispatched = target.handle.dispatch_runtime_protocol_message( + let dispatched = handle.dispatch_runtime_protocol_message( Some(inspector_session_id), raw_json, Some(response), @@ -173,8 +198,19 @@ impl RendererBrowserContextRuntime { instance_id: u64, inspector_session_id: Option, ) -> bool { - self.dedicated_worker_devtools_handle(instance_id) - .is_some_and(|handle| handle.attach_runtime_inspector_session(inspector_session_id)) + let mut targets = self.inner.dedicated_worker_devtools_targets.lock(); + match targets.get_mut(&instance_id) { + Some(DedicatedWorkerDevToolsTarget::Loading { inspector_sessions }) => { + if !inspector_sessions.contains(&inspector_session_id) { + inspector_sessions.push(inspector_session_id); + } + true + } + Some(DedicatedWorkerDevToolsTarget::Running { handle, .. }) => { + handle.attach_runtime_inspector_session(inspector_session_id) + } + None => false, + } } pub fn detach_dedicated_worker_runtime_inspector_session( @@ -182,8 +218,18 @@ impl RendererBrowserContextRuntime { instance_id: u64, inspector_session_id: Option, ) -> Option>> { - self.dedicated_worker_devtools_handle(instance_id) - .map(|handle| handle.detach_runtime_inspector_session(inspector_session_id)) + let mut targets = self.inner.dedicated_worker_devtools_targets.lock(); + match targets.get_mut(&instance_id)? { + DedicatedWorkerDevToolsTarget::Loading { inspector_sessions } => { + inspector_sessions.retain(|session| session != &inspector_session_id); + let (tx, rx) = oneshot::channel(); + let _ = tx.send(Ok(())); + Some(rx) + } + DedicatedWorkerDevToolsTarget::Running { handle, .. } => { + Some(handle.detach_runtime_inspector_session(inspector_session_id)) + } + } } pub fn run_dedicated_worker_if_waiting_for_debugger_for_devtools( @@ -199,3 +245,54 @@ impl RendererBrowserContextRuntime { .is_some_and(|handle| handle.terminate_for_devtools()) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn loading_worker_retirement_removes_pending_inspector_attachments() { + let runtime = RendererBrowserContextRuntime::new(); + let instance = runtime.allocate_dedicated_worker_instance_id(); + assert!( + runtime.attach_dedicated_worker_runtime_inspector_session( + instance, + Some("retired".into()) + ) + ); + assert!( + runtime + .attach_dedicated_worker_runtime_inspector_session(instance, Some("live".into())) + ); + assert!( + runtime + .attach_dedicated_worker_runtime_inspector_session(instance, Some("live".into())) + ); + runtime + .detach_dedicated_worker_runtime_inspector_session(instance, Some("retired".into())) + .unwrap() + .await + .unwrap() + .unwrap(); + { + let targets = runtime.inner.dedicated_worker_devtools_targets.lock(); + let DedicatedWorkerDevToolsTarget::Loading { inspector_sessions } = &targets[&instance] + else { + panic!("worker is still loading"); + }; + assert_eq!(inspector_sessions, &[Some("live".into())]); + } + runtime.unregister_dedicated_worker_devtools_handle(instance); + assert!( + !runtime + .attach_dedicated_worker_runtime_inspector_session(instance, Some("late".into())) + ); + assert!( + runtime + .inner + .dedicated_worker_devtools_targets + .lock() + .is_empty() + ); + } +} diff --git a/moli-renderer-v8/src/worker/inspector_task_runner.rs b/moli-renderer-v8/src/worker/inspector_task_runner.rs index e6e45649a8d..db87d1f9de7 100644 --- a/moli-renderer-v8/src/worker/inspector_task_runner.rs +++ b/moli-renderer-v8/src/worker/inspector_task_runner.rs @@ -271,12 +271,7 @@ impl WorkerInspectorTaskRunner { state: Mutex::new(WorkerInspectorTaskRunnerState { interrupting_tasks: VecDeque::new(), dont_interrupting_tasks: VecDeque::new(), - // Only the implicit primary session exists without attach. - // Named sessions must not be recreated by late dispatch. - sessions: HashMap::from([( - String::new(), - WorkerInspectorSessionLifetime::new(), - )]), + sessions: HashMap::new(), disposed: false, isolate_ready: false, pause_loop_active: false, @@ -392,10 +387,19 @@ impl WorkerInspectorTaskRunner { &self, id: Option<&str>, ) -> Result { - let state = self.shared.state.lock(); + let mut state = self.shared.state.lock(); if state.disposed { return Err(WorkerInspectorError::Disposed); } + // Only the implicit primary session may be created by first use. + // A late named command cannot attach itself or revive a retired id. + if id.is_none() { + return Ok(state + .sessions + .entry(String::new()) + .or_insert_with(WorkerInspectorSessionLifetime::new) + .clone()); + } state .sessions .get(id.unwrap_or_default()) @@ -1045,6 +1049,34 @@ mod tests { retired.try_recv().unwrap().unwrap(); } + #[test] + fn primary_session_is_lazy_and_can_be_recreated_after_retirement() { + let (wake_tx, _wake_rx) = mpsc::unbounded_channel(); + let runner = WorkerInspectorTaskRunner::new(wake_tx, Arc::new(Mutex::new(None))); + assert_eq!(runner.session_count(), 0); + assert!(matches!( + runner.session_lifetime(Some("unknown")), + Err(WorkerInspectorError::Detached) + )); + assert_eq!(runner.session_count(), 0); + let primary = runner.session_lifetime(None).unwrap(); + assert_eq!(runner.session_count(), 1); + assert!(runner.session_lifetime(None).unwrap().matches(&primary)); + runner.retire_lifetime(None).unwrap(); + runner.complete_retirement(None, &primary); + assert_eq!(runner.session_count(), 0); + let replacement = runner.session_lifetime(None).unwrap(); + assert!(replacement.is_active()); + assert!(!replacement.matches(&primary)); + assert!(!primary.is_active()); + runner.dispose(WorkerInspectorError::Closed); + assert!(matches!( + runner.session_lifetime(None), + Err(WorkerInspectorError::Disposed) + )); + assert_eq!(runner.session_count(), 0); + } + #[test] fn retirement_preserves_queued_tokens_and_rejects_late_dispatch_without_retaining_ids() { let (runner, _wake_rx) = runner();