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): bind response progress to individual transfers

ldm073e12a28f45a
diff --git a/moli-fetch/src/blocking/collectors.rs b/moli-fetch/src/blocking/collectors.rs
index 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(&current_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(&current_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.rs
index 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.rs
index 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.rs
index 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 its
diff --git a/moli-renderer-v8/src/network/loads/registry.rs b/moli-renderer-v8/src/network/loads/registry.rs
index 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.rs
index 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_observe
let 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?;