mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 00:03:15 +00:00
feat(workers): support EventSource connections
Use Worker-owned fetch transport for EventSource in dedicated and shared workers, including CORS/CSP, service-worker responses, interception, streaming SSE parsing, reconnection and UTF-8 Last-Event-ID headers. Deliver state and messages as individual networking tasks. Keep connection callbacks separate from fetch Promise consumers, and use private delayed networking tasks that author timers cannot cancel. Close and Worker teardown cancel their transport and delayed work. Keep CONNECTING when a closing Worker discards connection tasks. Remove the unsupported constructor and cover both Worker kinds with fourteen API tests, retaining Window EventSource and existing Worker test identities.
This commit is contained in:
@@ -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"]
|
||||
|
||||
@@ -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<Mutex<Vec<serde_json::Value>>>,
|
||||
task: JoinHandle<()>,
|
||||
disconnected: Arc<tokio::sync::Notify>,
|
||||
}
|
||||
|
||||
impl Drop for EventSourceWorkerServer {
|
||||
fn drop(&mut self) {
|
||||
self.task.abort();
|
||||
}
|
||||
}
|
||||
|
||||
impl EventSourceWorkerServer {
|
||||
async fn spawn() -> Result<Self> {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").await?;
|
||||
let origin = format!("http://{}", listener.local_addr()?);
|
||||
let requests = Arc::new(Mutex::new(Vec::<serde_json::Value>::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", "<!doctype html><body>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::<Vec<_>>();
|
||||
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::<Vec<_>>();
|
||||
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(())
|
||||
}
|
||||
@@ -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 {
|
||||
|
||||
@@ -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::{
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -35,6 +35,7 @@ pub(crate) struct ControlledFetchStream {
|
||||
delivered: usize,
|
||||
timing: crate::worker::WorkerResourceTiming,
|
||||
response_filter: Option<crate::types::AsyncSubresourceFetchResponseFilter>,
|
||||
event_source_parser: Option<crate::network_host::EventSourceParser>,
|
||||
}
|
||||
|
||||
struct StreamedFetchResponse {
|
||||
@@ -45,6 +46,10 @@ struct StreamedFetchResponse {
|
||||
}
|
||||
|
||||
impl ControlledFetchStream {
|
||||
fn with_event_source_parser(mut self, parser: Option<crate::network_host::EventSourceParser>) -> Self {
|
||||
self.event_source_parser = parser;
|
||||
self
|
||||
}
|
||||
pub(super) fn set_response_filter(&mut self, filter: Option<crate::types::AsyncSubresourceFetchResponseFilter>) {
|
||||
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<crate::network_host::EventSourceParser>,
|
||||
) {
|
||||
// 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));
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
@@ -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<EventSourceParser> {
|
||||
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::<Vec<_>>();
|
||||
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<WorkerFetchEvent>,
|
||||
parser: &mut Option<EventSourceParser>,
|
||||
fetch_id: u32,
|
||||
body_source_id: NetworkBodySourceId,
|
||||
bytes: Vec<u8>,
|
||||
) {
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
fetch_id: u32,
|
||||
body_source_id: Option<NetworkBodySourceId>,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -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<RefCell<WorkerGlobalState>>,
|
||||
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();
|
||||
|
||||
@@ -1,17 +1,19 @@
|
||||
use super::*;
|
||||
|
||||
pub(super) struct NativeWorkerFetchRequest<'s> {
|
||||
pub(super) request: Request,
|
||||
pub(super) body_stream: Option<v8::Global<v8::Object>>,
|
||||
pub(super) body_stream_locked: bool,
|
||||
pub(super) signal: Option<v8::Local<'s, v8::Object>>,
|
||||
pub(super) blob_url_entry: Option<CapturedBlobUrl>,
|
||||
pub(super) kind: WorkerFetchKind,
|
||||
pub(super) timing: WorkerResourceTiming,
|
||||
pub(super) font_face: Option<v8::Local<'s, v8::Object>>,
|
||||
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<v8::Local<'s, v8::Object>>,
|
||||
pub(in crate::worker::global_scope) admission_error: Option<String>,
|
||||
pub(in crate::worker::global_scope) body_stream: Option<v8::Global<v8::Object>>,
|
||||
pub(in crate::worker::global_scope) body_stream_locked: bool,
|
||||
pub(in crate::worker::global_scope) signal: Option<v8::Local<'s, v8::Object>>,
|
||||
pub(in crate::worker::global_scope) blob_url_entry: Option<CapturedBlobUrl>,
|
||||
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<v8::Local<'s, v8::Object>>,
|
||||
}
|
||||
|
||||
pub(super) fn start<'s>(
|
||||
pub(in crate::worker::global_scope) fn start<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
state: &Rc<RefCell<WorkerGlobalState>>,
|
||||
request: NativeWorkerFetchRequest<'s>,
|
||||
@@ -20,7 +22,7 @@ pub(super) fn start<'s>(
|
||||
metadata: ServiceWorkerFetchRequestMetadata,
|
||||
policy_context: SubresourcePolicyContext,
|
||||
) -> Option<v8::Local<'s, v8::Promise>> {
|
||||
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)
|
||||
|
||||
@@ -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};
|
||||
|
||||
@@ -2,12 +2,54 @@
|
||||
|
||||
use super::*;
|
||||
|
||||
pub(in crate::worker) enum WorkerFetchClient {
|
||||
Promise {
|
||||
resolver: v8::Global<v8::PromiseResolver>,
|
||||
font_face: Option<v8::Global<v8::Object>>,
|
||||
},
|
||||
EventSource(v8::Global<v8::Object>),
|
||||
}
|
||||
|
||||
impl WorkerFetchClient {
|
||||
pub(super) fn resolver(&self) -> &v8::Global<v8::PromiseResolver> {
|
||||
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<v8::Object>> {
|
||||
match self {
|
||||
Self::Promise { font_face, .. } => font_face.as_ref(),
|
||||
Self::EventSource(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn event_source(&self) -> Option<&v8::Global<v8::Object>> {
|
||||
match self {
|
||||
Self::EventSource(source) => Some(source),
|
||||
Self::Promise { .. } => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(in crate::worker) struct PendingWorkerFetch {
|
||||
pub(in crate::worker) upload: Option<crate::network_host::RequestUpload>,
|
||||
pub(super) timing: WorkerResourceTiming,
|
||||
pub(in crate::worker) kind: fetch::WorkerFetchKind,
|
||||
pub(in crate::worker) font_face: Option<v8::Global<v8::Object>>,
|
||||
pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,
|
||||
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<u32>,
|
||||
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,
|
||||
|
||||
@@ -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",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<WorkerFetchEvent>,
|
||||
/// Promise resolvers pending async fetch completion.
|
||||
/// Fetch promises, font loads and EventSource connections pending network work.
|
||||
pub(in crate::worker) pending_fetches: HashMap<u32, PendingWorkerFetch>,
|
||||
pub(in crate::worker) browser_timeouts: HashMap<u32, super::timers::WorkerBrowserTimeout>,
|
||||
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<NetworkBodySourceId, crate::network_host::PendingNetworkBodySourceState>,
|
||||
|
||||
@@ -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<u32> {
|
||||
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<RefCell<WorkerGlobalState>>,
|
||||
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 {
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -686,6 +686,7 @@ fn worker_has_pending_async(state: &Rc<RefCell<WorkerGlobalState>>) -> 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,
|
||||
|
||||
@@ -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"}"#
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user