Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(fetch): preserve worker abort reasons in response bodies

ldm09defda14afa8
diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs
index b587e63d5..204793d8d 100644
--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs
+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs
@@ -2411,10 +2411,10 @@ pub(in crate::worker) fn worker_fetch_callback<'s>(
rv.set(promise.into());
}
-pub(in crate::worker) fn reject_worker_fetches_for_signal(
- scope: &mut v8::PinScope<'_, '_>,
+pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
signal_id: u32,
- reason: v8::Local<'_, v8::Value>,
+ reason: v8::Local<'s, v8::Value>,
) {
let Some(state) = get_worker_state(scope) else {
return;
@@ -2487,12 +2487,11 @@ pub(in crate::worker) fn reject_worker_fetches_for_signal(
);
}
if let Some(body_source_id) = body_source_id {
- let abort_reason = worker_abort_error_value(scope);
error_pending_network_body_stream_with_reason(
scope,
body_source_id,
ABORTED_ERROR_TEXT.to_owned(),
- abort_reason,
+ reason,
);
} else {
let resolver = v8::Local::new(scope, &resolver);
diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
index 59db2a800..7423e1f6c 100644
--- a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
@@ -196,6 +196,7 @@ fn worker_client_snapshot_for_test(
mod background_apis_and_worker_events;
mod client_lifecycle_and_sync;
+mod fetch_abort_reasons;
mod fetch_events_and_messages;
mod messages_clients_and_windows;
mod worker_and_fetch_lifecycle;
diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_abort_reasons.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_abort_reasons.rs
new file mode 100644
index 000000000..a861bcd74
--- /dev/null
+++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_abort_reasons.rs
@@ -0,0 +1,76 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn worker_fetch_body_abort_preserves_signal_reason_for_all_body_methods() {
+ ensure_v8();
+ let listener = TcpListener::bind("127.0.0.1:0")
+ .await
+ .expect("bind worker fetch abort server");
+ let address = listener.local_addr().expect("worker fetch abort address");
+ let (stop_tx, mut stop_rx) = oneshot::channel::<()>();
+ let server = tokio::spawn(async move {
+ let mut response_stream = None;
+ loop {
+ let (mut stream, _) = tokio::select! {
+ _ = &mut stop_rx => break,
+ result = listener.accept() => result.expect("accept worker fetch abort request"),
+ };
+ let request = read_http_request_head(&mut stream)
+ .await
+ .expect("read worker fetch abort request");
+ if request.starts_with("GET /release?") {
+ // The assertion finishes before this request. Keep the original
+ // response incomplete until abort has rejected its Body promise.
+ drop(response_stream.take());
+ stream
+ .write_all(
+ b"HTTP/1.1 200 OK\r\nContent-Length: 8\r\nConnection: close\r\n\r\nreleased",
+ )
+ .await
+ .expect("write worker fetch release response");
+ } else {
+ assert!(request.starts_with("GET /stream?"), "{request}");
+ stream
+ .write_all(
+ b"HTTP/1.1 200 OK\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 9\r\nConnection: close\r\n\r\nfirst",
+ )
+ .await
+ .expect("write incomplete worker fetch body");
+ response_stream = Some(stream);
+ }
+ }
+ });
+ let script = format!(
+ "{}\n{}",
+ include_str!("../../../../../tests/fixtures/fetch-abort-reasons.js"),
+ r#"
+runFetchAbortReasonContract(location.href,'worker').then(result => {
+ postMessage(result);close();
+},error => {
+ postMessage({checks:[{name:'fixture completion',passed:false,detail:String(error.stack || error)}]});
+ close();
+});
+"#,
+ );
+ let loader =
+ ResourceRequestClient::new(&FetchConfig::default()).expect("worker fetch abort loader");
+ let mut handle = spawn_worker_with_request_client(
+ script,
+ format!("http://{address}/worker/main.js"),
+ loader,
+ );
+ let result = timeout(TIMEOUT, recv_post_json(&mut handle)).await;
+ handle.terminate_and_join();
+ let _ = stop_tx.send(());
+ server.await.expect("worker fetch abort server should stop");
+ let facts: serde_json::Value =
+ serde_json::from_str(&result.expect("worker fetch abort fixture should finish"))
+ .expect("worker fetch abort results should be JSON");
+ let checks = facts["checks"].as_array().expect("abort checks");
+ let failures = checks
+ .iter()
+ .filter(|check| check["passed"] != true)
+ .collect::<Vec<_>>();
+ assert!(failures.is_empty(), "{failures:#?}");
+ assert_eq!(checks.len(), 486);
+}
diff --git a/moli-renderer-v8/tests/fixtures/fetch-abort-reasons.js b/moli-renderer-v8/tests/fixtures/fetch-abort-reasons.js
new file mode 100644
index 000000000..d92a813ec
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/fetch-abort-reasons.js
@@ -0,0 +1,51 @@
+globalThis.runFetchAbortReasonContract = async function(base, prefix) {
+ const checks = [];
+ const check = (name, passed) => checks.push({name:`${prefix}/${name}`,passed:!!passed});
+ const reasonFor = kind => {
+ switch (kind) {
+ case 'default': return undefined;
+ case 'object': return {abort:'identity'};
+ case 'Error': return new Error('abort identity');
+ case 'DOMException': return new DOMException('abort identity','DataError');
+ case 'string': return 'abort identity';
+ case 'number': return 42;
+ case 'null': return null;
+ case 'Symbol': return Symbol('abort identity');
+ case 'function': return function abortReason() {};
+ }
+ };
+ const kinds = ['default','object','Error','DOMException','string','number','null','Symbol','function'];
+ for (const kind of kinds) {
+ for (const method of ['text','arrayBuffer','bytes','blob','json','formData']) {
+ for (const phase of ['pending','after-abort']) {
+ const name = `${kind}/${method}/${phase}`;
+ const id = `${prefix}-${kind}-${method}-${phase}`;
+ const endpoint = path => new URL(path+'?id='+encodeURIComponent(id),base).href;
+ const controller = new AbortController(), reason = reasonFor(kind);
+ try {
+ const response = await fetch(endpoint('/stream'),{signal:controller.signal});
+ check(`${name}/initial body unused`,!response.bodyUsed);
+ let pending, settled = false;
+ if (phase === 'pending') {
+ pending = response[method]();
+ pending.then(() => {settled = true;},() => {settled = true;});
+ for (let i = 0; i < 16; i++) await Promise.resolve();
+ check(`${name}/body waits for remaining network bytes`,!settled);
+ }
+ controller.abort(reason);
+ const expected = controller.signal.reason;
+ check(`${name}/signal keeps reason`,kind === 'default'
+ ? expected instanceof DOMException && expected.name === 'AbortError'
+ : expected === reason);
+ if (phase === 'after-abort') pending = response[method]();
+ const [result] = await Promise.allSettled([pending]);
+ check(`${name}/body rejects with exact signal reason`,result.status === 'rejected' && result.reason === expected);
+ check(`${name}/body is disturbed`,response.bodyUsed);
+ } finally {
+ await fetch(endpoint('/release')).then(response => response.text());
+ }
+ }
+ }
+ }
+ return {checks};
+};