fix(workers): preserve Inspector attachments while scripts load

This commit is contained in:
ldm0
2026-11-15 05:18:19 +08:00
committed by Donough Liu
parent 782540c5ca
commit 248ac028ca
5 changed files with 379 additions and 28 deletions
@@ -221,3 +221,4 @@ mod service_worker;
mod shared_worker;
mod worker_emulation;
mod worker_loading_attachment;
@@ -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")],
"<!doctype html><title>worker attachment</title>",
)
}),
)
.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();
}
@@ -215,9 +215,14 @@ struct RendererBrowserContextRuntimeInner {
}
#[derive(Clone, Debug)]
struct DedicatedWorkerDevToolsTarget {
handle: crate::worker::WorkerDevToolsHandle,
output_journal: Option<super::RendererTurnOutputJournal>,
enum DedicatedWorkerDevToolsTarget {
Loading {
inspector_sessions: Vec<Option<String>>,
},
Running {
handle: crate::worker::WorkerDevToolsHandle,
output_journal: Option<super::RendererTurnOutputJournal>,
},
}
#[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();
@@ -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<crate::runtime::RendererTurnOutputJournal>,
) {
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<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch> {
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<String>,
) -> 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<String>,
) -> Option<tokio::sync::oneshot::Receiver<anyhow::Result<()>>> {
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()
);
}
}
@@ -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<WorkerInspectorSessionLifetime, WorkerInspectorError> {
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();