mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 08:02:23 +00:00
fix(workers): preserve Inspector attachments while scripts load
This commit is contained in:
@@ -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();
|
||||
|
||||
Reference in New Issue
Block a user