diff --git a/moli-core/tests/scripts.rs b/moli-core/tests/scripts.rs index dd830a91222..45fb6f144e3 100644 --- a/moli-core/tests/scripts.rs +++ b/moli-core/tests/scripts.rs @@ -6,6 +6,8 @@ mod font_loading; mod integrity; #[path = "scripts/nested_worker_retirement.rs"] mod nested_worker_retirement; +#[path = "scripts/worker_event_source.rs"] +mod worker_event_source; #[path = "scripts/worker_fetch_metadata.rs"] mod worker_fetch_metadata; #[path = "scripts/worker_resource_timing.rs"] diff --git a/moli-core/tests/scripts/worker_event_source.rs b/moli-core/tests/scripts/worker_event_source.rs new file mode 100644 index 00000000000..64c1bc38ba4 --- /dev/null +++ b/moli-core/tests/scripts/worker_event_source.rs @@ -0,0 +1,513 @@ +use super::*; +use parking_lot::Mutex; +use std::sync::Arc; +use tokio::{ + io::{AsyncReadExt, AsyncWriteExt}, + net::TcpListener, + task::{JoinHandle, JoinSet}, +}; + +const WORKER: &str = r#" +async function run(config, send) { + try { + const check = (value, label) => { if (!value) throw new Error(label); }; + const url = config.url; + const scenario = config.scenario; + if (scenario === 'after-close') { + close(); + const source = new EventSource(url); + check(source.readyState === EventSource.CONNECTING, 'closing Worker discards tasks without changing initial EventSource state'); + send({ok:true}); return; + } + if (scenario === 'constructor') { + let missing = false, invalid = false, reads = 0; + try { new EventSource(); } catch (e) { missing = e instanceof TypeError; } + try { new EventSource('http://['); } catch (e) { invalid = e.name === 'SyntaxError'; } + const source = new EventSource(url, {get withCredentials() { reads++; return true; }}); + check(missing && invalid && reads === 1, 'constructor conversion/errors'); + check(source.url === url && source.withCredentials && source.readyState === 0, 'initial attributes'); + check(source instanceof EventTarget && EventSource.CONNECTING === 0 && + EventSource.OPEN === 1 && EventSource.CLOSED === 2, 'interface/constants'); + source.close(); source.close(); + check(source.readyState === 2, 'idempotent immediate close'); + send({ok:true}); return; + } + // Browser algorithms must not call author replacements of timers. + const cancelAuthorTimeout = globalThis.clearTimeout; + globalThis.setTimeout = globalThis.clearTimeout = () => { throw new Error('author timer called'); }; + const source = new EventSource(url, {withCredentials:!!config.credentials}); + for (let id = 0; id < 16; id++) cancelAuthorTimeout(id); + if (scenario === 'report-close') { + addEventListener('securitypolicyviolation', event => { + try { + check(event.disposition === 'report' && event.effectiveDirective === 'connect-src', 'report-only violation'); + source.close(); + check(source.readyState === 2, 'closed by policy callback'); + send({ok:true}); + } catch (error) { send({error:String(error)}); } + }, {once:true}); + return; + } + if (scenario === 'close-before') { + source.close(); + check(source.readyState === 2, 'close before connection'); + send({ok:true}); return; + } + const result = await new Promise((resolve, reject) => { + let opens = 0, errors = 0, messages = [], checkpoint = false; + source.onopen = event => { + try { + check(event.isTrusted && source.readyState === 1, 'open event/state'); + opens++; + } catch (error) { source.close(); reject(error); } + }; + source.onerror = event => { + try { + check(event.isTrusted && !('data' in event), 'error event shape'); + errors++; + if (scenario === 'reject') { + check(source.readyState === 2 && opens === 0 && messages.length === 0, 'fatal response/policy failure'); + resolve({ok:true}); + } else if (scenario !== 'reconnect') { + source.close(); reject(new Error('unexpected EventSource error')); + } else { + check(source.readyState === 0, 'reconnecting state'); + } + } catch (error) { source.close(); reject(error); } + }; + const receive = event => { + try { + check(event.isTrusted && event.source === null && event.ports.length === 0, 'message shape'); + check(event.origin === new URL(url).origin && source.readyState === 1, 'message origin/state'); + messages.push([event.type, event.data, event.lastEventId]); + if (scenario === 'stream') { + if (messages.length === 1) { queueMicrotask(() => checkpoint = true); return; } + check(checkpoint, 'separate SSE networking tasks need a microtask checkpoint'); + check(JSON.stringify(messages) === JSON.stringify([['message','hello 世界','42'],['special','line1\nline2','43']]), 'SSE decoding/type/id'); + } else if (scenario === 'reconnect') { + if (messages.length !== 2) return; + check(messages[0][1] === 'first' && messages[1][1] === 'second' && + messages[1][2] === '43' && opens === 2 && errors === 1, 'reconnect sequence'); + } else if (scenario === 'hold') { + resolve({ok:true, open:true}); return; + } else if (scenario === 'close-messages') { + check(messages.length === 1 && event.data === 'first', 'closed source delivered queued event'); + } else { + check(event.data === 'allowed', 'CORS allowed payload'); + } + source.close(); + check(source.readyState === 2, 'closed state'); + resolve({ok:true, messages:messages.length}); + } catch (error) { source.close(); reject(error); } + }; + source.onmessage = receive; + source.addEventListener('special', receive); + }); + send(result); + } catch (error) { send({error:String(error)}); } +} +if ('onconnect' in globalThis) { + onconnect = event => { + const port = event.ports[0]; + port.onmessage = event => run(event.data, value => port.postMessage(value)); + port.start(); + }; +} else { + onmessage = event => run(event.data, value => postMessage(value)); +} +"#; + +struct EventSourceWorkerServer { + origin: String, + requests: Arc>>, + task: JoinHandle<()>, + disconnected: Arc, +} + +impl Drop for EventSourceWorkerServer { + fn drop(&mut self) { + self.task.abort(); + } +} + +impl EventSourceWorkerServer { + async fn spawn() -> Result { + let listener = TcpListener::bind("127.0.0.1:0").await?; + let origin = format!("http://{}", listener.local_addr()?); + let requests = Arc::new(Mutex::new(Vec::::new())); + let recorded = Arc::clone(&requests); + let disconnected = Arc::new(tokio::sync::Notify::new()); + let closed = Arc::clone(&disconnected); + let task = tokio::spawn(async move { + let mut connections = JoinSet::new(); + loop { + tokio::select! { + accepted = listener.accept() => { + let Ok((mut stream, _)) = accepted else { break }; + let recorded = Arc::clone(&recorded); + let closed = Arc::clone(&closed); + connections.spawn(async move { + let mut bytes = Vec::new(); + while !bytes.ends_with(b"\r\n\r\n") && bytes.len() < 16384 { + let Ok(byte) = stream.read_u8().await else { return }; + bytes.push(byte); + } + let request = String::from_utf8_lossy(&bytes); + let path = request.split_whitespace().nth(1).unwrap_or("/"); + let header = |name: &str| request.lines().filter_map(|line| line.split_once(':')) + .find(|(key, _)| key.eq_ignore_ascii_case(name)).map(|(_, value)| value.trim()); + let sequence = { + let mut requests = recorded.lock(); + let sequence = requests.iter().filter(|r| r["path"] == path).count(); + requests.push(serde_json::json!({"path":path,"accept":header("Accept"), + "lastEventId":header("Last-Event-ID"),"origin":header("Origin"),"method":request.split_whitespace().next()})); + sequence + }; + if path.starts_with("/hold") { + let _ = stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\nf\r\ndata: allowed\n\n\r\n").await; + let _ = stream.read_u8().await; + closed.notify_one(); + return; + } + let (status, mime, body) = if path.starts_with("/page") { + ("200 OK", "text/html", "Worker EventSource") + } else if path.starts_with("/sw.js") { + ("200 OK", "text/javascript", "oninstall = event => event.waitUntil(skipWaiting()); onactivate = event => event.waitUntil(clients.claim()); onfetch = event => { if (new URL(event.request.url).pathname === '/sw-events') event.respondWith(new Response('data: allowed\\n\\n', {headers:{'Content-Type':'text/event-stream'}})); };") + } else if path.starts_with("/worker.js") { + ("200 OK", "text/javascript", WORKER) + } else if path.starts_with("/no-content") { + ("204 No Content", "text/event-stream", "") + } else if path.starts_with("/wrong-mime") { + ("200 OK", "text/plain", "data: forbidden\n\n") + } else if path.starts_with("/reconnect") { + ("200 OK", "text/event-stream", if sequence == 0 { + if path.starts_with("/reconnect-unicode") { "retry: 0\nid: 雪\ndata: first\n\n" } else { "retry: 0\nid: 42\ndata: first\n\n" } + } else { "id: 43\ndata: second\n\n" }) + } else if path.starts_with("/stream") { + ("200 OK", "text/event-stream", "\u{feff}id: 42\r\ndata: hello 世界\r\n\r\nid: 43\nevent: special\ndata: line1\ndata: line2\n\n") + } else if path.starts_with("/close-messages") { + ("200 OK", "text/event-stream", "data: first\n\ndata: second\n\n") + } else { + ("200 OK", "text/event-stream", "data: allowed\n\n") + }; + let policy = if path.starts_with("/worker.js?csp") { + "Content-Security-Policy: connect-src 'none'\r\n".to_owned() + } else if path.starts_with("/worker.js?report") { + "Content-Security-Policy-Report-Only: connect-src 'none'\r\n".to_owned() + } else if path.starts_with("/allow") || path.starts_with("/reconnect") { + format!("Access-Control-Allow-Origin: {}\r\nAccess-Control-Allow-Credentials: true\r\n", header("Origin").unwrap_or("*")) + } else { String::new() }; + let response = format!("HTTP/1.1 {status}\r\nContent-Type: {mime}\r\n{policy}Cache-Control: no-store\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",body.len()); + let _ = stream.write_all(response.as_bytes()).await; + }); + } + _ = connections.join_next(), if !connections.is_empty() => {} + } + } + }); + Ok(Self { + origin, + requests, + task, + disconnected, + }) + } +} + +async fn run_worker_source_case( + server: &EventSourceWorkerServer, + target: &EventSourceWorkerServer, + scenario: &str, + path: &str, + credentials: bool, + csp: bool, +) -> Result<()> { + let browser = Browser::new(AppConfig::default())?; + let mut page = browser.fetch(&format!("{}/page", server.origin)).await?; + if scenario == "serviceworker" { + let setup = page.evaluate_runtime_expression_with_await_async(r#"(async () => { + await navigator.serviceWorker.register('/sw.js'); + await navigator.serviceWorker.ready; + if (!navigator.serviceWorker.controller) + await new Promise(resolve => navigator.serviceWorker.addEventListener('controllerchange', resolve, {once:true})); + return true; + })()"#,true).await?; + assert_eq!(setup["value"], true, "{setup}"); + } + for shared in [false, true] { + if scenario == "after-close" && shared { + continue; + } + let config = serde_json::json!({"scenario":if scenario=="serviceworker" {"cors"} else {scenario},"url":format!("{}{path}?shared={shared}",target.origin),"credentials":credentials}); + let expression = format!( + r#"new Promise((resolve, reject) => {{ + const worker = {shared} ? new SharedWorker({worker_url}) : new Worker({worker_url}); + const port = {shared} ? worker.port : worker; + port.onmessage = event => {{ + if ({shared}) port.close(); else worker.terminate(); + resolve(JSON.stringify(event.data)); + }}; + worker.onerror = event => reject(new Error(event.message || 'worker bootstrap error')); + if ({shared}) port.start(); + port.postMessage({config}); + }})"#, + worker_url = serde_json::to_string(&format!( + "/worker.js?{}shared={shared}", + if csp { + "csp&" + } else if scenario == "report-close" { + "report&" + } else { + "" + } + ))?, + ); + let result = tokio::time::timeout( + Duration::from_secs(15), + page.evaluate_runtime_expression_with_await_async(&expression, true), + ) + .await??; + let value: serde_json::Value = serde_json::from_str( + result["value"] + .as_str() + .unwrap_or_else(|| panic!("serialized worker result: {result}")), + )?; + assert_eq!( + value["ok"], true, + "scenario={scenario}, shared={shared}: {value}" + ); + } + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_stream_decodes_messages_and_custom_events() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case(&server, &server, "stream", "/stream", false, false).await +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_reconnects_with_last_event_id() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case(&server, &server, "reconnect", "/reconnect", false, false).await?; + let requests = server.requests.lock(); + for shared in [false, true] { + let path = format!("/reconnect?shared={shared}"); + let requests = requests + .iter() + .filter(|r| r["path"] == path) + .collect::>(); + assert_eq!(requests.len(), 2, "{requests:?}"); + assert_eq!(requests[0]["lastEventId"], serde_json::Value::Null); + assert_eq!(requests[1]["lastEventId"], "42"); + assert!(requests.iter().all(|r| r["accept"] == "text/event-stream")); + } + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_close_before_connect_cancels_startup() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case( + &server, + &server, + "close-before", + "/closed-before", + false, + false, + ) + .await?; + assert!( + !server + .requests + .lock() + .iter() + .any(|r| r["path"].as_str().unwrap().starts_with("/closed-before")) + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_close_suppresses_remaining_messages() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case( + &server, + &server, + "close-messages", + "/close-messages", + false, + false, + ) + .await +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_invalid_response_closes_without_opening() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + for path in ["/no-content", "/wrong-mime"] { + run_worker_source_case(&server, &server, "reject", path, false, false).await?; + } + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_cors_checks_credentials_before_dispatch() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + let cross = EventSourceWorkerServer::spawn().await?; + for credentials in [false, true] { + run_worker_source_case(&server, &cross, "cors", "/allow", credentials, false).await?; + run_worker_source_case(&server, &cross, "reject", "/deny", credentials, false).await?; + } + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_csp_prevents_transport() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case(&server, &server, "reject", "/csp-blocked", false, true).await?; + assert!( + !server + .requests + .lock() + .iter() + .any(|r| r["path"].as_str().unwrap().starts_with("/csp-blocked")) + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_constructor_converts_arguments_and_closes() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case( + &server, + &server, + "constructor", + "/constructor", + false, + false, + ) + .await +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_cross_origin_reconnect_keeps_browser_headers() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + let cross = EventSourceWorkerServer::spawn().await?; + for (credentials, path) in [ + (false, "/reconnect-anonymous"), + (true, "/reconnect-credentials"), + ] { + run_worker_source_case(&server, &cross, "reconnect", path, credentials, false).await?; + } + let requests = cross.requests.lock(); + assert_eq!( + requests.len(), + 8, + "both Worker kinds reconnect once in each credentials mode: {requests:?}" + ); + assert!( + requests.iter().all(|r| r["method"] == "GET"), + "browser Last-Event-ID must not trigger an author-header preflight: {requests:?}" + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_reconnect_preserves_utf8_event_ids() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case( + &server, + &server, + "reconnect", + "/reconnect-unicode", + false, + false, + ) + .await?; + let requests = server.requests.lock(); + let ids = requests + .iter() + .filter(|r| { + r["path"] + .as_str() + .unwrap() + .starts_with("/reconnect-unicode") + }) + .filter_map(|r| r["lastEventId"].as_str()) + .collect::>(); + assert_eq!( + ids, + vec!["雪", "雪"], + "Last-Event-ID transmits the event id as UTF-8 bytes" + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn terminating_worker_cancels_open_event_source_transport() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + let browser = Browser::new(AppConfig::default())?; + let mut page = browser.fetch(&format!("{}/page", server.origin)).await?; + let result=tokio::time::timeout(Duration::from_secs(15), + page.evaluate_runtime_expression_with_await_async(r#"new Promise((resolve,reject) => { + const worker = new Worker('/worker.js'); + worker.onmessage = event => { worker.terminate(); resolve(JSON.stringify(event.data)); }; + worker.onerror = event => reject(new Error(event.message || 'worker bootstrap error')); + worker.postMessage({scenario:'hold', url:new URL('/hold',location.href).href}); + })"#,true)).await??; + let value: serde_json::Value = serde_json::from_str(result["value"].as_str().unwrap())?; + assert_eq!(value, serde_json::json!({"ok":true,"open":true})); + tokio::time::timeout(Duration::from_secs(5), server.disconnected.notified()).await?; + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_receives_service_worker_response() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case( + &server, + &server, + "serviceworker", + "/sw-events", + false, + false, + ) + .await?; + assert!( + !server + .requests + .lock() + .iter() + .any(|r| r["path"].as_str().unwrap().starts_with("/sw-events")), + "the response must come from the controlling Service Worker" + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_event_source_policy_callback_can_close_connection() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case(&server, &server, "report-close", "/allow", false, false).await +} + +#[tokio::test(flavor = "multi_thread")] +async fn closing_worker_event_source_remains_connecting_without_transport() -> Result<()> { + let server = EventSourceWorkerServer::spawn().await?; + run_worker_source_case( + &server, + &server, + "after-close", + "/must-not-start", + false, + false, + ) + .await?; + assert!( + !server + .requests + .lock() + .iter() + .any(|r| r["path"].as_str().unwrap().starts_with("/must-not-start")) + ); + Ok(()) +} diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index e10f713ebbd..0c75a7be00b 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -845,13 +845,6 @@ pub(in crate::context_bootstrap) fn build_profiled_exposed_interface_template<'s ); template } - "EventSource" => build_constructor_template_with_callback( - scope, - spec, - 1, - profile, - worker_unsupported_constructor_callback, - )?, _ => build_constructor_template_for_profile(scope, spec, profile)?, }; if profile == exposed_interfaces::TemplateBuildProfile::DedicatedWorker @@ -862,19 +855,6 @@ pub(in crate::context_bootstrap) fn build_profiled_exposed_interface_template<'s Ok(template) } -fn worker_unsupported_constructor_callback( - scope: &mut v8::PinScope<'_, '_>, - _args: v8::FunctionCallbackArguments<'_>, - _rv: v8::ReturnValue<'_, v8::Value>, -) { - let exception = crate::native_bridge::abort::dom_exception_value( - scope, - "This constructor is not implemented in dedicated workers yet.", - "NotSupportedError", - ); - scope.throw_exception(exception); -} - #[derive(Default, WebApiObject)] #[webapi(plain)] pub(in crate::context_bootstrap) struct GlobalCachesAccessorDeclaration { diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs index 48095f7986c..22d2c01b304 100644 --- a/moli-renderer-v8/src/network_host.rs +++ b/moli-renderer-v8/src/network_host.rs @@ -108,10 +108,12 @@ pub(crate) use self::csp_reports::{ }; pub(crate) use self::dictionary::start_response_dictionary_loads; pub(crate) use self::event_source::{ - EVENT_SOURCE_CLOSED, EventSourceMessage, EventSourceParser, EventSourceTerminalMode, - dispatch_event_source_message, event_source_constructor_callback, event_source_last_event_id, + EVENT_SOURCE_CLOSED, EVENT_SOURCE_OPEN, EventSourceMessage, EventSourceParser, + EventSourceTerminalMode, dispatch_event_source_message, event_source_active_request_id, + event_source_connection_url, event_source_constructor_callback, event_source_last_event_id, event_source_ready_state, event_source_reconnect_delay_ms, event_source_response_error, - fail_event_source_connection, install_event_source_bindings, open_event_source_connection, + event_source_with_credentials, fail_event_source_connection, install_event_source_bindings, + open_event_source_connection, set_event_source_active_request_id, update_event_source_stream_state, }; pub(crate) use self::fetch::{ diff --git a/moli-renderer-v8/src/network_host/controlled_resource.rs b/moli-renderer-v8/src/network_host/controlled_resource.rs index 4df3317d044..e29cad742d1 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource.rs @@ -295,6 +295,9 @@ impl ControlledResourceLoad { } if headers_changed { self.preflight_headers = self.request.request_headers.to_byte_strings(); + if self.info.resource_type == crate::types::SubresourceResourceType::EventSource { + self.preflight_headers.retain(|(name, _)| !name.eq_ignore_ascii_case("Last-Event-ID")); + } } self.sync_info(); if request_changed && self.interception.is_worker() { @@ -794,6 +797,9 @@ impl ControlledResourceLoad { owner.admit(&self.cancel).await?; } self.preflight_headers = self.request.request_headers.to_byte_strings(); + if self.info.resource_type == crate::types::SubresourceResourceType::EventSource { + self.preflight_headers.retain(|(name, _)| !name.eq_ignore_ascii_case("Last-Event-ID")); + } // Retire the previous hop's protocol correlation before installing // its next one. The stable native network handle keeps Network ID. self.interception.publish_continue( diff --git a/moli-renderer-v8/src/network_host/controlled_resource/context.rs b/moli-renderer-v8/src/network_host/controlled_resource/context.rs index 8a979d47598..3f3bcc75f48 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/context.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/context.rs @@ -68,7 +68,10 @@ impl ControlledXhrContext { cancel: moli_fetch::FetchCancelHandle, policy: crate::types::SubresourcePolicyContext, ) -> super::ControlledResourceLoad { - let headers = request.request_headers.to_byte_strings(); + let mut headers = request.request_headers.to_byte_strings(); + if info.resource_type == crate::types::SubresourceResourceType::EventSource { + headers.retain(|(name, _)| !name.eq_ignore_ascii_case("Last-Event-ID")); + } self.load(request, info, load, cancel, headers) .with_fetch_policy(policy) } diff --git a/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs b/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs index 99541059193..c22298325c0 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs @@ -35,6 +35,7 @@ pub(crate) struct ControlledFetchStream { delivered: usize, timing: crate::worker::WorkerResourceTiming, response_filter: Option, + event_source_parser: Option, } struct StreamedFetchResponse { @@ -45,6 +46,10 @@ struct StreamedFetchResponse { } impl ControlledFetchStream { + fn with_event_source_parser(mut self, parser: Option) -> Self { + self.event_source_parser = parser; + self + } pub(super) fn set_response_filter(&mut self, filter: Option) { self.response_filter = filter; } @@ -88,6 +93,7 @@ impl ControlledFetchStream { delivered: 0, timing, response_filter: None, + event_source_parser: None, } } @@ -191,6 +197,13 @@ impl ControlledFetchStream { )); // A detached JS consumer does not cancel a keepalive transport. Its // resource lease, rather than this delivery channel, owns cancellation. + if let Some(parser) = &mut self.event_source_parser { + let messages = parser.push(&bytes); + let _ = self.completion.send(WorkerFetchEvent::EventSourceState { fetch_id: self.fetch_id, body_source_id: self.body_source_id.unwrap(), last_event_id: parser.last_event_id().to_owned(), reconnect_delay_ms: parser.reconnect_delay_ms() }); + for message in messages { + let _ = self.completion.send(WorkerFetchEvent::EventSourceMessage { fetch_id: self.fetch_id, body_source_id: self.body_source_id.unwrap(), message }); + } + } else { let _ = self.completion.send(WorkerFetchEvent::StreamingChunk( WorkerFetchStreamingChunk { fetch_id: self.fetch_id, @@ -198,6 +211,7 @@ impl ControlledFetchStream { bytes, }, )); + } Ok(()) } @@ -255,6 +269,7 @@ impl super::ControlledResourceLoad { resource_timing: FetchResourceTiming, integrity: String, timing: crate::worker::WorkerResourceTiming, + event_source_parser: Option, ) { // Network/CDP correlation follows redirects; Resource Timing names // the original request, including when interception rewrites its URL. @@ -280,7 +295,7 @@ impl super::ControlledResourceLoad { self.load.clone(), resource_timing.clone(), timing.clone(), - )); + ).with_event_source_parser(event_source_parser)); let result = self.run_inner((integrity.is_empty() && self.info.resource_type != crate::types::SubresourceResourceType::Font).then_some(&mut stream)).await; let result = self.normalize_cancellation(result); stream.policy_violations(std::mem::take(&mut self.csp_violations)); diff --git a/moli-renderer-v8/src/network_host/event_source/bindings.rs b/moli-renderer-v8/src/network_host/event_source/bindings.rs index 5f479b48696..62dfbca881f 100644 --- a/moli-renderer-v8/src/network_host/event_source/bindings.rs +++ b/moli-renderer-v8/src/network_host/event_source/bindings.rs @@ -360,16 +360,22 @@ pub(crate) fn schedule_event_source_connect<'s>( else { return false; }; - let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else { - return false; + let timer_id = if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) { + unsafe { &mut *host_ptr }.queue_timeout( + scope, + callback, + delay_ms.min(u64::from(u32::MAX)), + crate::host::HostTimerOwner::Window, + Vec::new(), + ) + } else { + crate::worker::queue_worker_browser_timeout( + scope, + callback, + delay_ms.min(u64::from(u32::MAX)), + ) + .unwrap_or(0) }; - let timer_id = unsafe { &mut *host_ptr }.queue_timeout( - scope, - callback, - delay_ms.min(u64::from(u32::MAX)), - crate::host::HostTimerOwner::Window, - Vec::new(), - ); if timer_id == 0 { return false; } @@ -415,10 +421,12 @@ fn event_source_close_callback<'s>( return; } clear_event_source_reconnect_timer(scope, event_source); - if let Some(internal_id) = event_source_active_request_id(scope, event_source) - && let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) - { - let _ = unsafe { &mut *host_ptr }.abort_event_source_fetch(internal_id); + if let Some(internal_id) = event_source_active_request_id(scope, event_source) { + if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) { + let _ = unsafe { &mut *host_ptr }.abort_event_source_fetch(internal_id); + } else { + crate::worker::abort_worker_event_source(scope, internal_id); + } } set_event_source_active_request_id(scope, event_source, None); set_event_source_number_slot( @@ -442,6 +450,8 @@ fn clear_event_source_reconnect_timer<'s>( }; if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) { unsafe { &mut *host_ptr }.cancel_timer(timer_id); + } else { + crate::worker::cancel_worker_browser_timeout(scope, timer_id); } set_private_value( scope, diff --git a/moli-renderer-v8/src/network_host/event_source/request.rs b/moli-renderer-v8/src/network_host/event_source/request.rs index 2e42e78abd1..428c4d6b846 100644 --- a/moli-renderer-v8/src/network_host/event_source/request.rs +++ b/moli-renderer-v8/src/network_host/event_source/request.rs @@ -58,6 +58,34 @@ pub(crate) fn event_source_constructor_callback<'s>( None => return, }; let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else { + if let Some(base_url) = crate::worker::worker_current_script_url(scope) { + let resolved_url = match resolve_context_url(&base_url, &parsed.url, None) { + Ok(url) => url, + Err(_) => { + throw_dom_exception( + scope, + "SyntaxError", + 12, + "Failed to construct 'EventSource': The URL is invalid.", + ); + return; + } + }; + let event_source = args.this(); + initialize_event_source_object( + scope, + event_source, + resolved_url.as_str(), + options.with_credentials, + ); + if !schedule_event_source_connect(scope, event_source, 0) + && !crate::worker::worker_global_is_closed(scope) + { + fail_event_source_connection(scope, event_source, EventSourceTerminalMode::Close); + } + rv.set(event_source.into()); + return; + } throw_type_error( scope, "Failed to construct 'EventSource': runtime is unavailable.", @@ -120,6 +148,9 @@ pub(crate) fn start_event_source_request<'s>( return; } let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else { + if crate::worker::start_worker_event_source_request(scope, event_source) { + return; + } fail_event_source_connection(scope, event_source, EventSourceTerminalMode::Close); return; }; diff --git a/moli-renderer-v8/src/worker/global_scope/event_source.rs b/moli-renderer-v8/src/worker/global_scope/event_source.rs new file mode 100644 index 00000000000..479b0b4d74b --- /dev/null +++ b/moli-renderer-v8/src/worker/global_scope/event_source.rs @@ -0,0 +1,432 @@ +//! EventSource uses the Worker's native fetch transport and networking turns. + +use super::fetch::WorkerFetchKind; +use super::*; +use crate::network_host::{ + EventSourceParser, EventSourceTerminalMode, event_source_active_request_id, + event_source_connection_url, event_source_last_event_id, event_source_ready_state, + event_source_reconnect_delay_ms, event_source_with_credentials, fail_event_source_connection, + set_event_source_active_request_id, +}; + +pub(super) fn parser_for_request( + kind: WorkerFetchKind, + headers: &moli_fetch::RequestHeaders, +) -> Option { + let WorkerFetchKind::EventSource { reconnect_delay_ms } = kind else { + return None; + }; + let last_event_id = headers + .to_byte_strings() + .into_iter() + .find(|(key, _)| key.eq_ignore_ascii_case("Last-Event-ID")) + .map(|(_, value)| { + let bytes = value.chars().map(|ch| ch as u8).collect::>(); + String::from_utf8_lossy(&bytes).into_owned() + }) + .unwrap_or_default(); + Some(EventSourceParser::new(last_event_id, reconnect_delay_ms)) +} + +pub(super) fn send_stream_chunk( + completion: &mpsc::UnboundedSender, + parser: &mut Option, + fetch_id: u32, + body_source_id: NetworkBodySourceId, + bytes: Vec, +) { + if let Some(parser) = parser { + let messages = parser.push(&bytes); + let _ = completion.send(WorkerFetchEvent::EventSourceState { + fetch_id, + body_source_id, + last_event_id: parser.last_event_id().to_owned(), + reconnect_delay_ms: parser.reconnect_delay_ms(), + }); + for message in messages { + let _ = completion.send(WorkerFetchEvent::EventSourceMessage { + fetch_id, + body_source_id, + message, + }); + } + } else { + let _ = completion.send(WorkerFetchEvent::StreamingChunk( + WorkerFetchStreamingChunk { + fetch_id, + body_source_id, + bytes, + }, + )); + } +} + +fn current_source<'s>( + scope: &mut v8::PinScope<'s, '_>, + state: &Rc>, + fetch_id: u32, + body_source_id: Option, +) -> Option> { + let source = { + let state = state.borrow(); + let pending = state.pending_fetches.get(&fetch_id)?; + if pending.load.is_cancelled() + || body_source_id.is_some_and(|id| pending.streaming_body_source_id != Some(id)) + { + return None; + } + v8::Local::new(scope, pending.client.event_source()?) + }; + (event_source_active_request_id(scope, source) == Some(u64::from(fetch_id)) + && event_source_ready_state(scope, source) != crate::network_host::EVENT_SOURCE_CLOSED) + .then_some(source) +} + +pub(super) fn apply_state( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + fetch_id: u32, + body_source_id: NetworkBodySourceId, + last_event_id: &str, + reconnect_delay_ms: u64, +) { + if let Some(source) = current_source(scope, state, fetch_id, Some(body_source_id)) { + crate::network_host::update_event_source_stream_state( + scope, + source, + last_event_id, + reconnect_delay_ms, + ); + } +} + +pub(super) fn apply_message( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + fetch_id: u32, + body_source_id: NetworkBodySourceId, + message: &crate::network_host::EventSourceMessage, +) { + if let Some(source) = current_source(scope, state, fetch_id, Some(body_source_id)) + && event_source_ready_state(scope, source) == crate::network_host::EVENT_SOURCE_OPEN + { + crate::network_host::dispatch_event_source_message(scope, source, message); + } +} + +pub(crate) fn start_worker_event_source_request<'s>( + scope: &mut v8::PinScope<'s, '_>, + source: v8::Local<'s, v8::Object>, +) -> bool { + let Some(state) = get_worker_state(scope) else { + return false; + }; + let Some(document_url) = state.borrow().current_script_url.clone() else { + return false; + }; + let Some(url) = + event_source_connection_url(scope, source).and_then(|url| Url::parse(&url).ok()) + else { + return false; + }; + let ( + policy_context, + extra_headers, + blocked, + referrer_policy, + partition, + ) = { + let state = state.borrow(); + ( + state.policy_context, + state.extra_http_headers.clone(), + state.blocked_url_patterns.clone(), + state.referrer_policy.clone(), + state.network_partition_key.clone(), + ) + }; + let kind = WorkerFetchKind::EventSource { + reconnect_delay_ms: event_source_reconnect_delay_ms(scope, source), + }; + let credentials = if event_source_with_credentials(scope, source) { + RequestCredentialsMode::Include + } else { + RequestCredentialsMode::SameOrigin + }; + let credentials = policy_context.network_credentials_mode(RequestMode::Cors, credentials); + let origin = worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque); + let timing = WorkerResourceTiming::new( + scope, + url.clone(), + origin, + WorkerTimingRequest::EventSource { + credentials, + policy: policy_context, + }, + ); + let mut fields = vec![("Accept".to_owned(), "text/event-stream".to_owned())]; + let last_id = event_source_last_event_id(scope, source); + if !last_id.is_empty() { + fields.push(( + "Last-Event-ID".to_owned(), + last_id.bytes().map(char::from).collect(), + )); + } + let headers = merge_worker_request_headers( + &extra_headers, + &moli_fetch::RequestHeaders::from_byte_strings(&fields) + .expect("EventSource native headers are ByteStrings"), + ); + let metadata = crate::service_worker_runtime::ServiceWorkerFetchRequestMetadata { + cache: "no-store".to_owned(), + mixed_content_policy: state.borrow().mixed_content_policy(), + ..Default::default() + }; + let environment = crate::network_host::BlobUrlFetchEnvironment::for_worker(scope); + let blob = crate::network_host::CapturedBlobUrl::capture(&url) + .map(|entry| entry.for_environment(environment.as_ref())); + let error = check_worker_request_csp( + scope, &state, &document_url, &url, kind.csp_resource_kind(), "EventSource", + crate::content_security_policy::ContentSecurityPolicyDisposition::Enforce, + ).or_else(|| moli_url_policy::route_fetch_url(&url).err().map(|error| error.to_string())) + .or_else(|| should_request_be_blocked_due_to_bad_port(&url).then(|| "EventSource URL has a blocked port".to_owned())) + .or_else(|| worker_url_blocked(&blocked, &url).then(|| BLOCKED_BY_CLIENT_ERROR_TEXT.to_owned())); + let mut request = Request::new_browser("GET", url, None, headers, timing.origin().clone()) + .with_initiator_url(&document_url) + .with_mixed_content_policy(metadata.mixed_content_policy) + .with_request_mode(RequestMode::Cors) + .with_credentials_mode(credentials) + .with_cache_mode(moli_fetch::RequestCacheMode::NoStore) + .with_network_partition_key(partition) + .with_browser_request_metadata(BrowserRequestMetadata::EventSource); + if let Some(policy) = referrer_policy { + request = request.with_script_fetch_metadata(moli_fetch::ScriptFetchRequestMetadata { referrer_policy: Some(policy), ..Default::default() }); + } + super::fetch::start_native(scope, &state, super::fetch::NativeWorkerFetchRequest { + request, blob_url_entry: blob, kind, font_face: None, timing, + body_stream: None, body_stream_locked: false, signal: None, + event_source: Some(source), admission_error: error, + }, document_url, None, metadata, policy_context).is_some() +} + +pub(super) fn fail_request( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + fetch_id: u32, + error: String, + mode: EventSourceTerminalMode, +) { + let pending = state.borrow_mut().pending_fetches.remove(&fetch_id); + let Some(pending) = pending else { return }; + pending.load.cancel(); + pending.timing.reject(scope); + tracing::debug!(%error, "Worker EventSource request failed"); + if let Some(source) = pending.client.event_source() { + let source = v8::Local::new(scope, source); + if event_source_active_request_id(scope, source) == Some(u64::from(fetch_id)) { + fail_event_source_connection(scope, source, mode); + } + } +} + +pub(crate) fn abort_worker_event_source(scope: &mut v8::PinScope<'_, '_>, id: u64) { + let (Some(state), Ok(id)) = (get_worker_state(scope), u32::try_from(id)) else { + return; + }; + let pending = state.borrow_mut().pending_fetches.remove(&id); + if let Some(pending) = pending { + pending.timing.abort(scope); + pending.load.cancel(); + + } +} + +pub(super) fn start_response( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + started: &WorkerFetchStreamingStarted, +) -> bool { + let is_source = state + .borrow() + .pending_fetches + .get(&started.fetch_id) + .is_some_and(|pending| pending.client.event_source().is_some()); + if !is_source { + return false; + } + let error = { + let state = state.borrow(); + // Reporting a policy violation can run script that closes the source. + let Some(pending) = state.pending_fetches.get(&started.fetch_id) else { + return true; + }; + validate_response( + pending, + &started.head, + started.response_filter.as_ref(), + started.skip_fetch_security_validation, + ) + .err() + .or_else(|| crate::network_host::event_source_response_error(&started.head)) + }; + if let Some(error) = error { + fail_request( + scope, + state, + started.fetch_id, + error, + EventSourceTerminalMode::Close, + ); + return true; + } + { + let mut state = state.borrow_mut(); + let pending = state + .pending_fetches + .get_mut(&started.fetch_id) + .expect("current SSE response"); + pending.streaming_body_source_id = Some(started.body_source_id); + + } + if let Some(source) = + current_source(scope, state, started.fetch_id, Some(started.body_source_id)) + { + crate::network_host::open_event_source_connection(scope, source, &started.head.final_url); + } + true +} + +fn validate_response( + pending: &PendingWorkerFetch, + head: &ResponseHead, + filter: Option<&crate::types::AsyncSubresourceFetchResponseFilter>, + skip: bool, +) -> Result<(), String> { + if filter.is_some_and(|filter| !filter.is_readable()) { + return Err("EventSource cannot read an opaque response".to_owned()); + } + if !skip { + crate::network_host::validate_fetch_response_headers( + pending.timing.origin(), + head, + pending.request_mode, + pending.credentials_mode, + pending.policy_context, + )?; + } + Ok(()) +} + +pub(super) fn complete_response( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + pending: PendingWorkerFetch, + completion: WorkerFetchCompletion, +) { + let response_filter = completion + .result + .as_ref() + .ok() + .and_then(WorkerFetchResponse::response_filter); + let skip_fetch_security_validation = completion + .result + .as_ref() + .is_ok_and(WorkerFetchResponse::skips_fetch_security_validation); + match completion.result { + Err(error) => { + let id = completion.fetch_id; + state.borrow_mut().pending_fetches.insert(id, pending); + let mode = if crate::network_host::is_cors_policy_failure_message(&error) { + EventSourceTerminalMode::Close + } else { + EventSourceTerminalMode::Reconnect + }; + fail_request(scope, state, id, error, mode); + } + Ok(response) => { + let head = response.head(); + if let Err(error) = validate_response( + &pending, + &head, + response_filter.as_ref(), + skip_fetch_security_validation, + ) { + state + .borrow_mut() + .pending_fetches + .insert(completion.fetch_id, pending); + fail_request( + scope, + state, + completion.fetch_id, + error, + EventSourceTerminalMode::Close, + ); + return; + } + let body = response.subresource_response_body(); + let bytes = match body.try_bytes() { + Ok(bytes) => bytes.into_owned(), + Err(error) => { + state + .borrow_mut() + .pending_fetches + .insert(completion.fetch_id, pending); + fail_request( + scope, + state, + completion.fetch_id, + error.to_string(), + EventSourceTerminalMode::Reconnect, + ); + return; + } + }; + let mut parser = parser_for_request(pending.kind, &pending.request_headers); + state + .borrow_mut() + .pending_fetches + .insert(completion.fetch_id, pending); + let tx = state.borrow().fetch_completion_tx.clone(); + let body_source_id = crate::network_host::new_network_body_source_id(); + let _ = tx.send(WorkerFetchEvent::StreamingStarted( + WorkerFetchStreamingStarted { + fetch_id: completion.fetch_id, + body_source_id, + head: head.clone(), + response_filter, + skip_fetch_security_validation: true, + }, + )); + send_stream_chunk(&tx, &mut parser, completion.fetch_id, body_source_id, bytes); + let _ = tx.send(WorkerFetchEvent::StreamingFinished( + WorkerFetchStreamingFinished { + fetch_id: completion.fetch_id, + body_source_id, + head, + result: Ok(body), + }, + )); + } + } +} + +pub(super) fn finish_response( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + pending: PendingWorkerFetch, + finished: WorkerFetchStreamingFinished, +) { + pending.load.finish(); + pending.timing.publish(scope); + let source = pending + .client + .event_source() + .map(|source| v8::Local::new(scope, source)); + if let Some(source) = source + && event_source_active_request_id(scope, source) == Some(u64::from(finished.fetch_id)) + && event_source_ready_state(scope, source) != crate::network_host::EVENT_SOURCE_CLOSED + { + fail_event_source_connection(scope, source, EventSourceTerminalMode::Reconnect); + } +} diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index 2ccdc8106c6..47d40f73027 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -1,5 +1,6 @@ use super::*; mod native_load; +pub(super) use native_load::{NativeWorkerFetchRequest, start as start_native}; use std::sync::atomic::AtomicU64; use crate::network::interception_output::ResourceInterceptionContext; @@ -18,22 +19,26 @@ use crate::types::{ pub(in crate::worker) enum WorkerFetchKind { Fetch, Font, + EventSource { reconnect_delay_ms: u64 }, } impl WorkerFetchKind { - fn resource_type(self) -> SubresourceResourceType { + pub(super) fn resource_type(self) -> SubresourceResourceType { match self { Self::Fetch => SubresourceResourceType::Fetch, Self::Font => SubresourceResourceType::Font, + Self::EventSource { .. } => SubresourceResourceType::EventSource, } } - fn csp_resource_kind( + pub(super) fn csp_resource_kind( self, ) -> crate::content_security_policy::ContentSecurityPolicyResourceKind { use crate::content_security_policy::ContentSecurityPolicyResourceKind; match self { - Self::Fetch => ContentSecurityPolicyResourceKind::WorkerConnect, + Self::Fetch | Self::EventSource { .. } => { + ContentSecurityPolicyResourceKind::WorkerConnect + } Self::Font => ContentSecurityPolicyResourceKind::DocumentFont, } } @@ -42,6 +47,7 @@ impl WorkerFetchKind { match self { Self::Fetch => BrowserRequestMetadata::Fetch, Self::Font => BrowserRequestMetadata::Font, + Self::EventSource { .. } => BrowserRequestMetadata::EventSource, } } } @@ -1198,6 +1204,7 @@ pub(super) fn start_worker_resource_fetch<'s>( Ok(mut request) => { if let Some(metadata) = metadata { request = request.with_script_fetch_metadata(metadata); + } request } @@ -1209,7 +1216,7 @@ pub(super) fn start_worker_resource_fetch<'s>( native_load::start( scope, &state, - native_load::NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face, timing, body_stream, body_stream_locked, signal }, + native_load::NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face, timing, body_stream, body_stream_locked, signal, event_source: None, admission_error: None }, @@ -1257,9 +1264,10 @@ pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>( pending.load.cancel(); if let Some(body_source_id) = pending.streaming_body_source_id { + crate::network_host::abort_pending_network_body_stream(scope, body_source_id, reason); } else { - let resolver = v8::Local::new(scope, &pending.resolver); + let resolver = v8::Local::new(scope, pending.client.resolver()); let _ = resolver.reject(scope, reason); } @@ -1276,6 +1284,40 @@ pub(in crate::worker) fn drain_worker_fetch_completion( event: WorkerFetchEvent, ) { match event { + WorkerFetchEvent::BrowserTimeout { timer_id } => { + super::timers::run_worker_browser_timeout(scope, state, timer_id); + } + + WorkerFetchEvent::EventSourceState { + fetch_id, + body_source_id, + last_event_id, + reconnect_delay_ms, + } => { + super::event_source::apply_state( + scope, + state, + fetch_id, + body_source_id, + &last_event_id, + reconnect_delay_ms, + ); + } + WorkerFetchEvent::EventSourceMessage { + fetch_id, + body_source_id, + message, + } => { + super::event_source::apply_message(scope, state, fetch_id, body_source_id, &message); + } + WorkerFetchEvent::EventSourceFailure { + fetch_id, + error, + mode, + } => { + super::event_source::fail_request(scope, state, fetch_id, error, mode); + } + WorkerFetchEvent::RequestBodyProducer { fetch_id, mut producer, @@ -1288,7 +1330,7 @@ pub(in crate::worker) fn drain_worker_fetch_completion( .filter(|pending| !pending.load.is_cancelled()) .map(|pending| { ( - pending.resolver.clone(), + pending.client.resolver().clone(), pending.load.task_runner(), state.fetch_completion_tx.clone(), ) @@ -1415,18 +1457,20 @@ pub(in crate::worker) fn drain_worker_fetch_completion( } } + pub(in crate::worker) fn start_worker_streaming_fetch( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, started: WorkerFetchStreamingStarted, ) { + if super::event_source::start_response(scope, state, &started) { return; } let (resolver, method) = { let mut state = state.borrow_mut(); let Some(pending) = state.pending_fetches.get_mut(&started.fetch_id) else { return; }; pending.streaming_body_source_id = Some(started.body_source_id); - (pending.resolver.clone(), pending.request_method.clone()) + (pending.client.resolver().clone(), pending.request_method.clone()) }; // Security checks, exposed headers and immutable metadata belong to the // native load. This task only constructs the Response in its Worker realm. @@ -1456,6 +1500,10 @@ pub(in crate::worker) fn finish_worker_streaming_fetch( else { return; }; + if pending.client.event_source().is_some() { + super::event_source::finish_response(scope, state, pending, finished); + return; + } pending.load.finish(); match finished.result { Ok(entry) => { @@ -1484,6 +1532,7 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( ) { + let Some(pending) = state .borrow_mut() .pending_fetches @@ -1492,14 +1541,18 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( return; }; pending.load.finish(); - let resolver = v8::Local::new(scope, &pending.resolver); + if pending.client.event_source().is_some() { + super::event_source::complete_response(scope, state, pending, completion); + return; + } + let resolver = v8::Local::new(scope, pending.client.resolver()); match completion.result { Ok(response) => { crate::context_bootstrap::record_resource_performance_entry( scope, response.resource_timing, ); - if let Some(face) = pending.font_face.as_ref() { + if let Some(face) = pending.client.font_face() { let usable = (200..300).contains(&response.head.status) && response.metadata.response_type.is_readable(); let bytes = usable.then(|| response.body.as_materialized_bytes()).flatten(); diff --git a/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs b/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs index 4152135bef9..61441743e71 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs @@ -1,17 +1,19 @@ use super::*; -pub(super) struct NativeWorkerFetchRequest<'s> { - pub(super) request: Request, - pub(super) body_stream: Option>, - pub(super) body_stream_locked: bool, - pub(super) signal: Option>, - pub(super) blob_url_entry: Option, - pub(super) kind: WorkerFetchKind, - pub(super) timing: WorkerResourceTiming, - pub(super) font_face: Option>, +pub(in crate::worker::global_scope) struct NativeWorkerFetchRequest<'s> { + pub(in crate::worker::global_scope) request: Request, + pub(in crate::worker::global_scope) event_source: Option>, + pub(in crate::worker::global_scope) admission_error: Option, + pub(in crate::worker::global_scope) body_stream: Option>, + pub(in crate::worker::global_scope) body_stream_locked: bool, + pub(in crate::worker::global_scope) signal: Option>, + pub(in crate::worker::global_scope) blob_url_entry: Option, + pub(in crate::worker::global_scope) kind: WorkerFetchKind, + pub(in crate::worker::global_scope) timing: WorkerResourceTiming, + pub(in crate::worker::global_scope) font_face: Option>, } -pub(super) fn start<'s>( +pub(in crate::worker::global_scope) fn start<'s>( scope: &mut v8::PinScope<'s, '_>, state: &Rc>, request: NativeWorkerFetchRequest<'s>, @@ -20,7 +22,7 @@ pub(super) fn start<'s>( metadata: ServiceWorkerFetchRequestMetadata, policy_context: SubresourcePolicyContext, ) -> Option> { - let NativeWorkerFetchRequest { mut request, blob_url_entry, kind, font_face, timing, body_stream, body_stream_locked, signal } = request; + let NativeWorkerFetchRequest { mut request, blob_url_entry, kind, font_face, timing, body_stream, body_stream_locked, signal, event_source, admission_error } = request; let resolver = v8::PromiseResolver::new(scope)?; let promise = resolver.get_promise(scope); let cancel = FetchCancelHandle::new(); @@ -71,9 +73,14 @@ pub(super) fn start<'s>( PendingWorkerFetch { upload: None, kind, - font_face: font_face.map(|face| v8::Global::new(scope, face)), - resolver: v8::Global::new(scope, resolver), + client: if let Some(source) = event_source { WorkerFetchClient::EventSource(v8::Global::new(scope, source)) } else { WorkerFetchClient::Promise { resolver: v8::Global::new(scope, resolver), font_face: font_face.map(|face| v8::Global::new(scope, face)) } }, + request_headers: request.request_headers.clone(), resource_timing: resource_timing.clone(), + document_url, + credentials_mode: policy_context.network_credentials_mode(request.request_mode, request.credentials_mode), + request_mode: request.request_mode, + redirect_mode: request.redirect_mode(), + policy_context, timing: timing.clone(), signal_id, load: load.clone(), @@ -88,6 +95,14 @@ pub(super) fn start<'s>( control.connect_policy = control.connect_policy.for_resource_kind(kind.csp_resource_kind()); (fetch_id, state.fetch_completion_tx.clone(), control, resource_timing) }; + if let Some(source) = event_source { + crate::network_host::set_event_source_active_request_id(scope, source, Some(u64::from(fetch_id))); + } + if let Some(error) = admission_error { + record_worker_subresource_failure_with_handle(&state.borrow(), info.network_request_handle, info.document_url.clone(), info.url.clone(), info.method.clone(), info.request_headers.clone(), info.request_body_bytes.clone(), info.resource_type, error.clone()); + let _ = completion.send(WorkerFetchEvent::EventSourceFailure { fetch_id, error, mode: crate::network_host::EventSourceTerminalMode::Close }); + return Some(promise); + } let service_worker = state.borrow().service_worker_runtime.clone(); let service_worker_client = state.borrow().service_worker_client_id; let controlled = service_worker.as_ref().zip(service_worker_client).is_some_and(|(runtime, client)| { @@ -132,7 +147,8 @@ pub(super) fn start<'s>( } } let task_runner = load.task_runner(); - let redirect_owner = (kind == WorkerFetchKind::Fetch).then(|| { + let event_source_parser = crate::worker::global_scope::event_source::parser_for_request(kind, &request.request_headers); + let redirect_owner = (kind != WorkerFetchKind::Font).then(|| { crate::network_host::RedirectOwner::Worker(WorkerRedirectOwner::fetch(completion.clone(), fetch_id, load.clone())) }); task_runner.spawn(async move { @@ -143,7 +159,7 @@ pub(super) fn start<'s>( .with_blob_url_entry(blob_url_entry) .with_service_worker(service_worker, service_worker_client, metadata) .with_service_worker_request_body(transferred, request_body_owner) - .run_fetch(completion, fetch_id, resource_timing, integrity, timing) + .run_fetch(completion, fetch_id, resource_timing, integrity, timing, event_source_parser) .await; }); Some(promise) diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index 97f17f7b2cb..4682b730d3d 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -197,13 +197,16 @@ pub(crate) use nested_workers::{ }; pub(super) use nested_workers::{dispatch_nested_worker_event, retire_nested_workers}; pub(super) use network_state::{ - PendingWorkerFetch, PendingWorkerXhr, WorkerWebSocketState, WorkerXhrCompletion, WorkerXhrEvent, + WorkerFetchClient, PendingWorkerFetch, PendingWorkerXhr, WorkerWebSocketState, WorkerXhrCompletion, WorkerXhrEvent, }; pub(crate) use network_state::{ WorkerFetchCompletion, WorkerFetchEvent, WorkerFetchResponse, WorkerFetchStreamingChunk, WorkerFetchStreamingFinished, WorkerFetchStreamingStarted, + }; use network_state::{merge_worker_request_headers, next_fetch_id, next_xhr_id, worker_url_blocked}; +mod event_source; +pub(crate) use event_source::{abort_worker_event_source, start_worker_event_source_request}; pub(crate) use origin::worker_global_origin; use origin::{WorkerGlobalOriginDeclaration, WorkerGlobalOriginPrototypeDeclaration}; use performance::monotonic_unix_epoch_millis; @@ -240,3 +243,4 @@ pub(crate) use state::{ worker_termination_requested, }; pub(super) use timers::{TimerInfo, WorkerIsolateTimerQueues, worker_isolate_timer_queues}; +pub(crate) use timers::{cancel_worker_browser_timeout, queue_worker_browser_timeout}; diff --git a/moli-renderer-v8/src/worker/global_scope/network_state.rs b/moli-renderer-v8/src/worker/global_scope/network_state.rs index e8468f132c9..6d2897cd123 100644 --- a/moli-renderer-v8/src/worker/global_scope/network_state.rs +++ b/moli-renderer-v8/src/worker/global_scope/network_state.rs @@ -2,12 +2,54 @@ use super::*; +pub(in crate::worker) enum WorkerFetchClient { + Promise { + resolver: v8::Global, + font_face: Option>, + }, + EventSource(v8::Global), +} + +impl WorkerFetchClient { + pub(super) fn resolver(&self) -> &v8::Global { + match self { + Self::Promise { resolver, .. } => resolver, + Self::EventSource(_) => { + unreachable!("EventSource is delivered through networking tasks, not a Promise") + } + } + } + + pub(super) fn font_face(&self) -> Option<&v8::Global> { + match self { + Self::Promise { font_face, .. } => font_face.as_ref(), + Self::EventSource(_) => None, + } + } + + pub(super) fn event_source(&self) -> Option<&v8::Global> { + match self { + Self::EventSource(source) => Some(source), + Self::Promise { .. } => None, + } + } +} + pub(in crate::worker) struct PendingWorkerFetch { pub(in crate::worker) upload: Option, pub(super) timing: WorkerResourceTiming, pub(in crate::worker) kind: fetch::WorkerFetchKind, - pub(in crate::worker) font_face: Option>, - pub(in crate::worker) resolver: v8::Global, + pub(in crate::worker) client: WorkerFetchClient, + pub(in crate::worker) request_headers: moli_fetch::RequestHeaders, + + pub(in crate::worker) document_url: Url, + /// Effective network credentials; the input Request and FetchEvent retain + /// the author's original credentials mode. + pub(in crate::worker) credentials_mode: RequestCredentialsMode, + pub(in crate::worker) request_mode: moli_fetch::RequestMode, + pub(in crate::worker) redirect_mode: RequestRedirectMode, + + pub(in crate::worker) policy_context: crate::types::SubresourcePolicyContext, pub(in crate::worker) resource_timing: crate::context_bootstrap::FetchResourceTiming, pub(in crate::worker) signal_id: Option, pub(in crate::worker) load: ResourceLoadLease, @@ -19,6 +61,26 @@ pub(in crate::worker) struct PendingWorkerFetch { } pub(crate) enum WorkerFetchEvent { + BrowserTimeout { + timer_id: u32, + }, + EventSourceState { + fetch_id: u32, + body_source_id: NetworkBodySourceId, + last_event_id: String, + reconnect_delay_ms: u64, + }, + EventSourceMessage { + fetch_id: u32, + body_source_id: NetworkBodySourceId, + message: crate::network_host::EventSourceMessage, + }, + EventSourceFailure { + fetch_id: u32, + error: String, + mode: crate::network_host::EventSourceTerminalMode, + }, + RequestBodyProducer { fetch_id: u32, producer: crate::context_bootstrap::RequestBodyProducer, diff --git a/moli-renderer-v8/src/worker/global_scope/resource_timing.rs b/moli-renderer-v8/src/worker/global_scope/resource_timing.rs index d23c6289e46..1ca561808c4 100644 --- a/moli-renderer-v8/src/worker/global_scope/resource_timing.rs +++ b/moli-renderer-v8/src/worker/global_scope/resource_timing.rs @@ -28,6 +28,10 @@ pub(super) enum WorkerTimingRequest { Xhr { credentials: RequestCredentialsMode, }, + EventSource { + credentials: RequestCredentialsMode, + policy: SubresourcePolicyContext, + }, } impl WorkerTimingRequest { @@ -57,6 +61,25 @@ impl WorkerTimingRequest { RequestRedirectMode::Follow, ) } + Self::EventSource { + credentials, + policy, + } => { + validate_fetch_response_headers( + origin, + head, + RequestMode::Cors, + *credentials, + *policy, + ) + .ok()?; + ( + "GET", + RequestMode::Cors, + *credentials, + RequestRedirectMode::Follow, + ) + } }; Some( FetchResponseRequest { @@ -73,6 +96,7 @@ impl WorkerTimingRequest { Self::Fetch { font: true, .. } => "css", Self::Fetch { font: false, .. } => "fetch", Self::Xhr { .. } => "xmlhttprequest", + Self::EventSource { .. } => "other", } } } diff --git a/moli-renderer-v8/src/worker/global_scope/state.rs b/moli-renderer-v8/src/worker/global_scope/state.rs index 3b9c86b4ba1..9ffdaacbcf5 100644 --- a/moli-renderer-v8/src/worker/global_scope/state.rs +++ b/moli-renderer-v8/src/worker/global_scope/state.rs @@ -136,8 +136,10 @@ pub(crate) struct WorkerGlobalState { crate::structured_clone::SharedMemoryAgentCluster, /// Async fetch completions routed back onto the worker event loop. pub(in crate::worker) fetch_completion_tx: mpsc::UnboundedSender, - /// Promise resolvers pending async fetch completion. + /// Fetch promises, font loads and EventSource connections pending network work. pub(in crate::worker) pending_fetches: HashMap, + pub(in crate::worker) browser_timeouts: HashMap, + pub(in crate::worker) next_browser_timeout_id: u32, /// Worker-local pending body sources for headers-first worker fetch. pub(crate) pending_network_body_sources: HashMap, diff --git a/moli-renderer-v8/src/worker/global_scope/timers.rs b/moli-renderer-v8/src/worker/global_scope/timers.rs index f826e741c29..a02abea6dec 100644 --- a/moli-renderer-v8/src/worker/global_scope/timers.rs +++ b/moli-renderer-v8/src/worker/global_scope/timers.rs @@ -3,6 +3,80 @@ use super::*; use crate::timer_nesting::{TimerNestingLevel, TimerNestingOwner}; use std::collections::HashSet; +/// Browser-owned delayed networking work has a private id namespace, separate +/// from author setTimeout/clearTimeout ids and author timer nesting. +pub(in crate::worker) struct WorkerBrowserTimeout { + callback: WorkerTimerCallback, + load: ResourceLoadLease, +} + +pub(crate) fn queue_worker_browser_timeout<'s>( + scope: &mut v8::PinScope<'s, '_>, + callback: v8::Local<'s, v8::Function>, + delay_ms: u64, +) -> Option { + let state = get_worker_state(scope)?; + let mut state = state.borrow_mut(); + if !state.callback_task_delivery_allowed() { + return None; + } + state.next_browser_timeout_id = state.next_browser_timeout_id.checked_add(1)?; + let id = state.next_browser_timeout_id; + let cancel = FetchCancelHandle::new(); + let load = state.loader.register_load( + crate::network::loads::ResourceLoadKind::EventSource, + ResourceLoadDisposition::Ordinary, + Some(cancel.clone()), + )?; + state.browser_timeouts.insert( + id, + WorkerBrowserTimeout { + callback: WorkerTimerCallback::browser_function(scope, callback), + load: load.clone(), + }, + ); + let completion = state.fetch_completion_tx.clone(); + load.task_runner().spawn(async move { + tokio::select! { + _ = tokio::time::sleep(std::time::Duration::from_millis(delay_ms)) => { + load.finish(); + let _ = completion.send(WorkerFetchEvent::BrowserTimeout { timer_id: id }); + } + _ = cancel.cancelled() => {} + } + }); + Some(id) +} + +pub(crate) fn cancel_worker_browser_timeout(scope: &mut v8::PinScope<'_, '_>, id: u32) { + if let Some(state) = get_worker_state(scope) + && let Some(timer) = state.borrow_mut().browser_timeouts.remove(&id) + { + timer.load.cancel(); + } +} + +pub(super) fn run_worker_browser_timeout( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + id: u32, +) { + let timer = state.borrow_mut().browser_timeouts.remove(&id); + let allowed = state.borrow().callback_task_delivery_allowed(); + if let Some(timer) = timer + && allowed + && !timer.load.is_cancelled() + { + let context = timer.callback.target_context(scope); + let scope = &mut v8::ContextScope::new(scope, context); + if let super::super::timer_callback::WorkerTimerCallbackOutcome::Threw(report) = + timer.callback.invoke(scope, &[]) + { + crate::worker::dispatch_current_worker_callback_exception(scope, *report); + } + } +} + #[derive(webidl::WebIdlArgs)] #[webidl(prefix = "DedicatedWorkerGlobalScope.requestAnimationFrame")] struct WorkerRequestAnimationFrameArgs { diff --git a/moli-renderer-v8/src/worker/mod.rs b/moli-renderer-v8/src/worker/mod.rs index 4c0ce10f922..4af532dfd3a 100644 --- a/moli-renderer-v8/src/worker/mod.rs +++ b/moli-renderer-v8/src/worker/mod.rs @@ -49,23 +49,26 @@ pub(crate) use websocket_events::signal_worker_websocket_stream_pull; pub(crate) use data_url::decode_data_url_script_source; pub(crate) use global_scope::WorkerRedirectOwner; pub(crate) use global_scope::{ + abort_worker_event_source, cancel_worker_browser_timeout, NestedWorkerContext, WorkerFetchCompletion, WorkerFetchEvent, WorkerFetchResponse, WorkerFetchStreamingChunk, WorkerFetchStreamingFinished, WorkerFetchStreamingStarted, WorkerGlobalState, WorkerOpfsCompletion, WorkerWebCryptoCompletion, cancel_worker_opfs_task, check_and_queue_nested_worker_constructor_csp, check_worker_websocket_csp, check_worker_webtransport_csp, close_worker_websocket, + dispatch_worker_trusted_types_sink_violation_event, ensure_worker_opfs_directory_iterator_registry, ensure_worker_opfs_handle_registry, fetch_native_request, forget_worker_broadcast_channel_wrapper, forget_worker_message_port_wrapper, forward_nested_worker_error_after_owner_close, get_worker_state, install_service_worker_interface_template_bindings, queue_nested_worker_task, - queue_worker_font_task, register_nested_worker_handle, register_worker_blob_read_task, - register_worker_broadcast_channel_wrapper, register_worker_message_port_wrapper, - register_worker_opfs_iterator_task, register_worker_opfs_move_task, register_worker_opfs_task, - register_worker_webcrypto_task, register_worker_websocket, reserve_nested_worker_context, - send_worker_websocket_binary, send_worker_websocket_blob, send_worker_websocket_text, - service_worker_runtime_identity, set_worker_websocket_stream_abort_registration, + queue_worker_browser_timeout, queue_worker_font_task, register_nested_worker_handle, + register_worker_blob_read_task, register_worker_broadcast_channel_wrapper, + register_worker_message_port_wrapper, register_worker_opfs_iterator_task, + register_worker_opfs_move_task, register_worker_opfs_task, register_worker_webcrypto_task, + register_worker_websocket, reserve_nested_worker_context, send_worker_websocket_binary, + send_worker_websocket_blob, send_worker_websocket_text, service_worker_runtime_identity, + set_worker_websocket_stream_abort_registration, start_worker_event_source_request, start_worker_font_face_fetch, take_worker_websocket_stream_abort_registration, terminate_nested_worker, try_worker_xhr_abort_callback, try_worker_xhr_reschedule_timeout_after_timeout_change, try_worker_xhr_send_callback, diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index c451c4bad0f..fa91c34b6ad 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -686,6 +686,7 @@ fn worker_has_pending_async(state: &Rc>) -> bool { || !state.webtransport_tasks.is_empty() || !state.canvas_blob_tasks.is_empty() || !state.pending_fetches.is_empty() + || !state.browser_timeouts.is_empty() || !state.pending_xhrs.is_empty() || !state.websockets.is_empty() || !state.pending_webcrypto.is_empty() @@ -2006,6 +2007,8 @@ async fn worker_main( shared_memory_agent_cluster, fetch_completion_tx, pending_fetches: std::collections::HashMap::new(), + browser_timeouts: std::collections::HashMap::new(), + next_browser_timeout_id: 0, pending_network_body_sources: std::collections::HashMap::new(), pending_network_body_clones: std::collections::HashMap::new(), next_fetch_id: 0, diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs index 0b74b3b917e..922a7753710 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs @@ -165,7 +165,7 @@ async fn worker_unsupported_worker_related_constructors_throw_not_supported() { postMessage({ eventSource: describeUnsupported( "EventSource", - () => new EventSource("/events") + () => { const source = new EventSource("/events"); source.close(); } ), sharedWorker: typeof SharedWorker }); @@ -181,7 +181,7 @@ async fn worker_unsupported_worker_related_constructors_throw_not_supported() { .expect("channel closed"); assert_eq!( expect_post_json(msg), - r#"{"eventSource":"function|EventSource|1|true|true|[object EventSource]|NotSupportedError|9|This constructor is not implemented in dedicated workers yet.","sharedWorker":"undefined"}"# + r#"{"eventSource":"function|EventSource|1|true|true|[object EventSource]||0|","sharedWorker":"undefined"}"# ); }