Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(xhr): deliver early worker failures through the completion queue
ldm0f88dc644e475
diff --git a/moli-renderer-v8/src/worker/global_scope/xhr.rs b/moli-renderer-v8/src/worker/global_scope/xhr.rsindex 686226563..980c92500 100644--- a/moli-renderer-v8/src/worker/global_scope/xhr.rs+++ b/moli-renderer-v8/src/worker/global_scope/xhr.rs@@ -359,86 +359,39 @@ pub(crate) fn try_worker_xhr_send_callback<'s>(crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect,)};- if let Some(violation) = csp_violation {+ let request_error = if let Some(violation) = csp_violation {dispatch_worker_content_security_policy_violation_event_for_state(scope, &state, &violation,);- let message = worker_content_security_policy_error_message(&violation, "xhr");- record_worker_subresource_failure(- &state.borrow(),- prepared.document_url,- prepared.resolved_url,- prepared.method,- prepared.request_headers,- request_body_text(&prepared.send_body),- SubresourceResourceType::Xhr,- message,- );- apply_worker_xhr_request_failure(scope, xhr, async_request, &request_url);- return true;- }-- if let Err(error) = url_policy {- record_worker_subresource_failure(- &state.borrow(),- prepared.document_url,- prepared.resolved_url,- prepared.method,- prepared.request_headers,- request_body_text(&prepared.send_body),- SubresourceResourceType::Xhr,- error.to_string(),- );- apply_worker_xhr_request_failure(scope, xhr, async_request, &request_url);- return true;- }-- if should_request_be_blocked_due_to_bad_port(&prepared.resolved_url) {- record_worker_subresource_failure(- &state.borrow(),- prepared.document_url,- prepared.resolved_url.clone(),- prepared.method,- prepared.request_headers,- request_body_text(&prepared.send_body),- SubresourceResourceType::Xhr,- format!("xhr: blocked bad port for `{}`", prepared.resolved_url),- );- apply_worker_xhr_request_failure(scope, xhr, async_request, &request_url);- return true;- }-- if worker_url_blocked(&blocked_url_patterns, &prepared.resolved_url) {- record_worker_subresource_failure(- &state.borrow(),- prepared.document_url,- prepared.resolved_url,- prepared.method,- prepared.request_headers,- request_body_text(&prepared.send_body),- SubresourceResourceType::Xhr,- BLOCKED_BY_CLIENT_ERROR_TEXT.to_owned(),- );- apply_worker_xhr_request_failure(scope, xhr, async_request, &request_url);- return true;- }-- if network_offline {- record_worker_subresource_failure(- &state.borrow(),- prepared.document_url,- prepared.resolved_url,- prepared.method,- prepared.request_headers,- request_body_text(&prepared.send_body),- SubresourceResourceType::Xhr,- "Network emulation offline".to_owned(),- );- apply_worker_xhr_request_failure(scope, xhr, async_request, &request_url);+ Some(worker_content_security_policy_error_message(+ &violation, "xhr",+ ))+ } else if let Err(error) = url_policy {+ Some(error.to_string())+ } else if should_request_be_blocked_due_to_bad_port(&prepared.resolved_url) {+ Some(format!(+ "xhr: blocked bad port for `{}`",+ prepared.resolved_url+ ))+ } else if worker_url_blocked(&blocked_url_patterns, &prepared.resolved_url) {+ Some(BLOCKED_BY_CLIENT_ERROR_TEXT.to_owned())+ } else if network_offline {+ Some("Network emulation offline".to_owned())+ } else {+ None+ };+ if xhr_state_bool_property(scope, xhr, XHR_ABORTED_SLOT).unwrap_or(false)+ || worker_xhr_open_generation_changed(scope, xhr, open_generation)+ {return true;}- let local_response = local_url_response_result(&prepared.resolved_url, &prepared.method);+ // A rejected fetch still completes in a networking task. Keep the pending+ // XHR and its load lease until delivery so abort/open can cancel that task.+ let local_response = request_error.map(Err).or_else(|| {+ local_url_response_result(&prepared.resolved_url, &prepared.method)+ .map(|response| response.map_err(|error| error.to_string()))+ });if !async_request && let Some(result) = local_response {match result {Ok(response) => apply_xhr_response(scope, xhr, response),@@ -451,7 +404,7 @@ pub(crate) fn try_worker_xhr_send_callback<'s>(prepared.request_headers,request_body_text(&prepared.send_body),SubresourceResourceType::Xhr,- error.to_string(),+ error,);throw_synchronous_xhr_failure(scope, xhr, &request_url, "NetworkError");}@@ -478,7 +431,7 @@ pub(crate) fn try_worker_xhr_send_callback<'s>(SubresourceResourceType::Xhr,"Synchronous XMLHttpRequest interception is not supported".to_owned(),);- apply_worker_xhr_request_failure(scope, xhr, async_request, &request_url);+ throw_synchronous_xhr_failure(scope, xhr, &request_url, "NetworkError");return true;}@@ -528,9 +481,7 @@ pub(crate) fn try_worker_xhr_send_callback<'s>(let _ = state.borrow().xhr_completion_tx.send(WorkerXhrCompletion {xhr_id,network_request_headers: None,- result: result- .map(|response| WorkerXhrResponse::Materialized(Box::new(response)))- .map_err(|error| error.to_string()),+ result: result.map(|response| WorkerXhrResponse::Materialized(Box::new(response))),});return true;}@@ -806,19 +757,6 @@ fn send_synchronous_worker_xhr(}}-fn apply_worker_xhr_request_failure(- scope: &mut v8::PinScope<'_, '_>,- xhr: v8::Local<'_, v8::Object>,- async_request: bool,- request_url: &str,-) {- if async_request {- apply_xhr_failure(scope, xhr);- } else {- throw_synchronous_xhr_failure(scope, xhr, request_url, "NetworkError");- }-}-struct SynchronousWorkerXhrTimeout {wait_delay: Duration,configured_timeout: Duration,@@ -964,6 +902,23 @@ pub(in crate::worker) fn drain_worker_xhr_completion(state: &Rc<RefCell<WorkerGlobalState>>,completion: WorkerXhrCompletion,) {+ let xhr = {+ let state = state.borrow();+ let Some(pending) = state.pending_xhrs.get(&completion.xhr_id) else {+ return;+ };+ v8::Local::new(scope, &pending.xhr)+ };+ if xhr_state_number_property(scope, xhr, XHR_ACTIVE_INTERNAL_ID_SLOT)+ != Some(f64::from(completion.xhr_id))+ || !xhr_state_bool_property(scope, xhr, XHR_SEND_FLAG_SLOT).unwrap_or(false)+ || xhr_state_bool_property(scope, xhr, XHR_ABORTED_SLOT).unwrap_or(false)+ {+ if let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) {+ pending.load.cancel();+ }+ return;+ }let parent_tx = state.borrow().parent_tx.clone();if let Some(network_request_headers) = completion.network_request_headers.as_ref()&& let Some(record) = statediff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rsindex 3584222ee..8f545f69b 100644--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs@@ -1534,3 +1534,5 @@ mod strict_script_mime;mod network;mod postmessage;mod tls;++mod xhr_failure;diff --git a/moli-renderer-v8/src/worker/thread/tests/xhr_failure.rs b/moli-renderer-v8/src/worker/thread/tests/xhr_failure.rsnew file mode 100644index 000000000..53dbc4fc9--- /dev/null+++ b/moli-renderer-v8/src/worker/thread/tests/xhr_failure.rs@@ -0,0 +1,242 @@+use super::*;++const REJECTIONS: [(&str, &str, &str); 6] = [+ (+ "scheme",+ "invalid-protocol://example.test/xhr",+ "not supported",+ ),+ ("file", "file:///moli-policy-must-not-open", "not supported"),+ ("port", "http://example.test:25/xhr", "blocked bad port"),+ (+ "blocked",+ "http://example.test/xhr",+ "net::ERR_BLOCKED_BY_CLIENT",+ ),+ (+ "offline",+ "http://example.test/xhr",+ "Network emulation offline",+ ),+ ("csp", "http://example.test/xhr", "Content Security Policy"),+];++fn rejected_xhr_worker(case: &str, script: String) -> WorkerTestHandle {+ let policy = WorkerNetworkPolicy {+ blocked_url_patterns: if case == "blocked" {+ vec!["http://example.test/*".to_owned()]+ } else {+ vec![]+ },+ network_offline: case == "offline",+ ..WorkerNetworkPolicy::default()+ };+ spawn_test_worker_with_options(+ WorkerSpawnOptions::new(script, "http://example.test/worker.js".to_owned())+ .with_network_policy(policy)+ .with_content_security_policies(if case == "csp" {+ vec!["connect-src 'none'".to_owned()]+ } else {+ vec![]+ }),+ )+}++async fn collect_rejected_xhr_output(+ mut handle: WorkerTestHandle,+) -> (serde_json::Value, Vec<SubresourceNetworkRecord>) {+ let mut posts = vec![];+ let mut records = vec![];+ while let Some(message) = timeout(TIMEOUT, handle.recv())+ .await+ .expect("worker XHR should finish and close")+ {+ match message {+ WorkerToParentMessage::Post(payload) => {+ posts.push(serde_json::from_str(&stringify_payload(&payload)).unwrap());+ }+ WorkerToParentMessage::SubresourceNetwork(record) => records.push(record),+ other => panic!("unexpected worker XHR message: {other:?}"),+ }+ }+ assert_eq!(posts.len(), 1, "worker should post exactly one result");+ (posts.remove(0), records)+}++#[tokio::test]+async fn worker_xhr_early_failure_runs_after_send_and_microtasks() {+ ensure_v8();+ for (case, url, error_text) in REJECTIONS {+ let script = r#"+ const events = [];+ const xhr = new XMLHttpRequest();+ xhr.onreadystatechange = () => events.push("state:" + xhr.readyState);+ for (const [target, prefix] of [[xhr, "xhr"], [xhr.upload, "upload"]]) {+ for (const type of ["loadstart", "progress", "error", "abort", "load", "loadend"]) {+ target.addEventListener(type, event => events.push(+ `${prefix}:${type}:${event.loaded}:${event.total}:${event.lengthComputable}`));+ }+ }+ xhr.onloadend = () => {+ postMessage({ events, readyState: xhr.readyState, status: xhr.status });+ close();+ };+ xhr.open("GET", URL);+ xhr.send();+ events.push("returned:" + xhr.readyState);+ queueMicrotask(() => {+ events.push("microtask");+ xhr.onerror = () => events.push("late-error-listener");+ });+ "#+ .replace("URL", &serde_json::to_string(url).unwrap());+ let (result, records) =+ collect_rejected_xhr_output(rejected_xhr_worker(case, script)).await;+ assert_eq!(+ result,+ serde_json::json!({+ "events": [+ "state:1", "xhr:loadstart:0:0:false",+ "returned:1", "microtask", "state:4",+ "xhr:error:0:0:false", "late-error-listener",+ "xhr:loadend:0:0:false"+ ],+ "readyState": 4, "status": 0+ }),+ "{case}"+ );+ assert_eq!(records.len(), 1, "{case}: exactly one failure record");+ assert_eq!(records[0].url().as_str(), url);+ assert_eq!(records[0].resource_type(), SubresourceResourceType::Xhr);+ assert!(+ matches!(+ records[0].outcome(),+ SubresourceNetworkOutcome::Failure { error_text: actual } if actual.contains(error_text)+ ),+ "{case}: {:?}",+ records[0].outcome()+ );+ }+}++#[tokio::test]+async fn worker_xhr_early_failure_can_abort_or_reopen_before_delivery() {+ ensure_v8();+ for (case, url, _) in REJECTIONS {+ for action in ["abort", "microtask-abort", "reopen"] {+ let script = r#"+ const events = [];+ const xhr = new XMLHttpRequest();+ for (const target of [xhr, xhr.upload]) {+ for (const type of ["error", "abort", "load", "loadend"])+ target.addEventListener(type, () => events.push(+ `${target === xhr ? 'xhr' : 'upload'}:${type}`));+ }+ xhr.open("GET", URL);+ xhr.send();+ const returnedState = xhr.readyState;+ function cancel() {+ if (ACTION === "reopen") xhr.open("GET", "data:text/plain,reopened");+ else xhr.abort();+ }+ if (ACTION === "microtask-abort") queueMicrotask(cancel);+ else cancel();+ // A second XHR completes through the same queue, after the+ // canceled failure, so the observation cannot race a timer.+ const barrier = new XMLHttpRequest();+ barrier.onloadend = () => {+ postMessage({ returnedState, readyState: xhr.readyState, status: xhr.status, events });+ close();+ };+ barrier.open("GET", URL);+ barrier.send();+ "#+ .replace("URL", &serde_json::to_string(url).unwrap())+ .replace("ACTION", &serde_json::to_string(action).unwrap());+ let (result, records) =+ collect_rejected_xhr_output(rejected_xhr_worker(case, script)).await;+ let events = if action == "reopen" {+ vec![]+ } else {+ vec!["xhr:abort", "xhr:loadend"]+ };+ assert_eq!(+ result,+ serde_json::json!({+ "returnedState": 1, "readyState": if action == "reopen" { 1 } else { 0 },+ "status": 0, "events": events+ }),+ "{case}/{action}"+ );+ assert_eq!(+ records.len(),+ 1,+ "{case}/{action}: only the barrier may report failure"+ );+ }+ }+}++#[tokio::test]+async fn worker_xhr_early_failure_does_not_overwrite_a_new_send() {+ ensure_v8();+ let script = r#"+ const xhr = new XMLHttpRequest();+ const events = [];+ for (const type of ["error", "abort", "load", "loadend"])+ xhr.addEventListener(type, () => events.push(type));+ xhr.onloadend = () => {+ postMessage({ events, status: xhr.status, text: xhr.responseText });+ close();+ };+ xhr.open("GET", "invalid-protocol://example.test/old");+ xhr.send();+ xhr.open("GET", "data:text/plain,new-request");+ xhr.send();+ "#;+ let (result, records) =+ collect_rejected_xhr_output(rejected_xhr_worker("scheme", script.to_owned())).await;+ assert_eq!(+ result,+ serde_json::json!({+ "events": ["load", "loadend"], "status": 200, "text": "new-request"+ })+ );+ assert!(+ records.is_empty(),+ "superseded request must not report a late failure"+ );+}++#[tokio::test]+async fn worker_xhr_early_failure_still_throws_for_synchronous_requests() {+ ensure_v8();+ for (case, url, _) in REJECTIONS {+ let script = r#"+ const xhr = new XMLHttpRequest();+ const events = [];+ xhr.onreadystatechange = () => events.push("state:" + xhr.readyState);+ for (const target of [xhr, xhr.upload])+ for (const type of ["loadstart", "progress", "error", "abort", "load", "loadend"])+ target.addEventListener(type, () => events.push(type));+ xhr.open("GET", URL, false);+ let exception = null;+ try { xhr.send(); }+ catch (error) { exception = { name: error.name, domException: error instanceof DOMException }; }+ postMessage({ exception, events, readyState: xhr.readyState, status: xhr.status });+ close();+ "#+ .replace("URL", &serde_json::to_string(url).unwrap());+ let (result, records) =+ collect_rejected_xhr_output(rejected_xhr_worker(case, script)).await;+ assert_eq!(+ result,+ serde_json::json!({+ "exception": { "name": "NetworkError", "domException": true },+ "events": ["state:1"], "readyState": 4, "status": 0+ }),+ "{case}"+ );+ assert_eq!(records.len(), 1, "{case}: exactly one synchronous failure");+ }+}