mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 16:02:34 +00:00
fix(service-workers): allow Clients queries during startup
Let an associated worker query its registration during evaluation, installation, and pending unregistration. Deliver same-run query replies to its published Starting host while keeping default MatchAll restricted to the exact active controller version. Cover lifecycle transitions, waiting-worker isolation, mismatched registrations, and real worker startup promises with stale-run replies.
This commit is contained in:
@@ -819,7 +819,11 @@ fn service_worker_get_client_locked(
|
||||
if !service_worker_registration_can_see_client(registration, client) {
|
||||
return None;
|
||||
}
|
||||
Some(service_worker_client_snapshot(registration, client))
|
||||
Some(service_worker_client_snapshot_with_controlled(
|
||||
client,
|
||||
registration.active_version_id == Some(version_id)
|
||||
&& registration.controlled_client_ids.contains(&client.id),
|
||||
))
|
||||
}
|
||||
|
||||
fn service_worker_match_all_clients_locked(
|
||||
@@ -839,6 +843,7 @@ fn service_worker_match_all_clients_locked(
|
||||
.filter_map(|client| {
|
||||
service_worker_client_visible_to_query(
|
||||
registration,
|
||||
version_id,
|
||||
client.id,
|
||||
client,
|
||||
options.include_uncontrolled,
|
||||
@@ -856,24 +861,17 @@ fn service_worker_query_registration_locked(
|
||||
version_id: ServiceWorkerVersionId,
|
||||
) -> Option<&ServiceWorkerRegistration> {
|
||||
let version = state.versions.get(&version_id)?;
|
||||
if version.registration_id != registration_id
|
||||
|| !matches!(
|
||||
version.lifecycle_state,
|
||||
ServiceWorkerVersionLifecycleState::Activating
|
||||
| ServiceWorkerVersionLifecycleState::Activated
|
||||
)
|
||||
{
|
||||
if version.registration_id != registration_id {
|
||||
return None;
|
||||
}
|
||||
let registration = state.registrations.get(®istration_id)?;
|
||||
if registration.pending_unregistration || registration.active_version_id != Some(version_id) {
|
||||
return None;
|
||||
}
|
||||
Some(registration)
|
||||
// Clients queries are also available during evaluation and installation,
|
||||
// and while a live worker's registration is being unregistered.
|
||||
state.registrations.get(®istration_id)
|
||||
}
|
||||
|
||||
fn service_worker_client_visible_to_query(
|
||||
registration: &ServiceWorkerRegistration,
|
||||
version_id: ServiceWorkerVersionId,
|
||||
client_id: ServiceWorkerClientId,
|
||||
client: &ServiceWorkerClient,
|
||||
include_uncontrolled: bool,
|
||||
@@ -890,7 +888,8 @@ fn service_worker_client_visible_to_query(
|
||||
if !service_worker_client_is_exposed_to_clients_api(client) || !client.secure_context {
|
||||
return None;
|
||||
}
|
||||
let controlled = registration.controlled_client_ids.contains(&client_id);
|
||||
let controlled = registration.active_version_id == Some(version_id)
|
||||
&& registration.controlled_client_ids.contains(&client_id);
|
||||
if !include_uncontrolled && !controlled {
|
||||
return None;
|
||||
}
|
||||
|
||||
@@ -111,10 +111,12 @@ impl ServiceWorkerRuntimeService {
|
||||
if version.run != run {
|
||||
return;
|
||||
}
|
||||
// Evaluation can query Clients before bootstrap completion marks
|
||||
// the version Running. Its host already has the worker handle.
|
||||
match &version.running_state {
|
||||
ServiceWorkerVersionRunningState::Running { host } => Some(host.clone()),
|
||||
ServiceWorkerVersionRunningState::Starting { .. }
|
||||
| ServiceWorkerVersionRunningState::Stopped => None,
|
||||
ServiceWorkerVersionRunningState::Starting { host }
|
||||
| ServiceWorkerVersionRunningState::Running { host } => Some(host.clone()),
|
||||
ServiceWorkerVersionRunningState::Stopped => None,
|
||||
}
|
||||
};
|
||||
if let Some(host) = host {
|
||||
|
||||
@@ -1195,20 +1195,15 @@ fn client_query_matches_live_window_clients_for_active_version() {
|
||||
});
|
||||
assert!(hidden_cross_origin.clients.is_empty());
|
||||
|
||||
{
|
||||
let mut state = service.inner.state.lock();
|
||||
state.versions.get_mut(&version_id).unwrap().lifecycle_state =
|
||||
ServiceWorkerVersionLifecycleState::Installed;
|
||||
}
|
||||
let inactive_result = service.query_clients(&ServiceWorkerClientQuery {
|
||||
let mismatched_registration = service.query_clients(&ServiceWorkerClientQuery {
|
||||
request_id: 15,
|
||||
registration_id,
|
||||
registration_id: ServiceWorkerRegistrationId(2),
|
||||
version_id,
|
||||
kind: ServiceWorkerClientQueryKind::Get {
|
||||
exposed_client_id: service_worker_exposed_client_id(controlled_client_id),
|
||||
},
|
||||
});
|
||||
assert!(inactive_result.clients.is_empty());
|
||||
assert!(mismatched_registration.clients.is_empty());
|
||||
}
|
||||
#[test]
|
||||
fn client_match_all_visibility_uses_storage_partition_and_security_instead_of_scope() {
|
||||
@@ -1632,6 +1627,33 @@ fn client_query_requires_exact_active_controller_version() {
|
||||
});
|
||||
assert!(waiting_worker_clients.clients.is_empty());
|
||||
|
||||
let waiting_worker_all_clients = service.query_clients(&ServiceWorkerClientQuery {
|
||||
request_id: 28,
|
||||
registration_id,
|
||||
version_id: waiting_version_id,
|
||||
kind: ServiceWorkerClientQueryKind::MatchAll {
|
||||
options: ServiceWorkerClientQueryOptions {
|
||||
include_uncontrolled: true,
|
||||
client_type: ServiceWorkerClientQueryType::Window,
|
||||
},
|
||||
},
|
||||
});
|
||||
assert_eq!(waiting_worker_all_clients.clients.len(), 1);
|
||||
assert_eq!(waiting_worker_all_clients.clients[0].id, client_id);
|
||||
assert!(!waiting_worker_all_clients.clients[0].controlled);
|
||||
|
||||
let waiting_worker_get = service.query_clients(&ServiceWorkerClientQuery {
|
||||
request_id: 29,
|
||||
registration_id,
|
||||
version_id: waiting_version_id,
|
||||
kind: ServiceWorkerClientQueryKind::Get {
|
||||
exposed_client_id: service_worker_exposed_client_id(client_id),
|
||||
},
|
||||
});
|
||||
assert_eq!(waiting_worker_get.clients.len(), 1);
|
||||
assert_eq!(waiting_worker_get.clients[0].id, client_id);
|
||||
assert!(!waiting_worker_get.clients[0].controlled);
|
||||
|
||||
let active_worker_clients = service.query_clients(&ServiceWorkerClientQuery {
|
||||
request_id: 27,
|
||||
registration_id,
|
||||
@@ -1652,6 +1674,205 @@ fn client_query_requires_exact_active_controller_version() {
|
||||
vec![client_id]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn client_queries_remain_available_across_lifecycle_and_unregistration() {
|
||||
for lifecycle in [
|
||||
ServiceWorkerVersionLifecycleState::Installing,
|
||||
ServiceWorkerVersionLifecycleState::Installed,
|
||||
ServiceWorkerVersionLifecycleState::Activating,
|
||||
ServiceWorkerVersionLifecycleState::Activated,
|
||||
ServiceWorkerVersionLifecycleState::Redundant,
|
||||
] {
|
||||
for pending_unregistration in [false, true] {
|
||||
let service = new_service_worker_runtime_service();
|
||||
let registration_id = ServiceWorkerRegistrationId(1);
|
||||
let version_id = ServiceWorkerVersionId(1);
|
||||
insert_registered_version(
|
||||
&service,
|
||||
registration_id,
|
||||
version_id,
|
||||
url("https://example.test/app/sw.js"),
|
||||
url("https://example.test/app/"),
|
||||
[],
|
||||
);
|
||||
let client_id =
|
||||
register_client_for_test(&service, url("https://example.test/app/page.html"));
|
||||
let outside_client_id =
|
||||
register_client_for_test(&service, url("https://example.test/outside.html"));
|
||||
register_client_for_test(&service, url("https://other.test/app/page.html"));
|
||||
let is_active = matches!(
|
||||
lifecycle,
|
||||
ServiceWorkerVersionLifecycleState::Activating
|
||||
| ServiceWorkerVersionLifecycleState::Activated
|
||||
);
|
||||
{
|
||||
let mut state = service.inner.state.lock();
|
||||
let registration = state.registrations.get_mut(®istration_id).unwrap();
|
||||
registration.installing_version_id = (lifecycle
|
||||
== ServiceWorkerVersionLifecycleState::Installing)
|
||||
.then_some(version_id);
|
||||
registration.waiting_version_id = (lifecycle
|
||||
== ServiceWorkerVersionLifecycleState::Installed)
|
||||
.then_some(version_id);
|
||||
registration.active_version_id = is_active.then_some(version_id);
|
||||
if !is_active {
|
||||
registration.controlled_client_ids.clear();
|
||||
}
|
||||
registration.pending_unregistration = pending_unregistration;
|
||||
state.versions.get_mut(&version_id).unwrap().lifecycle_state = lifecycle;
|
||||
}
|
||||
|
||||
for include_uncontrolled in [false, true] {
|
||||
let result = service.query_clients(&ServiceWorkerClientQuery {
|
||||
request_id: 1,
|
||||
registration_id,
|
||||
version_id,
|
||||
kind: ServiceWorkerClientQueryKind::MatchAll {
|
||||
options: ServiceWorkerClientQueryOptions {
|
||||
include_uncontrolled,
|
||||
client_type: ServiceWorkerClientQueryType::Window,
|
||||
},
|
||||
},
|
||||
});
|
||||
let expected = if include_uncontrolled {
|
||||
vec![client_id, outside_client_id]
|
||||
} else if is_active {
|
||||
vec![client_id]
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
assert_eq!(
|
||||
result
|
||||
.clients
|
||||
.iter()
|
||||
.map(|client| client.id)
|
||||
.collect::<Vec<_>>(),
|
||||
expected,
|
||||
"{lifecycle:?}, pending unregistration: {pending_unregistration}"
|
||||
);
|
||||
}
|
||||
for target in [client_id, outside_client_id] {
|
||||
let result = service.query_clients(&ServiceWorkerClientQuery {
|
||||
request_id: 2,
|
||||
registration_id,
|
||||
version_id,
|
||||
kind: ServiceWorkerClientQueryKind::Get {
|
||||
exposed_client_id: service_worker_exposed_client_id(target),
|
||||
},
|
||||
});
|
||||
assert_eq!(result.clients.len(), 1, "{lifecycle:?}");
|
||||
assert_eq!(result.clients[0].id, target);
|
||||
assert_eq!(
|
||||
result.clients[0].controlled,
|
||||
is_active && target == client_id
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn client_query_replies_during_startup_reject_stale_runs() {
|
||||
ensure_v8_for_test();
|
||||
let service = new_service_worker_runtime_service();
|
||||
let registration_id = ServiceWorkerRegistrationId(1);
|
||||
let version_id = ServiceWorkerVersionId(1);
|
||||
let script_url = url("https://example.test/app/sw.js");
|
||||
let scope_url = url("https://example.test/app/");
|
||||
let client_id = register_client_for_test(&service, url("https://example.test/outside.html"));
|
||||
let exposed_id = serde_json::to_string(&service_worker_exposed_client_id(client_id)).unwrap();
|
||||
let source = format!(
|
||||
r#"
|
||||
const expectedId = {exposed_id};
|
||||
Promise.all([
|
||||
clients.matchAll({{includeUncontrolled: true}}),
|
||||
clients.get(expectedId)
|
||||
]).then(([all, one]) => {{
|
||||
if (all.length !== 1 || all[0].id !== expectedId || one?.id !== expectedId) {{
|
||||
throw new Error("startup query returned incorrect clients");
|
||||
}}
|
||||
all[0].postMessage("queried during startup");
|
||||
}});
|
||||
"#
|
||||
);
|
||||
let (bootstrap_tx, mut bootstrap_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let mut handle = crate::worker::spawn_worker_with_options(
|
||||
crate::worker::WorkerSpawnOptions::new_with_request_client(
|
||||
source,
|
||||
script_url.to_string(),
|
||||
service.request_client(),
|
||||
)
|
||||
.with_global_kind(crate::worker::WorkerGlobalKind::Service {
|
||||
registration_id,
|
||||
version_id,
|
||||
scope_url: scope_url.clone(),
|
||||
})
|
||||
.with_bootstrap_completion_sender(bootstrap_tx),
|
||||
);
|
||||
let mut parent_rx = handle.take_receiver().expect("worker receiver");
|
||||
let run = RendererServiceWorkerRunIdentity::fresh();
|
||||
let host = new_running_test_host_with_handle(version_id, &run, handle);
|
||||
insert_registered_version(
|
||||
&service,
|
||||
registration_id,
|
||||
version_id,
|
||||
script_url,
|
||||
scope_url,
|
||||
[],
|
||||
);
|
||||
{
|
||||
let mut state = service.inner.state.lock();
|
||||
let registration = state.registrations.get_mut(®istration_id).unwrap();
|
||||
registration.active_version_id = None;
|
||||
registration.installing_version_id = Some(version_id);
|
||||
let version = state.versions.get_mut(&version_id).unwrap();
|
||||
version.lifecycle_state = ServiceWorkerVersionLifecycleState::Installing;
|
||||
version.running_state = ServiceWorkerVersionRunningState::Starting { host };
|
||||
version.run = run.clone();
|
||||
}
|
||||
|
||||
// Keep bootstrap completion queued, as can happen when evaluation requests
|
||||
// reach the service lane before its worker-start completion.
|
||||
for _ in 0..2 {
|
||||
let message = tokio::time::timeout(Duration::from_secs(5), parent_rx.recv())
|
||||
.await
|
||||
.expect("top-level query should arrive")
|
||||
.expect("worker channel should stay open");
|
||||
let crate::worker::WorkerToParentMessage::ServiceWorkerClientQuery(query) = message else {
|
||||
panic!("expected top-level Clients query, got {message:?}");
|
||||
};
|
||||
service.finish_client_query(
|
||||
version_id,
|
||||
RendererServiceWorkerRunIdentity::fresh(),
|
||||
ServiceWorkerClientQueryResult {
|
||||
request_id: query.request_id,
|
||||
clients: vec![],
|
||||
},
|
||||
);
|
||||
service.finish_client_query_requested(query, run.clone());
|
||||
}
|
||||
let message = tokio::time::timeout(Duration::from_secs(5), parent_rx.recv())
|
||||
.await
|
||||
.expect("both startup query promises should resolve")
|
||||
.expect("worker channel should stay open");
|
||||
let crate::worker::WorkerToParentMessage::ServiceWorkerClientMessage(message) = message else {
|
||||
panic!("expected queried client message, got {message:?}");
|
||||
};
|
||||
assert_eq!(message.target_client_id, client_id);
|
||||
assert_eq!(message.source_version_id, version_id);
|
||||
let bootstrap = tokio::time::timeout(Duration::from_secs(5), bootstrap_rx.recv())
|
||||
.await
|
||||
.expect("bootstrap completion should arrive")
|
||||
.expect("bootstrap channel should stay open");
|
||||
bootstrap.result.expect("bootstrap should succeed");
|
||||
assert!(matches!(
|
||||
service.inner.state.lock().versions[&version_id].running_state,
|
||||
ServiceWorkerVersionRunningState::Starting { .. }
|
||||
));
|
||||
service.terminate_all_for_context_shutdown();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn client_document_update_tracks_creation_url_and_regenerates_cross_origin_exposed_id() {
|
||||
let service = new_service_worker_runtime_service();
|
||||
|
||||
Reference in New Issue
Block a user