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(fetch): bind response progress to individual transfers
ldm073e12a28f45a
diff --git a/moli-fetch/src/blocking/collectors.rs b/moli-fetch/src/blocking/collectors.rsindex a8c7385d6..94135278e 100644--- a/moli-fetch/src/blocking/collectors.rs+++ b/moli-fetch/src/blocking/collectors.rs@@ -13,6 +13,7 @@ use url::Url;use crate::{FetchCancelHandle, FetchConfig, NegotiatedHttpVersion, NetworkRequestExtraInfo, Request,+ cancellation::ResponseProgress,client_hints::{ClientHintResponseAction, ClientHintResponsePolicy},headers::{decode_http_header_bytes, parse_http_response_header_line},response::parse_http_response_status_line,@@ -260,6 +261,8 @@ pub struct RawStreamingResponseCollector {client_hint_response_policy: Option<ClientHintResponsePolicy>,client_hint_restart_requested: bool,cancel_handle: FetchCancelHandle,+ response_progress: ResponseProgress,+ follow_redirects: bool,negotiated_http_version: Option<NegotiatedHttpVersion>,network_request_extra_info: Option<NetworkRequestExtraInfo>,}@@ -654,6 +657,7 @@ impl RawStreamingResponseCollector {body_tx: mpsc::UnboundedSender<Vec<u8>>,cancel_handle: FetchCancelHandle,) -> Self {+ let response_progress = cancel_handle.response_progress();Self {cookie_store,headers: Vec::new(),@@ -681,12 +685,14 @@ impl RawStreamingResponseCollector {client_hint_response_policy: None,client_hint_restart_requested: false,cancel_handle,+ response_progress,+ follow_redirects: true,negotiated_http_version: None,network_request_extra_info: None,}}- pub fn begin_request(+ fn begin_request(&mut self,max_response_size: Option<usize>,current_url: Url,@@ -694,6 +700,7 @@ impl RawStreamingResponseCollector {request_cookie_report: Option<StoredCookieQueryReport>,response_credentials_allowed: bool,redirect_chain: Vec<RedirectInfo>,+ response_progress: ResponseProgress,) {self.headers.clear();self.status_text = None;@@ -704,7 +711,8 @@ impl RawStreamingResponseCollector {self.response_too_large = false;self.response_bytes_received = 0;self.declared_identity_body_length = None;- self.cancel_handle.reset_response_progress();+ self.response_progress = response_progress;+ self.follow_redirects = true;self.cache_body_writer = None;self.cache_plan = None;self.started = false;@@ -733,6 +741,8 @@ impl RawStreamingResponseCollector {network_request_extra_info: Option<NetworkRequestExtraInfo>,cache_plan: Option<StreamingCachePlan>,defer_not_modified_start: bool,+ response_progress: ResponseProgress,+ follow_redirects: bool,) {self.begin_request(max_response_size,@@ -741,10 +751,12 @@ impl RawStreamingResponseCollector {request_cookie_report,response_credentials_allowed,redirect_chain,+ response_progress,);self.network_request_extra_info = network_request_extra_info;self.cache_plan = cache_plan;self.defer_not_modified_start = defer_not_modified_start;+ self.follow_redirects = follow_redirects;}pub(crate) fn status_text(&self) -> Option<&str> {@@ -866,11 +878,19 @@ impl RawStreamingResponseCollector {}self.declared_identity_body_length = identity_encoded_content_length(&self.headers);if self.declared_identity_body_length == Some(0) {- self.cancel_handle.mark_declared_response_body_complete();+ self.response_progress.commit();}self.maybe_create_cache_body_writer();- self.maybe_emit_start();- if response_body_ends_at_headers(self.status) && self.started {+ let is_redirect_response =+ next_redirect_url_from_parts(¤t_url, self.status, &self.headers, 0)+ .ok()+ .flatten()+ .is_some();+ self.maybe_emit_start(is_redirect_response);+ if self.started && (response_body_ends_at_headers(self.status) || is_redirect_response) {+ // Manual redirects expose their head with an empty body. Stop the+ // transport here so neither streaming nor buffered callers wait+ // for bytes that this API discards.self.finish_streaming_body();self.header_terminated = true;return false;@@ -897,18 +917,14 @@ impl RawStreamingResponseCollector {}}- fn maybe_emit_start(&mut self) {+ fn maybe_emit_start(&mut self, is_redirect_response: bool) {if self.started || self.response_too_large {return;}let Some(current_url) = self.current_url.clone() else {return;};- if next_redirect_url_from_parts(¤t_url, self.status, &self.headers, 0)- .ok()- .flatten()- .is_some()- {+ if self.follow_redirects && is_redirect_response {return;}if self.defer_not_modified_start && self.status == 304 {@@ -1139,7 +1155,7 @@ impl Handler for RawStreamingResponseCollector {self.response_bytes_received += data.len();if self.declared_identity_body_length == Some(self.response_bytes_received) {- self.cancel_handle.mark_declared_response_body_complete();+ self.response_progress.commit();}self.write_cache_body_bytes(data);self.send_chunk(data);@@ -1251,6 +1267,7 @@ mod tests {) {let (start_tx, _start_rx) = oneshot::channel();let (body_tx, body_rx) = mpsc::unbounded_channel();+ let response_progress = cancel_handle.begin_response_progress();let mut collector = RawStreamingResponseCollector::new(new_shared_browser_cookie_store(),start_tx,@@ -1264,6 +1281,7 @@ mod tests {None,true,Vec::new(),+ response_progress,);assert!(collector.header(b"HTTP/1.1 200 OK\r\n"));for header in headers {@@ -1297,6 +1315,20 @@ mod tests {assert!(cancel_handle.response_completion_is_committed());}+ #[test]+ fn raw_streaming_late_callback_cannot_commit_a_reused_handle() {+ let cancel_handle = FetchCancelHandle::new();+ let (mut old, _old_body) =+ raw_streaming_collector_with_headers(cancel_handle.clone(), &["Content-Length: 4"]);+ let (mut current, _current_body) =+ raw_streaming_collector_with_headers(cancel_handle.clone(), &["Content-Length: 4"]);++ assert_eq!(old.write(b"late").unwrap(), 4);+ assert!(!cancel_handle.response_completion_is_committed());+ assert_eq!(current.write(b"body").unwrap(), 4);+ assert!(cancel_handle.response_completion_is_committed());+ }+#[test]fn raw_streaming_framed_or_encoded_body_waits_for_transport_terminal() {for headers in [diff --git a/moli-fetch/src/cancellation.rs b/moli-fetch/src/cancellation.rsindex 1cd41e959..79f9236c0 100644--- a/moli-fetch/src/cancellation.rs+++ b/moli-fetch/src/cancellation.rs@@ -1,21 +1,52 @@use std::sync::{Arc,- atomic::{AtomicBool, Ordering},+ atomic::{AtomicBool, AtomicU8, Ordering},};use parking_lot::Mutex;-#[derive(Debug, Default)]-struct ResponseProgress {- declared_body_complete: AtomicBool,- terminal: AtomicBool,+const RESPONSE_PENDING: u8 = 0;+const RESPONSE_COMMITTED: u8 = 1;+const RESPONSE_CANCELLED: u8 = 2;++/// A writer token for one transfer. Replacing a handle's selected progress+/// never redirects an existing writer to a different transfer.+#[derive(Debug, Clone, Default)]+pub(crate) struct ResponseProgress {+ state: Arc<AtomicU8>,+}++impl ResponseProgress {+ pub(crate) fn commit(&self) {+ let _ = self.state.compare_exchange(+ RESPONSE_PENDING,+ RESPONSE_COMMITTED,+ Ordering::AcqRel,+ Ordering::Acquire,+ );+ }++ fn is_committed(&self) -> bool {+ self.state.load(Ordering::Acquire) == RESPONSE_COMMITTED+ }++ fn cancel_if_pending(&self) -> bool {+ self.state.compare_exchange(+ RESPONSE_PENDING,+ RESPONSE_CANCELLED,+ Ordering::AcqRel,+ Ordering::Acquire,+ ) != Err(RESPONSE_COMMITTED)+ }}#[derive(Debug, Default)]struct FetchLifecycleState {cancel_requested: AtomicBool,parent: Option<Arc<FetchLifecycleState>>,- response_progress: Mutex<Arc<ResponseProgress>>,+ // This lock protects selection, while the selected token arbitrates+ // transport completion and consumer cancellation without taking the lock.+ response_progress: Mutex<ResponseProgress>,}#[derive(Debug, Clone, Default)]@@ -32,6 +63,18 @@ impl FetchCancelHandle {self.state.cancel_requested.store(true, Ordering::SeqCst);}+ /// Cancels only if this response's transport result has not committed.+ /// Completion and this cancellation compete on the same atomic state, so+ /// a completion arriving between a separate check and cancel cannot lose.+ pub fn cancel_if_response_pending(&self) -> bool {+ let progress = self.state.response_progress.lock();+ if !progress.cancel_if_pending() {+ return false;+ }+ self.cancel();+ true+ }+pub fn is_cancelled(&self) -> bool {let mut state = self.state.as_ref();loop {@@ -59,7 +102,9 @@ impl FetchCancelHandle {/// Selects the accepted final response's transport progress. This shares/// already recorded and future completion facts, without retaining the- /// child's cancellation state (which itself retains the parent).+ /// child's cancellation state (which itself retains the parent). Call only+ /// after the accepted response's headers arrive: selection is a snapshot,+ /// and starting another transfer on the child does not change this choice.pub fn adopt_response_progress(&self, response: &Self) {let progress = response.state.response_progress.lock().clone();*self.state.response_progress.lock() = progress;@@ -68,32 +113,20 @@ impl FetchCancelHandle {/// Returns whether transport facts already determine this response's/// terminal result, so a later consumer cancellation must not replace it.pub fn response_completion_is_committed(&self) -> bool {- let progress = self.state.response_progress.lock();- progress.declared_body_complete.load(Ordering::Acquire)- || progress.terminal.load(Ordering::Acquire)+ self.state.response_progress.lock().is_committed()}- /// Starts a new logical transfer without clearing cancellation. Detaching- /// the previous progress also prevents an old hop's late completion from- /// committing this new transfer.- pub fn reset_response_progress(&self) {- *self.state.response_progress.lock() = Arc::default();+ /// Starts a transfer without clearing cancellation and returns its writer.+ /// Every callback must retain this token instead of looking up whichever+ /// progress happens to be selected when the callback eventually runs.+ pub(crate) fn begin_response_progress(&self) -> ResponseProgress {+ let progress = ResponseProgress::default();+ *self.state.response_progress.lock() = progress.clone();+ progress}- pub(crate) fn mark_declared_response_body_complete(&self) {- self.state- .response_progress- .lock()- .declared_body_complete- .store(true, Ordering::Release);- }-- pub(crate) fn mark_response_terminal(&self) {- self.state- .response_progress- .lock()- .terminal- .store(true, Ordering::Release);+ pub(crate) fn response_progress(&self) -> ResponseProgress {+ self.state.response_progress.lock().clone()}}@@ -107,13 +140,16 @@ mod tests {let observer = handle.clone();assert!(!observer.response_completion_is_committed());- handle.mark_declared_response_body_complete();+ let first = handle.response_progress();+ first.commit();assert!(observer.response_completion_is_committed());- handle.reset_response_progress();+ let second = handle.begin_response_progress();assert!(!observer.response_completion_is_committed());- handle.mark_response_terminal();+ first.commit();+ assert!(!observer.response_completion_is_committed());+ second.commit();assert!(observer.response_completion_is_committed());}@@ -134,34 +170,131 @@ mod tests {#[test]fn only_selected_response_progress_commits_the_parent() {for complete_before_selection in [false, true] {- for declared_body in [false, true] {- let parent = FetchCancelHandle::new();- let discarded = parent.child_for_subrequest();- discarded.mark_response_terminal();- assert!(!parent.response_completion_is_committed());- let response = parent.child_for_subrequest();- let complete = || {- if declared_body {- response.mark_declared_response_body_complete();- } else {- response.mark_response_terminal();- }- };- if complete_before_selection {- complete();- }- parent.adopt_response_progress(&response);- assert_eq!(- parent.response_completion_is_committed(),- complete_before_selection- );- complete();- assert!(parent.response_completion_is_committed());- parent.reset_response_progress();- response.mark_response_terminal();- assert!(!parent.response_completion_is_committed());- assert!(!parent.is_cancelled());+ let parent = FetchCancelHandle::new();+ let discarded = parent.child_for_subrequest();+ let discarded_writer = discarded.begin_response_progress();+ discarded_writer.commit();+ assert!(!parent.response_completion_is_committed());+ let response = parent.child_for_subrequest();+ let writer = response.begin_response_progress();+ if complete_before_selection {+ writer.commit();}+ parent.adopt_response_progress(&response);+ assert_eq!(+ parent.response_completion_is_committed(),+ complete_before_selection+ );+ discarded_writer.commit();+ writer.commit();+ assert!(parent.response_completion_is_committed());+ parent.begin_response_progress();+ writer.commit();+ assert!(!parent.response_completion_is_committed());+ assert!(!parent.is_cancelled());+ }+ }++ #[test]+ fn selected_response_keeps_its_writer_when_child_starts_another_transfer() {+ let parent = FetchCancelHandle::new();+ let child = parent.child_for_subrequest();+ let selected = child.begin_response_progress();+ parent.adopt_response_progress(&child);+ let next = child.begin_response_progress();++ next.commit();+ assert!(!parent.response_completion_is_committed());+ selected.commit();+ assert!(parent.response_completion_is_committed());+ }++ #[test]+ fn committed_response_wins_later_consumer_cancellation() {+ let parent = FetchCancelHandle::new();+ let child = parent.child_for_subrequest();+ let writer = child.begin_response_progress();+ parent.adopt_response_progress(&child);+ writer.commit();++ assert!(!parent.cancel_if_response_pending());+ assert!(!parent.is_cancelled());+ assert!(!child.is_cancelled());+ }++ #[test]+ fn consumer_cancellation_wins_later_completion() {+ let parent = FetchCancelHandle::new();+ let child = parent.child_for_subrequest();+ let writer = child.begin_response_progress();+ parent.adopt_response_progress(&child);++ assert!(parent.cancel_if_response_pending());+ writer.commit();+ assert!(!parent.response_completion_is_committed());+ assert!(parent.is_cancelled());+ assert!(child.is_cancelled());+ }++ #[test]+ fn completion_and_consumer_cancellation_have_one_winner() {+ for _ in 0..64 {+ let handle = FetchCancelHandle::new();+ let writer = handle.begin_response_progress();+ let ready = std::sync::Barrier::new(2);+ std::thread::scope(|scope| {+ let completion = scope.spawn(|| {+ ready.wait();+ writer.commit();+ });+ ready.wait();+ let cancelled = handle.cancel_if_response_pending();+ completion.join().unwrap();+ assert_eq!(handle.response_completion_is_committed(), !cancelled);+ assert_eq!(handle.is_cancelled(), cancelled);+ });+ }+ }++ #[test]+ fn late_completion_during_selection_cannot_commit_a_new_transfer() {+ let parent = FetchCancelHandle::new();+ let child = parent.child_for_subrequest();+ let old_writer = child.begin_response_progress();+ let current_writer = child.begin_response_progress();+ std::thread::scope(|scope| {+ let completion = scope.spawn(move || old_writer.commit());+ parent.adopt_response_progress(&child);+ completion.join().unwrap();+ });+ assert!(!parent.response_completion_is_committed());+ current_writer.commit();+ assert!(parent.response_completion_is_committed());+ }++ #[test]+ fn concurrent_selection_and_transfer_start_keep_a_stable_snapshot() {+ for _ in 0..32 {+ let parent = FetchCancelHandle::new();+ let child = parent.child_for_subrequest();+ let first = child.begin_response_progress();+ let ready = std::sync::Barrier::new(2);+ let second = std::thread::scope(|scope| {+ let restart = scope.spawn(|| {+ ready.wait();+ child.begin_response_progress()+ });+ ready.wait();+ parent.adopt_response_progress(&child);+ restart.join().unwrap()+ });+ // Selection may observe either transfer. A subsequent restart+ // must leave that snapshot and both existing writers intact.+ child.begin_response_progress();+ first.commit();+ second.commit();+ assert!(parent.response_completion_is_committed());+ assert!(!child.response_completion_is_committed());}}}diff --git a/moli-fetch/src/runtime.rs b/moli-fetch/src/runtime.rsindex c18648eb6..3db968caf 100644--- a/moli-fetch/src/runtime.rs+++ b/moli-fetch/src/runtime.rs@@ -50,6 +50,7 @@ use crate::{remove_cached_response, response_headers_forbid_cache_storage, store_response_cookies,transfer_metrics_from_easy, validation_headers_for_cached_streaming_response_lookup,},+ cancellation::ResponseProgress,client_hints::{ClientHintResponseAction, ClientHintResponsePolicy, SharedClientHintPreferences,SharedNavigationClientHintRestarts, prepare_client_hint_request,@@ -1213,6 +1214,7 @@ impl RuntimeOwner {anyhow::Error,),> {+ job.response_progress = job.cancel_handle.begin_response_progress();if let Err(error) = job.request.validate_request_mode_for_url(&job.current_url) {return Err((Box::new(job), None, error));}@@ -1345,6 +1347,8 @@ impl RuntimeOwner {request_extra_info.clone(),cache_plan,stale_cached_lookup.is_some(),+ job.response_progress.clone(),+ job.request.follow_redirects,);collector.set_client_hint_response_policy(prepared_request.response_policy);@@ -2312,7 +2316,7 @@ impl RuntimeOwner {return;}- job.cancel_handle.mark_response_terminal();+ job.response_progress.commit();let (started_tx, cache_body_writer) = {let streaming = easy.get_mut()@@ -2357,7 +2361,7 @@ impl RuntimeOwner {return;}- job.cancel_handle.mark_response_terminal();+ job.response_progress.commit();let cache_body_writer = {let streaming = easy.get_mut()@@ -2567,6 +2571,7 @@ struct StreamingRuntimeJob {body_tx: Option<mpsc::UnboundedSender<String>>,completion_tx: RuntimeStreamingCompletionTx,cancel_handle: FetchCancelHandle,+ response_progress: ResponseProgress,easy: Option<Easy2<FetchTransferHandler>>,http_version: RequestHttpVersion,empty_http_https_upgrade_attempted: bool,@@ -2582,6 +2587,7 @@ impl StreamingRuntimeJob {cancel_handle: FetchCancelHandle,) -> Self {let origin_key = origin_key(&request);+ let response_progress = cancel_handle.response_progress();Self {current_url: request.url.clone(),current_cookie_context: request.network_cookie_context(),@@ -2592,6 +2598,7 @@ impl StreamingRuntimeJob {body_tx: Some(body_tx),completion_tx,cancel_handle,+ response_progress,easy: None,http_version: RequestHttpVersion::PreferHttp2,empty_http_https_upgrade_attempted: false,@@ -2610,6 +2617,7 @@ struct StreamingRawRuntimeJob {body_tx: Option<mpsc::UnboundedSender<Vec<u8>>>,completion_tx: RuntimeStreamingCompletionTx,cancel_handle: FetchCancelHandle,+ response_progress: ResponseProgress,easy: Option<Easy2<FetchTransferHandler>>,http_version: RequestHttpVersion,empty_http_https_upgrade_attempted: bool,@@ -2625,6 +2633,7 @@ impl StreamingRawRuntimeJob {cancel_handle: FetchCancelHandle,) -> Self {let origin_key = origin_key(&request);+ let response_progress = cancel_handle.response_progress();Self {current_url: request.url.clone(),current_cookie_context: request.network_cookie_context(),@@ -2635,6 +2644,7 @@ impl StreamingRawRuntimeJob {body_tx: Some(body_tx),completion_tx,cancel_handle,+ response_progress,easy: None,http_version: RequestHttpVersion::PreferHttp2,empty_http_https_upgrade_attempted: false,@@ -3051,7 +3061,7 @@ fn complete_cached_streaming_raw_job(cached: CachedStreamingResponseLookup,request_cookie_report: Option<StoredCookieQueryReport>,) {- job.cancel_handle.mark_response_terminal();+ job.response_progress.commit();let redirected = !job.request.redirect_chain.is_empty();let redirect_chain = job.request.redirect_chain.clone();let CachedStreamingResponseLookup {@@ -3566,7 +3576,7 @@ fn complete_streaming_proxy_connect_response(.expect("proxy CONNECT streaming response should use streaming collector").take_response_channels();drop(body_tx);- job.cancel_handle.mark_response_terminal();+ job.response_progress.commit();if let Some(started_tx) = started_tx {let _ = started_tx.send(Ok(start));}@@ -3591,7 +3601,7 @@ fn complete_raw_streaming_proxy_connect_response(.expect("proxy CONNECT raw response should use raw streaming collector").take_response_channels();drop(body_tx);- job.cancel_handle.mark_response_terminal();+ job.response_progress.commit();if let Some(started_tx) = started_tx {let _ = started_tx.send(Ok(start));}@@ -3694,7 +3704,7 @@ fn fail_raw_streaming_job_with_easy(&job.request.redirect_chain,error,);- job.cancel_handle.mark_response_terminal();+ job.response_progress.commit();if let Some(easy) = easy.as_mut()&& let Some(streaming) = easy.get_mut().raw_streaming_mut(){diff --git a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rsindex 917f9226c..f5ea94294 100644--- a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs@@ -2083,7 +2083,7 @@ impl JsContextHost {if self.streaming_subresource_fetches.get(&internal_id)- .is_some_and(|streaming| streaming.pending.load.response_completion_is_committed())+ .is_some_and(|streaming| !streaming.pending.load.cancel_if_response_pending()){// The network owner has already accepted a complete declared body// or a real terminal result. Keep the stream registered so that itsdiff --git a/moli-renderer-v8/src/network/loads/registry.rs b/moli-renderer-v8/src/network/loads/registry.rsindex 0f8c09a38..3f3e1132f 100644--- a/moli-renderer-v8/src/network/loads/registry.rs+++ b/moli-renderer-v8/src/network/loads/registry.rs@@ -572,13 +572,18 @@ impl ResourceLoadLease {self.registration.cancelled.load(Ordering::Acquire)}- pub(crate) fn response_completion_is_committed(&self) -> bool {- self.registration+ pub(crate) fn cancel_if_response_pending(&self) -> bool {+ let should_cancel = self+ .registration.lifecycle.lock().cancel_handle.as_ref()- .is_some_and(FetchCancelHandle::response_completion_is_committed)+ .is_none_or(FetchCancelHandle::cancel_if_response_pending);+ if should_cancel {+ self.cancel();+ }+ should_cancel}pub(crate) fn is_detached_keepalive(&self) -> bool {diff --git a/moli-renderer-v8/src/network_host/async_fetch.rs b/moli-renderer-v8/src/network_host/async_fetch.rsindex ad249e549..c885e9d37 100644--- a/moli-renderer-v8/src/network_host/async_fetch.rs+++ b/moli-renderer-v8/src/network_host/async_fetch.rs@@ -91,7 +91,12 @@ async fn fetch_browser_subresource_with_preflight_headers_and_observer(preflight_observer,).await?;- fetch_once_with_network_metadata(&loader, request, cancel_handle).await+ let cancel_handle = cancel_handle.unwrap_or_default();+ let response_cancel = cancel_handle.child_for_subrequest();+ let observed =+ fetch_once_with_network_metadata(&loader, request, Some(response_cancel.clone())).await?;+ cancel_handle.adopt_response_progress(&response_cancel);+ Ok(observed)}pub(crate) fn browser_request_needs_manual_preflight_redirects(@@ -236,27 +241,33 @@ async fn fetch_browser_subresource_with_manual_preflight_redirects(preflight_observer: Option<&CorsPreflightNetworkObserver>,) -> Result<NetworkFetchResult<Response>, String> {let mut redirects = ManualCorsRedirectState::new(request, preflight_request_headers);+ let cancel_handle = cancel_handle.unwrap_or_default();loop {redirects- .run_current_hop_preflight(&loader, cancel_handle.clone(), preflight_observer)+ .run_current_hop_preflight(&loader, Some(cancel_handle.clone()), preflight_observer).await?;+ let response_cancel = cancel_handle.child_for_subrequest();let mut observed = fetch_once_with_network_metadata_unvalidated(&loader,redirects.hop_request(),- cancel_handle.clone(),+ Some(response_cancel.clone()),).await?;let network_extra_info_available = observed.request_observation().is_some();match redirects.advance(observed.response().head(), network_extra_info_available)? {ManualCorsRedirectTransition::FinalResponse => {+ cancel_handle.adopt_response_progress(&response_cancel);let redirect_chain = redirects.into_redirect_chain();observed.response_mut().redirected = !redirect_chain.is_empty();observed.response_mut().redirect_chain = redirect_chain;return Ok(observed);}- ManualCorsRedirectTransition::ManualResponse { .. } => return Ok(observed),+ ManualCorsRedirectTransition::ManualResponse { .. } => {+ cancel_handle.adopt_response_progress(&response_cancel);+ return Ok(observed);+ }ManualCorsRedirectTransition::FollowedRedirect => {}}}@@ -270,16 +281,17 @@ async fn fetch_browser_subresource_raw_stream_with_manual_preflight_redirects(preflight_observer: Option<&CorsPreflightNetworkObserver>,) -> Result<NetworkFetchResult<StreamingRawResponse>, String> {let mut redirects = ManualCorsRedirectState::new(request, preflight_request_headers);+ let cancel_handle = cancel_handle.unwrap_or_default();loop {redirects- .run_current_hop_preflight(loader, cancel_handle.clone(), preflight_observer)+ .run_current_hop_preflight(loader, Some(cancel_handle.clone()), preflight_observer).await?;let mut observed = loader.fetch_raw_stream_with_cancel_and_network_metadata(redirects.hop_request(),- cancel_handle.clone().unwrap_or_default(),+ cancel_handle.child_for_subrequest(),).await.map_err(format_network_error)?;@@ -287,6 +299,7 @@ async fn fetch_browser_subresource_raw_stream_with_manual_preflight_redirects(let head = observed.response().head();match redirects.advance(head, network_extra_info_available)? {ManualCorsRedirectTransition::FinalResponse => {+ cancel_handle.adopt_response_progress(&observed.response().cancellation_handle());let redirect_chain = redirects.into_redirect_chain();observed.response_mut().redirected = !redirect_chain.is_empty();observed.response_mut().redirect_chain = redirect_chain;@@ -301,14 +314,9 @@ async fn fetch_browser_subresource_raw_stream_with_manual_preflight_redirects(ManualCorsRedirectTransition::FollowedRedirect => {}}- // Redirect bodies are not exposed to Fetch/XHR. Finish this hop before- // reusing the logical request's cancel handle for the redirected hop;- // the final non-redirect response remains headers-first and streaming.- observed- .response_mut()- .finish()- .await- .map_err(format_network_error)?;+ // Dropping this hop retires only its transport. Its body and late+ // completion cannot cancel or commit the logical request's next hop.+ drop(observed);}}@@ -383,10 +391,14 @@ async fn fetch_browser_subresource_raw_stream_with_preflight_headers_and_observelet cancel_handle = cancel_handle.unwrap_or_default();let redirect_mode = request.redirect_mode;let result = loader- .fetch_raw_stream_with_cancel_and_network_metadata(request, cancel_handle)+ .fetch_raw_stream_with_cancel_and_network_metadata(+ request,+ cancel_handle.child_for_subrequest(),+ ).await.map_err(format_network_error)?;validate_redirect_mode_response_head(&result.response().head(), redirect_mode)?;+ cancel_handle.adopt_response_progress(&result.response().cancellation_handle());Ok(result)}@@ -441,7 +453,9 @@ async fn run_cors_preflight_if_needed(let preflight_response = match fetch_response_head_once(loader,preflight_request,- cancel_handle.clone(),+ cancel_handle+ .as_ref()+ .map(FetchCancelHandle::child_for_subrequest),).await{@@ -820,13 +834,13 @@ async fn fetch_response_head_once(}let cancel_handle = cancel_handle.unwrap_or_default();- let mut response = loader+ let response = loader.fetch_raw_stream_with_cancel(request, cancel_handle).await.map_err(format_network_error)?;- let head = response.head();- response.finish().await.map_err(format_network_error)?;- Ok(head)+ // Preflight validation consumes only the headers. Its private cancellation+ // authority lets Drop stop a slow body without aborting the actual request.+ Ok(response.head())}fn validate_redirect_mode_response(@@ -1045,6 +1059,226 @@ mod tests {Ok(())}+ #[tokio::test(flavor = "multi_thread")]+ async fn preflight_body_cancellation_does_not_commit_or_cancel_the_final_response() -> Result<()>+ {+ let listener = TcpListener::bind("127.0.0.1:0").await?;+ let addr = listener.local_addr()?;+ let (send_tail_tx, send_tail_rx) = tokio::sync::oneshot::channel();+ let server = tokio::spawn(async move {+ let (mut preflight, _) = listener.accept().await?;+ assert!(+ read_http_request_text(&mut preflight)+ .await?+ .starts_with("OPTIONS ")+ );+ preflight+ .write_all(+ concat!(+ "HTTP/1.1 200 OK\r\n",+ "Access-Control-Allow-Origin: http://origin.test\r\n",+ "Access-Control-Allow-Methods: PUT\r\n",+ "Access-Control-Allow-Headers: x-test\r\n",+ "Content-Length: 100\r\n",+ "Connection: close\r\n\r\n",+ )+ .as_bytes(),+ )+ .await?;++ // Keep the preflight body unfinished until the actual request is+ // received. Waiting for that body would deadlock this exchange.+ let (mut actual, _) = listener.accept().await?;+ assert!(+ read_http_request_text(&mut actual)+ .await?+ .starts_with("PUT ")+ );+ let mut byte = [0_u8; 1];+ assert_eq!(preflight.read(&mut byte).await?, 0);+ actual+ .write_all(+ concat!(+ "HTTP/1.1 200 OK\r\n",+ "Access-Control-Allow-Origin: http://origin.test\r\n",+ "Content-Length: 4\r\n",+ "Connection: close\r\n\r\n",+ "bo",+ )+ .as_bytes(),+ )+ .await?;+ send_tail_rx.await?;+ actual.write_all(b"dy").await?;+ Ok::<_, anyhow::Error>(())+ });++ let loader_owner = ResourceRequestClient::new(&FetchConfig::default())?;+ let loader = loader_owner.handle();+ let request_headers = vec![("X-Test".to_owned(), "yes".to_owned())];+ let request = Request::new(+ "PUT",+ &format!("http://{addr}/resource"),+ None,+ request_headers.clone(),+ )?+ .with_request_origin(moli_url::WebOrigin::from_url(&Url::parse(+ "http://origin.test/page",+ )?))+ .with_credentials_mode(RequestCredentialsMode::SameOrigin)+ .with_browser_request_metadata(BrowserRequestMetadata::Fetch);+ let cancel = FetchCancelHandle::new();+ let observed = tokio::time::timeout(+ Duration::from_secs(5),+ fetch_browser_subresource_raw_stream_with_preflight_headers_and_network_metadata(+ &loader,+ request,+ Some(cancel.clone()),+ request_headers,+ ),+ )+ .await?+ .map_err(anyhow::Error::msg)?;+ let mut response = observed.into_response();+ assert_eq!(response.status, 200);+ assert!(!cancel.is_cancelled());+ assert!(!cancel.response_completion_is_committed());++ send_tail_tx.send(()).unwrap();+ let mut body = Vec::new();+ while let Some(chunk) = response.next_chunk().await {+ body.extend_from_slice(&chunk);+ }+ response.finish().await?;+ assert_eq!(body, b"body");+ assert!(cancel.response_completion_is_committed());+ assert!(!cancel.cancel_if_response_pending());+ assert!(!cancel.is_cancelled());+ server.await??;+ Ok(())+ }++ #[tokio::test(flavor = "multi_thread")]+ async fn discarded_redirect_and_preflight_bodies_do_not_block_final_response_cancellation()+ -> Result<()> {+ let listener = TcpListener::bind("127.0.0.1:0").await?;+ let addr = listener.local_addr()?;+ let origin = format!("http://127.0.0.1:{}", addr.port());+ let target = format!("http://localhost:{}/final", addr.port());+ let server_origin = origin.clone();+ let server_target = target.clone();+ let server = tokio::spawn(async move {+ let (mut redirect, _) = listener.accept().await?;+ assert!(+ read_http_request_text(&mut redirect)+ .await?+ .starts_with("GET /start ")+ );+ redirect+ .write_all(+ format!(+ concat!(+ "HTTP/1.1 307 Temporary Redirect\r\n",+ "Location: {}\r\n",+ "Content-Length: 100\r\n",+ "Connection: close\r\n\r\n",+ ),+ server_target+ )+ .as_bytes(),+ )+ .await?;++ let (mut preflight, _) = listener.accept().await?;+ assert!(+ read_http_request_text(&mut preflight)+ .await?+ .starts_with("OPTIONS /final ")+ );+ preflight+ .write_all(+ format!(+ concat!(+ "HTTP/1.1 200 OK\r\n",+ "Access-Control-Allow-Origin: {}\r\n",+ "Access-Control-Allow-Methods: GET\r\n",+ "Access-Control-Allow-Headers: x-test\r\n",+ "Content-Length: 100\r\n",+ "Connection: close\r\n\r\n",+ ),+ server_origin+ )+ .as_bytes(),+ )+ .await?;++ let (mut actual, _) = listener.accept().await?;+ assert!(+ read_http_request_text(&mut actual)+ .await?+ .starts_with("GET /final ")+ );+ let mut byte = [0_u8; 1];+ assert_eq!(redirect.read(&mut byte).await?, 0);+ assert_eq!(preflight.read(&mut byte).await?, 0);+ actual+ .write_all(+ format!(+ concat!(+ "HTTP/1.1 200 OK\r\n",+ "Access-Control-Allow-Origin: {}\r\n",+ "Content-Length: 4\r\n",+ "Connection: close\r\n\r\n",+ "bo",+ ),+ server_origin+ )+ .as_bytes(),+ )+ .await?;+ assert_eq!(actual.read(&mut byte).await?, 0);+ Ok::<_, anyhow::Error>(())+ });++ let loader_owner = ResourceRequestClient::new(&FetchConfig::default())?;+ let loader = loader_owner.handle();+ let document = Url::parse(&format!("{origin}/page"))?;+ let headers = vec![("X-Test".to_owned(), "yes".to_owned())];+ let request = Request::new("GET", &format!("{origin}/start"), None, headers.clone())?+ .with_initiator_url(&document)+ .with_request_origin(moli_url::WebOrigin::from_url(&document))+ .with_credentials_mode(RequestCredentialsMode::SameOrigin)+ .with_browser_request_metadata(BrowserRequestMetadata::Fetch);+ let cancel = FetchCancelHandle::new();+ let observed = tokio::time::timeout(+ Duration::from_secs(5),+ fetch_browser_subresource_raw_stream_with_manual_preflight_redirects(+ &loader,+ request,+ Some(cancel.clone()),+ headers,+ None,+ ),+ )+ .await?+ .map_err(anyhow::Error::msg)?;+ let mut response = observed.into_response();+ assert_eq!(response.final_url.as_str(), target);+ assert_eq!(response.redirect_chain.len(), 1);+ assert!(!cancel.is_cancelled());+ assert!(!cancel.response_completion_is_committed());+ assert!(cancel.cancel_if_response_pending());+ assert!(response.cancellation_handle().is_cancelled());+ assert!(+ tokio::time::timeout(Duration::from_secs(5), response.finish())+ .await?+ .is_err()+ );+ assert!(!cancel.response_completion_is_committed());+ tokio::time::timeout(Duration::from_secs(5), server).await???;+ Ok(())+ }+#[tokio::test(flavor = "multi_thread")]async fn unsafe_xhr_redirect_preflights_next_origin_in_buffered_path() -> Result<()> {let listener = TcpListener::bind("127.0.0.1:0").await?;