diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index 3b3dfe1c43b..0d2c99903a4 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -586,13 +586,15 @@ pub(crate) use self::stream_adapter::{ require_internal_stream_value, }; pub(crate) use self::streams::{ - ReadableStreamClonePayload, TransformStreamClonePayload, WritableStreamClonePayload, - build_readable_stream_clone_shell, build_transform_stream_clone_shell, - build_writable_stream_clone_shell, initialize_readable_stream_clone_shell, + ReadableStreamClonePayload, RequestBodyOwner, RequestBodyProducer, TransformStreamClonePayload, + WritableStreamClonePayload, build_readable_stream_clone_shell, + build_transform_stream_clone_shell, build_writable_stream_clone_shell, + initialize_readable_stream_clone_shell, initialize_request_body_stream, initialize_transform_stream_clone_shell, initialize_writable_stream_clone_shell, - new_readable_stream_from_array_buffer, new_readable_stream_from_source, - prepare_readable_stream_transfer, prepare_transform_stream_transfer, - prepare_writable_stream_transfer, proxy_fetch_body_stream, tee_fetch_body_stream, + install_request_body_abort, new_readable_stream_from_array_buffer, + new_readable_stream_from_source, prepare_readable_stream_transfer, + prepare_transform_stream_transfer, prepare_writable_stream_transfer, proxy_fetch_body_stream, + request_body_owner, tee_fetch_body_stream, transfer_request_body, }; pub(crate) use self::time_ranges::new_time_ranges_value; #[cfg(test)] diff --git a/moli-renderer-v8/src/context_bootstrap/streams.rs b/moli-renderer-v8/src/context_bootstrap/streams.rs index 6699eb70dca..2498af343ce 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams.rs @@ -351,12 +351,14 @@ pub(super) use readable::{ readable_stream_tee_callback, }; pub(crate) use transferable::{ - ReadableStreamClonePayload, TransformStreamClonePayload, WritableStreamClonePayload, - build_readable_stream_clone_shell, build_transform_stream_clone_shell, - build_writable_stream_clone_shell, initialize_readable_stream_clone_shell, + ReadableStreamClonePayload, RequestBodyOwner, RequestBodyProducer, TransformStreamClonePayload, + WritableStreamClonePayload, build_readable_stream_clone_shell, + build_transform_stream_clone_shell, build_writable_stream_clone_shell, + initialize_readable_stream_clone_shell, initialize_request_body_stream, initialize_transform_stream_clone_shell, initialize_writable_stream_clone_shell, - prepare_readable_stream_transfer, prepare_transform_stream_transfer, - prepare_writable_stream_transfer, + install_request_body_abort, prepare_readable_stream_transfer, + prepare_transform_stream_transfer, prepare_writable_stream_transfer, request_body_owner, + transfer_request_body, }; pub(super) use writable::{ writable_stream_abort_callback, writable_stream_close_callback, diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable.rs index 32201c69378..8f83dca1680 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams/transferable.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable.rs @@ -40,11 +40,17 @@ use moli_streams::{ mod protocol; mod receiver; +mod request_body; mod sender; mod state; mod writable; mod writable_state; +pub(crate) use request_body::{ + RequestBodyOwner, RequestBodyProducer, initialize_request_body_stream, + install_request_body_abort, request_body_owner, transfer_request_body, +}; + #[derive(Clone, Debug)] pub(crate) struct ReadableStreamClonePayload { pub(crate) port_id: MessagePortId, diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/receiver.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/receiver.rs index 8e69e8bc4d3..688f7e5073e 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams/transferable/receiver.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/receiver.rs @@ -1,4 +1,7 @@ use super::*; +use crate::context_bootstrap::stream_adapter::{ + enqueue_byte_chunk, finish_readable_byte_stream_source_close, +}; use moli_streams::transfer::{ ReceiverCancelPlan, ReceiverEnqueueOutcome, ReceiverEnqueuePlan, ReceiverMessageErrorPlan, ReceiverMessagePlan, ReceiverPullPlan, @@ -9,12 +12,21 @@ pub(super) fn initialize<'s>( scope: &mut v8::PinScope<'s, '_>, stream: v8::Local<'s, v8::Object>, payload: &ReadableStreamClonePayload, +) -> Option<()> { + initialize_mode(scope, stream, payload, false) +} + +pub(super) fn initialize_mode<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + payload: &ReadableStreamClonePayload, + byte_stream: bool, ) -> Option<()> { let Some(port) = ensure_message_port_wrapper_for_id(scope, payload.port_id) else { payload.discard_port(scope); return None; }; - let initialized = initialize_with_port(scope, stream, port); + let initialized = initialize_with_port(scope, stream, port, byte_stream); if initialized.is_none() { payload.discard_port(scope); } @@ -26,7 +38,7 @@ pub(super) fn new_from_port<'s>( port: v8::Local<'s, v8::Object>, ) -> Option> { let stream = new_readable_stream_shell_object(scope); - initialize_with_port(scope, stream, port)?; + initialize_with_port(scope, stream, port, false)?; Some(stream) } @@ -34,11 +46,16 @@ fn initialize_with_port<'s>( scope: &mut v8::PinScope<'s, '_>, stream: v8::Local<'s, v8::Object>, port: v8::Local<'s, v8::Object>, + byte_stream: bool, ) -> Option<()> { // Keep construction free of local close side effects. The payload owner or // prepared-transfer owner must discard the complete private channel if any // required V8 machinery below cannot be published. - initialize_readable_stream_object(scope, stream, None, 0.0, None); + if byte_stream { + initialize_webidl_readable_stream_object(scope, stream, None, true, 0.0, None); + } else { + initialize_readable_stream_object(scope, stream, None, 0.0, None); + } let state = state::create(scope, stream, port); let (onmessage, onmessageerror) = build_transfer_port_handlers(scope, state, message_callback, messageerror_callback)?; @@ -101,10 +118,33 @@ fn message_callback<'s>( match state::snapshot(scope, state).plan_receiver_message(Some(kind)) { ReceiverMessagePlan::IgnoreLateMessage => {} ReceiverMessagePlan::EnqueueChunk => { - let outcome = match enqueue_chunk(scope, stream, value) { + if readable_stream_is_byte_stream(scope, stream) + && v8::Local::::try_from(value) + .is_ok_and(|chunk| chunk.byte_length() == 0) + { + // Empty upload chunks are not EOF and cannot be enqueued by + // byte controllers. Retain the read and request another chunk. + let undefined = v8::undefined(scope).into(); + if let Err(error) = post_handling_error(scope, state, MessageKind::Pull, undefined) + { + error_stream(scope, stream, error); + state::finish(scope, state); + } + rv.set_undefined(); + return; + } + let result = if readable_stream_is_byte_stream(scope, stream) { + enqueue_byte_chunk(scope, stream, value) + } else { + enqueue_chunk(scope, stream, value) + }; + let outcome = match result { Ok(()) => ReceiverEnqueueOutcome::Enqueued, Err(EnqueueChunkError::ClosedOrErrored) => ReceiverEnqueueOutcome::StreamTerminal, - Err(EnqueueChunkError::Strategy(_)) => ReceiverEnqueueOutcome::StrategyError, + Err(EnqueueChunkError::Strategy(error)) => { + error_stream(scope, stream, error); + ReceiverEnqueueOutcome::StrategyError + } }; if matches!(outcome.plan(), ReceiverEnqueuePlan::Finish) { state::finish(scope, state); @@ -112,6 +152,9 @@ fn message_callback<'s>( } ReceiverMessagePlan::CloseStreamAndFinish => { let _ = close_stream(scope, stream); + if let Err(error) = finish_readable_byte_stream_source_close(scope, stream) { + error_stream(scope, stream, error); + } state::finish(scope, state); } ReceiverMessagePlan::ErrorStreamAndFinish => { diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/request_body.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/request_body.rs new file mode 100644 index 00000000000..e263e9eeb55 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/request_body.rs @@ -0,0 +1,329 @@ +//! Fetch body pipes carry snapshotted bytes and network errors. Their source +//! remains independent of the response promise, including synthetic responses +//! which never consume their FetchEvent request body. + +use super::*; +use crate::context_bootstrap::stream_adapter::{ + begin_readable_stream_body_consumption, cancel_readable_stream_for_fetch, maybe_pull_stream, + prepare_readable_stream_read_with_steps, stream_slot_value, +}; +use moli_streams::transfer::{SenderReadResultSnapshot, SenderStartReadPlan}; + +const BYTE_BODY: &str = "__moliFetchBodyByteSender"; +const SOURCE_STATE: &str = "__moliFetchBodyTransferState"; +const ABORT_CALLBACK: &str = "__moliFetchBodyAbortCallback"; +const ABORT_SIGNAL: &str = "__moliFetchBodyAbortSignal"; +const READ_STEPS: &str = "__moliFetchBodyReadSteps"; + +pub(crate) type RequestBodyOwner = std::sync::Arc< + dyn Fn(ReadableStreamClonePayload, moli_fetch::UploadBodySender, moli_fetch::FetchCancelHandle) + + Send + + Sync, +>; + +pub(crate) struct RequestBodyProducer { + stream: Option, + sender: Option, + pub(crate) cancel: moli_fetch::FetchCancelHandle, + registry: SharedMessagePortRegistry, +} + +impl std::fmt::Debug for RequestBodyProducer { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("RequestBodyProducer") + .field("stream", &self.stream) + .finish_non_exhaustive() + } +} + +impl RequestBodyProducer { + pub(crate) fn take_stream(&mut self) -> ReadableStreamClonePayload { + self.stream.take().expect("single body producer delivery") + } + pub(crate) fn take_sender(&mut self) -> moli_fetch::UploadBodySender { + self.sender.take().expect("single body producer sender") + } +} + +impl Drop for RequestBodyProducer { + fn drop(&mut self) { + if let Some(stream) = self.stream.take() { + self.registry.discard_message_port_channel(stream.port_id()); + } + } +} + +pub(crate) fn request_body_owner( + scope: &mut v8::PinScope<'_, '_>, + send: impl Fn(RequestBodyProducer) + Send + Sync + 'static, +) -> RequestBodyOwner { + let realm = MessagePortRealmBinding::current(scope).expect("request body owner realm"); + let registry = realm.registry().clone(); + std::sync::Arc::new(move |stream, sender, cancel| { + send(RequestBodyProducer { + stream: Some(stream), + sender: Some(sender), + cancel, + registry: registry.clone(), + }); + }) +} + +pub(crate) fn initialize_request_body_stream<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + payload: &ReadableStreamClonePayload, +) -> Option<()> { + receiver::initialize_mode(scope, stream, payload, true) +} + +pub(crate) fn transfer_request_body<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + already_locked: bool, +) -> Option { + if !is_readable_stream_object(scope, stream) + || (!already_locked && readable_stream_access_snapshot(scope, stream).locked()) + { + let error = state::type_error(scope, "Body stream is locked"); + scope.throw_exception(error); + return None; + } + let realm = MessagePortRealmBinding::current(scope)?; + let registry = realm.registry().clone(); + let (sender_id, receiver_id) = registry.create_entangled_message_port_pair(realm.owner()); + let Some(port) = ensure_message_port_wrapper_for_id_in_realm(scope, sender_id, &realm) else { + discard_prepared_port_pair(scope, ®istry, None, sender_id); + return None; + }; + let state = state::create(scope, stream, port); + set_stream_slot_bool(scope, state, BYTE_BODY, true); + let Some((onmessage, onmessageerror)) = build_transfer_port_handlers( + scope, + state, + sender::message_callback, + sender::messageerror_callback, + ) else { + discard_prepared_port_pair(scope, ®istry, Some(port), sender_id); + return None; + }; + let callbacks = (|| { + let steps = [ + v8::Function::builder(chunk) + .data(state.into()) + .build(scope)?, + v8::Function::builder(close) + .data(state.into()) + .build(scope)?, + v8::Function::builder(error) + .data(state.into()) + .build(scope)?, + ] + .map(v8::Local::::from); + let steps = v8::Array::new_with_elements(scope, &steps); + set_stream_slot_value(scope, state, READ_STEPS, steps.into()); + v8::Function::builder(start_callback) + .data(state.into()) + .build(scope) + })(); + let Some(start) = callbacks else { + discard_prepared_port_pair(scope, ®istry, Some(port), sender_id); + return None; + }; + if !already_locked && !begin_readable_stream_body_consumption(scope, stream) { + discard_prepared_port_pair(scope, ®istry, Some(port), sender_id); + return None; + } + registry.detach_message_port_owner_for_transfer(receiver_id); + install_transfer_port_handlers(scope, port, onmessage, onmessageerror); + set_stream_slot_value(scope, stream, SOURCE_STATE, state.into()); + // Author pull algorithms run only after the fetch callback releases its + // host borrow and installs cancellation, as on the direct network path. + scope.enqueue_microtask(start); + Some(ReadableStreamClonePayload { + port_id: receiver_id, + }) +} + +pub(super) fn is_request_body<'s>( + scope: &mut v8::PinScope<'s, '_>, + state: v8::Local<'s, v8::Object>, +) -> bool { + stream_slot_bool(scope, state, BYTE_BODY).unwrap_or(false) +} + +pub(super) fn start_read<'s>(scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, v8::Object>) { + if matches!( + state::snapshot(scope, state).plan_sender_start_read(), + SenderStartReadPlan::Ignore + ) { + return; + } + let Some(stream) = state::stream(scope, state) else { + return; + }; + let Some(steps) = stream_slot_array(scope, state, READ_STEPS) else { + return; + }; + let callbacks = [0, 1, 2].map(|index| { + v8::Local::::try_from( + steps.get_index(scope, index).expect("body pipe read step"), + ) + .expect("body pipe read function") + }); + state::set_read_in_flight(scope, state, true); + let pull = prepare_readable_stream_read_with_steps( + scope, + stream, + callbacks[0], + callbacks[1], + callbacks[2], + ); + if pull && state::snapshot(scope, state).active() { + maybe_pull_stream(scope, stream); + } +} + +fn active<'s>( + scope: &mut v8::PinScope<'s, '_>, + value: v8::Local<'s, v8::Value>, +) -> Option> { + let (binding, _) = crate::common_runtime::CommonRuntimeBinding::from_scope(scope)?; + binding.callback_execution_context(scope)?; + let state = v8::Local::::try_from(value).ok()?; + state::snapshot(scope, state).active().then_some(state) +} + +fn start_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + if let Some(state) = active(scope, args.data()) { + start_read(scope, state); + } +} + +fn chunk<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + let Some(state) = active(scope, args.data()) else { + return; + }; + state::set_read_in_flight(scope, state, false); + let Ok(chunk) = v8::Local::::try_from(args.get(0)) else { + fail(scope, state, None); + return; + }; + // The next source pull can mutate or detach the original backing store. + let mut bytes = vec![0; chunk.byte_length()]; + let count = chunk.copy_contents(&mut bytes); + bytes.truncate(count); + let length = bytes.len(); + let backing = v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared(); + let buffer = v8::ArrayBuffer::with_backing_store(scope, &backing); + let copy = v8::Uint8Array::new(scope, buffer, 0, length).expect("body pipe byte snapshot"); + let plan = state::snapshot(scope, state) + .plan_sender_read_fulfilled(SenderReadResultSnapshot::new(true, false)); + sender::apply_read_fulfillment(scope, state, plan, Some(copy.into())); +} + +fn close<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + let Some(state) = active(scope, args.data()) else { + return; + }; + state::set_read_in_flight(scope, state, false); + let plan = state::snapshot(scope, state) + .plan_sender_read_fulfilled(SenderReadResultSnapshot::new(true, true)); + sender::apply_read_fulfillment(scope, state, plan, None); +} + +fn error<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + if let Some(state) = active(scope, args.data()) { + fail(scope, state, None); + } +} + +fn fail<'s>( + scope: &mut v8::PinScope<'s, '_>, + state: v8::Local<'s, v8::Object>, + cancel_reason: Option>, +) { + state::set_active(scope, state, false); + let error = state::type_error(scope, "Failed to fetch"); + let _ = protocol::post(scope, state, protocol::MessageKind::Error, error); + state::close_port(scope, state); + remove_abort(scope, state); + if let Some(stream) = state::stream(scope, state) { + cancel_readable_stream_for_fetch(scope, stream, cancel_reason.unwrap_or(error)); + } +} + +pub(crate) fn install_request_body_abort<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + signal: v8::Local<'s, v8::Object>, +) { + let Some(signal) = crate::abort_signal_route::ResolvedAbortSignal::resolve(scope, signal) + else { + return; + }; + let callback = v8::Function::builder(abort) + .data(stream.into()) + .build(scope) + .expect("request body abort algorithm"); + set_stream_slot_value(scope, stream, ABORT_CALLBACK, callback.into()); + if signal.is_aborted(scope) { + let reason = signal.reason(scope); + cancel_readable_stream_for_fetch(scope, stream, reason); + return; + } + assert!(signal.register_weak_algorithm(scope, callback)); + if let Some(state) = stream_slot_object(scope, stream, SOURCE_STATE) { + set_stream_slot_value(scope, state, ABORT_SIGNAL, signal.value().into()); + } +} + +fn abort<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + let Ok(stream) = v8::Local::::try_from(args.data()) else { + return; + }; + if let Some(state) = stream_slot_object(scope, stream, SOURCE_STATE) { + fail(scope, state, Some(args.get(0))); + } else { + cancel_readable_stream_for_fetch(scope, stream, args.get(0)); + } +} + +pub(super) fn remove_abort<'s>(scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, v8::Object>) { + if !is_request_body(scope, state) { + return; + } + if let Some(stream) = state::stream(scope, state) { + if let Some(signal) = stream_slot_object(scope, state, ABORT_SIGNAL) + && let Some(callback) = stream_slot_value(scope, stream, ABORT_CALLBACK) + .and_then(|value| v8::Local::::try_from(value).ok()) + && let Some(signal) = + crate::abort_signal_route::ResolvedAbortSignal::resolve(scope, signal) + { + signal.unregister_algorithm(scope, callback); + } + set_stream_slot_value(scope, state, ABORT_SIGNAL, v8::undefined(scope).into()); + set_stream_slot_value(scope, stream, ABORT_CALLBACK, v8::undefined(scope).into()); + set_stream_slot_value(scope, stream, SOURCE_STATE, v8::undefined(scope).into()); + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/sender.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/sender.rs index 56ba5780c72..c577bc7d98e 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams/transferable/sender.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/sender.rs @@ -6,6 +6,10 @@ use moli_streams::transfer::{ use protocol::{MessageKind, parts, post}; pub(super) fn start_read<'s>(scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, v8::Object>) { + if request_body::is_request_body(scope, state) { + request_body::start_read(scope, state); + return; + } if matches!( state::snapshot(scope, state).plan_sender_start_read(), SenderStartReadPlan::Ignore @@ -81,7 +85,7 @@ fn read_fulfilled_callback<'s>( rv.set_undefined(); } -fn apply_read_fulfillment<'s>( +pub(super) fn apply_read_fulfillment<'s>( scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, v8::Object>, plan: SenderReadFulfillmentPlan, @@ -248,6 +252,7 @@ fn close_port_and_cancel_source<'s>( // Both terminal paths deactivate before reaching this helper. Release the // channel before cancellation can reenter or terminate the owning realm. state::close_port(scope, state); + request_body::remove_abort(scope, state); if let Some(stream) = state::stream(scope, state) && let Some(promise) = cancel_readable_stream(scope, stream, reason) { diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/state.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/state.rs index 737e18a118a..7aacb3e1714 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams/transferable/state.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/state.rs @@ -125,6 +125,7 @@ pub(super) fn finish<'s>(scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, ) { set_active(scope, state, false); close_port(scope, state); + request_body::remove_abort(scope, state); } } 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 99d65a41b6e..6871bb6e163 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 @@ -1899,7 +1899,14 @@ impl JsContextHost { internal_id: u64, upload: crate::network_host::RequestUpload, ) { - let Some(pending) = self.pending_subresource_fetches.get_mut(&internal_id) else { + let pending = if self.pending_subresource_fetches.contains_key(&internal_id) { + self.pending_subresource_fetches.get_mut(&internal_id) + } else { + self.running_subresource_fetches + .get_mut(&internal_id) + .map(|state| &mut state.pending) + }; + let Some(pending) = pending else { return; }; if let PendingSubresourceContinuation::Fetch(fetch) = &mut pending.continuation { @@ -1907,6 +1914,30 @@ impl JsContextHost { } } + pub(crate) fn window_request_body_producer_delivery( + &self, + internal_id: u64, + ) -> Option<( + v8::Global, + super::WindowExecutionContextBinding, + super::OwnerDispatchScope, + crate::network::RendererResourceTaskRunner, + )> { + let pending = self + .subresource_fetch_states() + .find(|pending| pending.info.internal_id == internal_id)?; + let binding = pending.execution_context.window_realm_binding()?; + if pending.load.is_cancelled() || !binding.is_current(self) { + return None; + } + Some(( + pending.continuation.window_fetch()?.resolver()?.clone(), + binding.clone(), + pending.execution_context.dispatch_scope(), + pending.load.task_runner(), + )) + } + pub(crate) fn window_request_upload( &self, internal_id: u64, diff --git a/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs b/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs index b2e7e2a94fd..e17f1675e19 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs @@ -1877,6 +1877,7 @@ impl JsContextHost { metadata: ServiceWorkerFetchRequestMetadata, ) -> ServiceWorkerFetchRequest { ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url, diff --git a/moli-renderer-v8/src/network_host/csp_reports.rs b/moli-renderer-v8/src/network_host/csp_reports.rs index 3c3fa12b8f0..8bcf505552c 100644 --- a/moli-renderer-v8/src/network_host/csp_reports.rs +++ b/moli-renderer-v8/src/network_host/csp_reports.rs @@ -370,6 +370,7 @@ fn dispatch_service_worker_content_security_policy_report( ); let request_body_text = report_request_body_text(&request); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/dictionary.rs b/moli-renderer-v8/src/network_host/dictionary.rs index 5f6aedfa034..92d9e46b4d8 100644 --- a/moli-renderer-v8/src/network_host/dictionary.rs +++ b/moli-renderer-v8/src/network_host/dictionary.rs @@ -153,6 +153,7 @@ fn start_dictionary_fetch( .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/event_source/request.rs b/moli-renderer-v8/src/network_host/event_source/request.rs index 947e5ea1808..1b8f730a028 100644 --- a/moli-renderer-v8/src/network_host/event_source/request.rs +++ b/moli-renderer-v8/src/network_host/event_source/request.rs @@ -422,6 +422,7 @@ fn dispatch_service_worker_event_source<'s>( }, ); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: host.window_fetch_redirect_check(registered.internal_id), internal_id: registered.internal_id, request, diff --git a/moli-renderer-v8/src/network_host/fetch/bindings.rs b/moli-renderer-v8/src/network_host/fetch/bindings.rs index 156699c86f8..2d02c9c3122 100644 --- a/moli-renderer-v8/src/network_host/fetch/bindings.rs +++ b/moli-renderer-v8/src/network_host/fetch/bindings.rs @@ -370,6 +370,10 @@ fn window_fetch_callback_in_relevant_realm<'s>( Ok(Some(internal_id)) => { if let Some(signal) = signal { install_window_fetch_abort_listener(scope, signal, internal_id); + if let Some(stream) = prepared.body_stream.as_ref() { + let stream = v8::Local::new(scope, stream); + crate::context_bootstrap::install_request_body_abort(scope, stream, signal); + } } rv.set(promise.into()); return; diff --git a/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs b/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs index 45be9c56d8d..e784505f30c 100644 --- a/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs +++ b/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs @@ -5,10 +5,10 @@ use crate::service_worker_runtime::{ }; use moli_fetch::FetchCancelHandle; -pub(super) fn dispatch_service_worker_fetch( - scope: &mut v8::PinScope<'_, '_>, +pub(super) fn dispatch_service_worker_fetch<'s>( + scope: &mut v8::PinScope<'s, '_>, host: &mut JsContextHost, - resolver: v8::Local<'_, v8::PromiseResolver>, + resolver: v8::Local<'s, v8::PromiseResolver>, prepared: &PreparedWindowFetchRequest, ) -> anyhow::Result> { if !matches!(prepared.resolved_url.scheme(), "http" | "https") { @@ -87,7 +87,7 @@ pub(super) fn dispatch_service_worker_fetch( requires_preflight, ) .ok_or_else(|| anyhow::anyhow!("Failed to fetch"))?; - let request = host.service_worker_fetch_request( + let mut request = host.service_worker_fetch_request( client_id, prepared.resolved_url.clone(), prepared.method.clone(), @@ -111,7 +111,31 @@ pub(super) fn dispatch_service_worker_fetch( link_preload: false, }, ); + if prepared.body_source_is_null + && let Some(stream) = prepared.body_stream.as_ref() + { + let stream = v8::Local::new(scope, stream); + let Some(body) = crate::context_bootstrap::transfer_request_body( + scope, + stream, + prepared.body_stream_locked, + ) else { + host.take_pending_subresource_fetch(internal_id); + return Err(anyhow::anyhow!("Failed to transfer request body")); + }; + request.body_stream = Some(body); + } + let completion = host.resource_completion_sender(); + let body_owner = crate::context_bootstrap::request_body_owner(scope, move |producer| { + let _ = completion.send_async_subresource_event( + AsyncSubresourceFetchEvent::RequestBodyProducer { + internal_id, + producer, + }, + ); + }); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: Some(body_owner), redirect_check: host.window_fetch_redirect_check(internal_id), internal_id, request, diff --git a/moli-renderer-v8/src/network_host/image.rs b/moli-renderer-v8/src/network_host/image.rs index 236c5fadce2..74b9c9ddc9a 100644 --- a/moli-renderer-v8/src/network_host/image.rs +++ b/moli-renderer-v8/src/network_host/image.rs @@ -367,6 +367,7 @@ pub(crate) fn start_image_element_resource_fetch( if service_worker_controller.is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/media.rs b/moli-renderer-v8/src/network_host/media.rs index 90fa3f9e6ab..9add769da2c 100644 --- a/moli-renderer-v8/src/network_host/media.rs +++ b/moli-renderer-v8/src/network_host/media.rs @@ -179,6 +179,7 @@ pub(crate) fn start_media_element_resource_fetch( .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/preload.rs b/moli-renderer-v8/src/network_host/preload.rs index 89903c254e2..ae16d1d87c3 100644 --- a/moli-renderer-v8/src/network_host/preload.rs +++ b/moli-renderer-v8/src/network_host/preload.rs @@ -275,6 +275,7 @@ fn start_resource_preload( .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/request_upload.rs b/moli-renderer-v8/src/network_host/request_upload.rs index 773451cd750..3c567aba205 100644 --- a/moli-renderer-v8/src/network_host/request_upload.rs +++ b/moli-renderer-v8/src/network_host/request_upload.rs @@ -46,6 +46,30 @@ impl RequestUpload { cancel: FetchCancelHandle, ready: impl Fn(Result<(), UploadBodyError>) + Send + Sync + 'static, ) -> Result<(Self, UploadBody), v8::Local<'s, v8::Value>> { + let (sender, body) = UploadBody::channel(); + Self::with_sender( + scope, + stream, + resolver, + already_locked, + runner, + cancel, + ready, + sender, + ) + .map(|upload| (upload, body)) + } + + pub(crate) fn with_sender<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + resolver: v8::Local<'s, v8::PromiseResolver>, + already_locked: bool, + runner: RendererResourceTaskRunner, + cancel: FetchCancelHandle, + ready: impl Fn(Result<(), UploadBodyError>) + Send + Sync + 'static, + sender: UploadBodySender, + ) -> Result> { if !already_locked && !begin_readable_stream_body_consumption(scope, stream) { return Err(v8::Exception::type_error( scope, @@ -71,7 +95,6 @@ impl RequestUpload { let steps = v8::Array::new_with_elements(scope, &steps); set_null_prototype(scope, steps.into()); set_private_value(scope, consumer, STEPS, steps.into()); - let (sender, body) = UploadBody::channel(); let upload = Self(Rc::new(Upload { consumer: v8::Global::new(scope, consumer), sender: RefCell::new(Some(sender)), @@ -87,7 +110,7 @@ impl RequestUpload { let external = v8::External::new(scope, (&mut *weak as *mut Weak).cast()); set_private_value(scope, consumer, NATIVE, external.into()); crate::v8_finalizer::track_context_owned_v8_finalizer(scope, consumer, move || drop(weak)); - Ok((upload, body)) + Ok(upload) } /// Lock synchronously, but start reads after fetch has installed its abort diff --git a/moli-renderer-v8/src/network_host/subresource.rs b/moli-renderer-v8/src/network_host/subresource.rs index e53e3a7efba..4f7d5a8978d 100644 --- a/moli-renderer-v8/src/network_host/subresource.rs +++ b/moli-renderer-v8/src/network_host/subresource.rs @@ -152,6 +152,7 @@ impl PreparedSubresourceFetch { .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/text_track.rs b/moli-renderer-v8/src/network_host/text_track.rs index 7747d912bb6..bfa41628492 100644 --- a/moli-renderer-v8/src/network_host/text_track.rs +++ b/moli-renderer-v8/src/network_host/text_track.rs @@ -153,6 +153,7 @@ pub(crate) fn start_text_track_resource_fetch( .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/xhr/send/paths.rs b/moli-renderer-v8/src/network_host/xhr/send/paths.rs index 0e704f4491d..d4ff68cc830 100644 --- a/moli-renderer-v8/src/network_host/xhr/send/paths.rs +++ b/moli-renderer-v8/src/network_host/xhr/send/paths.rs @@ -129,6 +129,7 @@ pub(super) fn dispatch_service_worker_xhr( }, ); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: host.window_fetch_redirect_check(internal_id), internal_id, request, diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs index 251f4f0e1e4..794b6030451 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs @@ -198,9 +198,11 @@ impl RendererBrowserContextRuntime { let redirect_mode = main_resource_fetch_event_redirect_mode(destination, request.redirect_mode()); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 0, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: Some(client_id), url: request.url.clone(), @@ -237,6 +239,12 @@ impl RendererBrowserContextRuntime { } match main_resource_completion_rx.await { + Ok( + ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::Stream(_), + ) => Err(anyhow!( + "navigation requests cannot contain an author stream" + )), Ok(ServiceWorkerDirectFetchResult::Fallback) => Ok(None), Ok(ServiceWorkerDirectFetchResult::Response(response)) => Ok(Some(*response.response)), Ok(ServiceWorkerDirectFetchResult::Failure(message)) => Err(anyhow!(message)), @@ -311,11 +319,13 @@ impl RendererBrowserContextRuntime { let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); let redirect_request = request.clone(); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: Some(moli_fetch::RequestRedirectCheck::new(move |next_url| { redirect_request.check_redirect_target(next_url) })), internal_id: 0, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request.url.clone(), @@ -351,6 +361,12 @@ impl RendererBrowserContextRuntime { } match direct_completion_rx.await { + Ok( + ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::Stream(_), + ) => Err(anyhow!( + "native subresource requests cannot contain an author stream" + )), Ok(ServiceWorkerDirectFetchResult::Fallback) => Ok(None), Ok(ServiceWorkerDirectFetchResult::Response(response)) => Ok(Some(response)), Ok(ServiceWorkerDirectFetchResult::Failure(message)) => Err(anyhow!(message)), diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload.rs index 05f683ab48f..5e8e2ed163b 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload.rs @@ -7,6 +7,8 @@ use tokio_rustls::rustls::{ pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer}, }; +mod controlled; + #[derive(Default)] struct Wire { bytes: Vec, @@ -111,6 +113,14 @@ impl UploadServer { .header("access-control-allow-headers", "authorization"); if request.method() == http::Method::OPTIONS { response.send_response(head.status(204).body(())?, true)?; + } else if path == "/sw.js" { + let head = head.status(200) + .header("content-type", "text/javascript") + .header("service-worker-allowed", "/").body(())?; + let mut send = response.send_response(head, false)?; + send.send_data(bytes::Bytes::from_static(include_bytes!( + "../../../../../tests/fixtures/controlled-request-upload-worker.js" + )), true)?; } else if path == "/upload" { wire.lock().headers = request.headers().clone(); events.headers.send_replace(true); diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload/controlled.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload/controlled.rs new file mode 100644 index 00000000000..3f9e761fede --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload/controlled.rs @@ -0,0 +1,248 @@ +use super::*; + +async fn controlled_probe( + server: &UploadServer, + script: &str, + dedicated: bool, +) -> serde_json::Value { + // Blob Worker URLs cannot resolve relative request URLs. + let script = script.replace("'/", &format!("'{}", server.url)); + let mut config = FetchConfig::default(); + config.set_tls_verify_host(false); + config.set_http_no_proxy(Some("*".to_owned())); + let owner = ResourceRequestClient::new(&config).unwrap(); + let mut page = test_page_vm_with_loader_and_document_url( + &owner, + Vec::new(), + server.url.join("page").unwrap(), + ); + page.retain_standalone_request_client_owner_for_test(owner); + let executor = page.local_executor.clone(); + let source = format!( + r#" + (async () => {{ + globalThis.__wsEvents = ['register']; + const registration = await navigator.serviceWorker.register('/sw.js', {{scope:'/'}}); + await navigator.serviceWorker.ready; + if (!navigator.serviceWorker.controller) await new Promise(resolve => + navigator.serviceWorker.addEventListener('controllerchange', resolve, {{once:true}})); + __wsEvents.push('controlled'); + async function run() {{ {script} }} + let result; + if ({dedicated}) {{ + const url = URL.createObjectURL(new Blob(['onmessage=async()=>{{try{{postMessage(await ('+run.toString()+')());}}catch(e){{postMessage({{failure:String(e.stack||e)}});}}}};'])); + const worker = new Worker(url); + try {{ + result = await new Promise((resolve,reject) => {{ + worker.onmessage = event => resolve(event.data); + worker.onerror = event => reject(new Error(event.message)); + worker.postMessage(1); + }}); + }} finally {{worker.terminate();URL.revokeObjectURL(url);}} + }} else result = await run(); + await registration.unregister(); + return result; + }})().then(value => globalThis.__controlledUploadResult = value, + error => globalThis.__controlledUploadResult = {{failure:String(error.stack||error)}}) + .finally(() => globalThis.__controlledUploadDone = true); + "# + ); + let result = executor + .run(async move { + page.vm_mut().eval(&source)?; + drive_page_work_until_done_with_explicit_producer_admission( + &mut page, + "String(globalThis.__controlledUploadDone===true)", + "controlled author upload should complete", + |page| { + page.runtime_hooks + .browser_context_runtime + .drain_service_worker_service_lane(); + }, + ) + .await?; + page.vm_mut() + .eval("JSON.stringify(globalThis.__controlledUploadResult)") + }) + .await + .unwrap(); + serde_json::from_str(&result).unwrap() +} + +#[tokio::test] +async fn controlled_upload_snapshots_views_and_exposes_byob_across_window_and_worker() { + run_page_vm_async_test(async { + for dedicated in [false, true] { + let server = UploadServer::new(false, 200).await.unwrap(); + let result = controlled_probe(&server, r#" + const backing = new Uint8Array([88,0,255,65,66,99]); + const body = new ReadableStream({ + start(c){c.enqueue(backing.subarray(1,5));c.enqueue(new Uint8Array());}, + pull(c){backing.fill(123);c.enqueue(new Uint8Array([3,4]));c.close();} + },{highWaterMark:0}); + ReadableStream.prototype.getReader = () => {throw Error('public input getReader');}; + ReadableStreamDefaultReader.prototype.read = () => {throw Error('public input read');}; + const request = new Request('/upload?mode=byob',{method:'POST',body,duplex:'half'}); + const response = await fetch(request); + return {bytes:await response.json(),locked:body.locked,used:request.bodyUsed}; + "#, dedicated).await; + assert_eq!(result, serde_json::json!({"bytes":[0,255,65,66,3,4],"locked":true,"used":true}), "dedicated={dedicated}"); + assert!(server.wire.lock().bytes.is_empty()); + server.shutdown().await; + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_fallback_clone_and_forward_send_bytes_before_eof() { + run_page_vm_async_test(async { + for dedicated in [false, true] { + for mode in ["fallback", "clone", "forward"] { + let server = UploadServer::new(false, 200).await.unwrap(); + let script = r#" + let controller,settled=false; + const body = new ReadableStream({start(c){controller=c;c.enqueue(new Uint8Array([0,255,65,66]));}}); + const promise=fetch('/upload?mode=MODE',{method:'POST',body,duplex:'half'}) + .then(async response=>{settled=true;return response.text();}); + await (await fetch('/first')).text(); + if(settled)throw Error('fetch settled before request EOF'); + controller.enqueue(new Uint8Array()); + controller.enqueue(new Uint8Array(196613).fill(7));controller.close(); + const text=await promise;await (await fetch('/finished')).text(); + return {text,locked:body.locked}; + "#.replace("MODE", mode); + let result=controlled_probe(&server,&script,dedicated).await; + assert_eq!(result,serde_json::json!({"text":"uploaded","locked":true}),"mode={mode}, dedicated={dedicated}"); + { + let wire=server.wire.lock();assert!(wire.ended); + assert_eq!(&wire.bytes[..4],&[0,255,65,66]);assert_eq!(wire.bytes.len(),196617); + assert!(wire.bytes[4..].iter().all(|byte|*byte==7)); + assert!(wire.headers.get("content-length").is_none()); + } + server.shutdown().await; + } + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_retains_backpressure_through_fallback_and_forward() { + run_page_vm_async_test(async { + for mode in ["fallback","forward"] { + let server=UploadServer::new(true,200).await.unwrap(); + // Keep 4 MiB on the wire while limiting external owner turns in + // this standalone PageVm's explicitly admitted Service Worker lane. + let script=r#" + let pulls=0,settled=false; + const body=new ReadableStream({pull(c){c.enqueue(new Uint8Array(262144).fill(1));if(++pulls===16)c.close();}},{highWaterMark:0}); + const promise=fetch('/upload?mode=MODE',{method:'POST',body,duplex:'half'}) + .then(async response=>{settled=true;return response.text();}); + __wsEvents.push('await headers'); + await (await fetch('/headers')).text();const bounded=pulls<16&&!settled; + __wsEvents.push('headers, pulls='+pulls); + await (await fetch('/release')).text(); + __wsEvents.push('released, pulls='+pulls); + const text=await promise; + await (await fetch('/finished')).text();return {bounded,pulls,text}; + "#.replace("MODE",mode); + let result=controlled_probe(&server,&script,false).await; + assert_eq!(result,serde_json::json!({"bounded":true,"pulls":16,"text":"uploaded"}),"mode={mode}"); + assert_eq!(server.wire.lock().bytes.len(),4*1024*1024); + server.shutdown().await; + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_echo_exposes_headers_and_bytes_before_source_eof() { + run_page_vm_async_test(async { + for dedicated in [false, true] { + let server = UploadServer::new(false, 200).await.unwrap(); + let result = controlled_probe(&server, r#" + let controller; + const body = new ReadableStream({start(c){controller=c;c.enqueue(new Uint8Array([0,255]));}}); + const response = await fetch('/upload?mode=echo',{method:'POST',body,duplex:'half'}); + const reader = response.body.getReader(),first = await reader.read(); + controller.enqueue(new Uint8Array([65,66]));controller.close(); + const bytes = Array.from(first.value); + while (true) {const {value,done}=await reader.read();if(done)break;bytes.push(...value);} + return {status:response.status,bytes}; + "#, dedicated).await; + assert_eq!(result, serde_json::json!({"status":200,"bytes":[0,255,65,66]}), "dedicated={dedicated}"); + assert!(server.wire.lock().bytes.is_empty()); + server.shutdown().await; + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_synthetic_responses_keep_body_errors_and_abort_lifetimes() { + run_page_vm_async_test(async { + for dedicated in [false,true] { + let server=UploadServer::new(false,200).await.unwrap(); + let result=controlled_probe(&server,r#" + const rows=[]; + for(const kind of ['open','error','invalid']){ + const controller=new AbortController(),reason={marker:'after response'}; + let cancelled=0,same=false; + const body=new ReadableStream({start(c){if(kind==='error')c.error(Error('source'));else {c.enqueue(kind==='invalid'?'wrong':new Uint8Array([65,66]));if(kind==='invalid')c.close();}},cancel(value){cancelled++;same=value===reason;}}); + const response=await fetch('/upload?mode=constant',{method:'POST',body,duplex:'half',signal:controller.signal}); + const text=await response.text(),before=cancelled;controller.abort(reason); + rows.push({kind,text,before,cancelled,same}); + } + for(const kind of ['error','invalid']){ + const body=new ReadableStream({start(c){if(kind==='error')c.error(Error('source'));else {c.enqueue('wrong');c.close();}}}); + const response=await fetch('/upload?mode=echo',{method:'POST',body,duplex:'half'}); + let name;try{await response.text();}catch(error){name=error.name;} + rows.push({kind,status:response.status,name}); + }return rows; + "#,dedicated).await; + assert_eq!(result,serde_json::json!([ + {"kind":"open","text":"constant","before":0,"cancelled":1,"same":true}, + {"kind":"error","text":"constant","before":0,"cancelled":0,"same":false}, + {"kind":"invalid","text":"constant","before":0,"cancelled":0,"same":false}, + {"kind":"error","status":200,"name":"TypeError"}, + {"kind":"invalid","status":200,"name":"TypeError"} + ]),"dedicated={dedicated}"); + server.shutdown().await; + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_rejects_used_fallback_but_keeps_source_abort_algorithm() { + run_page_vm_async_test(async { + let server=UploadServer::new(false,200).await.unwrap(); + let result=controlled_probe(&server,r#" + const controller=new AbortController(),reason={marker:'used fallback'}; + let cancelled=0,same=false; + const body=new ReadableStream({start(c){c.enqueue(new Uint8Array([65]));},cancel(value){cancelled++;same=value===reason;}}); + let name;try{await fetch('/upload?mode=used',{method:'POST',body,duplex:'half',signal:controller.signal});}catch(error){name=error.name;} + const before=cancelled;controller.abort(reason);return {name,before,cancelled,same}; + "#,false).await; + assert_eq!(result,serde_json::json!({"name":"TypeError","before":0,"cancelled":1,"same":true})); + assert!(server.wire.lock().bytes.is_empty()); + server.shutdown().await; + }).await; +} + +#[tokio::test] +async fn controlled_upload_checks_source_before_synthetic_redirect_method_rewriting() { + run_page_vm_async_test(async { + let server=UploadServer::new(false,200).await.unwrap(); + let result=controlled_probe(&server,r#" + const rows=[]; + for(const status of [301,302,303,307,308]){ + const body=new ReadableStream({start(c){c.enqueue(new Uint8Array([65]));c.close();}}); + try{const response=await fetch('/upload?mode=redirect&status='+status,{method:'POST',body,duplex:'half'});rows.push({status,text:await response.text()});} + catch(error){rows.push({status,name:error.name});} + }return rows; + "#,false).await; + assert_eq!(result,serde_json::json!([ + {"status":301,"name":"TypeError"},{"status":302,"name":"TypeError"}, + {"status":303,"text":"uploaded"},{"status":307,"name":"TypeError"}, + {"status":308,"name":"TypeError"} + ])); + server.shutdown().await; + }).await; +} diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch.rs index 25a3c9d537a..078c1c59b34 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch.rs @@ -774,6 +774,12 @@ fn async_subresource_trace_fields_for_event( event: &AsyncSubresourceFetchEvent, ) -> AsyncSubresourceTraceFields { match event { + AsyncSubresourceFetchEvent::RequestBodyProducer { internal_id, .. } => { + AsyncSubresourceTraceFields { + internal_id: Some(*internal_id), + ..Default::default() + } + } AsyncSubresourceFetchEvent::RequestUploadReady { internal_id, .. } => { AsyncSubresourceTraceFields { internal_id: Some(*internal_id), diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs index 8a08670f7cc..7f0d80c14d1 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs @@ -490,6 +490,7 @@ impl ScriptVm { let request_client = pending.load.request_client(); let resource_task_runner = pending.load.task_runner(); let dispatch = crate::service_worker_runtime::ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: self._context_host.borrow().service_worker_fetch_request( diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs index e45e443dd16..737206679b6 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs @@ -424,6 +424,10 @@ impl ScriptVm { let trace_fields = async_subresource_trace_fields_for_event(&event); trace_async_subresource_stage("async_subresource_event_start", trace_fields, trace_started); let result = match event { + AsyncSubresourceFetchEvent::RequestBodyProducer { + internal_id, + producer, + } => self.apply_request_body_producer(internal_id, producer), AsyncSubresourceFetchEvent::RequestUploadReady { internal_id, result, @@ -486,6 +490,64 @@ impl ScriptVm { trace_async_subresource_stage("async_subresource_event_done", trace_fields, trace_started); result } + fn apply_request_body_producer( + &mut self, + internal_id: u64, + mut producer: crate::context_bootstrap::RequestBodyProducer, + ) -> Result { + let host = self._context_host.clone(); + self.renderer_document_isolate + .with_entered_renderer_document_isolate(|isolate| { + let scope = pin!(v8::HandleScope::new(isolate)); + let scope = &mut scope.init(); + let Some((resolver, binding, dispatch, runner)) = host + .borrow() + .window_request_body_producer_delivery(internal_id) + else { + return Ok(AsyncSubresourceFetchBodyActivity::NoWindowRealmEntered); + }; + let context = v8::Local::new(scope, binding.context_global()); + let scope = &mut v8::ContextScope::new(scope, context); + let previous = enter_subresource_owner_async_scope(&host, scope, dispatch); + let stream = crate::context_bootstrap::build_readable_stream_clone_shell(scope); + let payload = producer.take_stream(); + if crate::context_bootstrap::initialize_request_body_stream(scope, stream, &payload) + .is_some() + { + let resolver = v8::Local::new(scope, resolver); + let completion = host.borrow().resource_completion_sender(); + match crate::network_host::RequestUpload::with_sender( + scope, + stream, + resolver, + false, + runner, + producer.cancel.clone(), + move |result| { + let _ = completion.send_async_subresource_event( + AsyncSubresourceFetchEvent::RequestUploadReady { + internal_id, + result, + }, + ); + }, + producer.take_sender(), + ) { + Ok(upload) => { + host.borrow_mut() + .set_window_request_upload(internal_id, upload.clone()); + upload.start(scope); + } + Err(reason) => { + resolver.reject(scope, reason); + } + } + } + defer_subresource_owner_async_scope(&host, scope, dispatch, previous); + Ok(AsyncSubresourceFetchBodyActivity::WindowRealmEntered) + }) + } + fn apply_request_upload_ready( &mut self, internal_id: u64, diff --git a/moli-renderer-v8/src/service_worker_runtime.rs b/moli-renderer-v8/src/service_worker_runtime.rs index 5a01f094781..62962f63200 100644 --- a/moli-renderer-v8/src/service_worker_runtime.rs +++ b/moli-renderer-v8/src/service_worker_runtime.rs @@ -38,22 +38,23 @@ pub(crate) use events::{ ServiceWorkerClientNavigateResult, ServiceWorkerClientsOpenWindow, ServiceWorkerClientsOpenWindowError, ServiceWorkerClientsOpenWindowResult, ServiceWorkerCloseNotification, ServiceWorkerDirectFetchResponse, - ServiceWorkerDirectFetchResult, ServiceWorkerFetchCompletion, ServiceWorkerFetchDispatch, - ServiceWorkerFetchEvent, ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, - ServiceWorkerFetchResponse, ServiceWorkerFetchResult, ServiceWorkerFetchStreamChunk, - ServiceWorkerFetchStreamStarted, ServiceWorkerGetNotifications, - ServiceWorkerGetNotificationsResult, ServiceWorkerLifecycleCompletion, - ServiceWorkerLifecycleEvent, ServiceWorkerLifecycleEventKind, ServiceWorkerMessageCompletion, - ServiceWorkerMessageEvent, ServiceWorkerNavigationPreloadFailure, - ServiceWorkerNavigationPreloadResponseStarted, ServiceWorkerNavigationPreloadStreamChunk, - ServiceWorkerNavigationPreloadStreamFinished, ServiceWorkerNotificationAction, - ServiceWorkerNotificationCompletion, ServiceWorkerNotificationEvent, - ServiceWorkerNotificationMetadata, ServiceWorkerNotificationSnapshot, - ServiceWorkerPeriodicSyncCompletion, ServiceWorkerPeriodicSyncEvent, - ServiceWorkerPeriodicSyncGetTags, ServiceWorkerPeriodicSyncGetTagsResult, - ServiceWorkerPeriodicSyncRegistration, ServiceWorkerPeriodicSyncRegistrationResult, - ServiceWorkerPeriodicSyncUnregistration, ServiceWorkerPeriodicSyncUnregistrationResult, - ServiceWorkerPushCompletion, ServiceWorkerPushEvent, ServiceWorkerPushGetSubscription, + ServiceWorkerDirectFetchResult, ServiceWorkerDirectFetchStreamEvent, + ServiceWorkerFetchCompletion, ServiceWorkerFetchDispatch, ServiceWorkerFetchEvent, + ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, ServiceWorkerFetchResponse, + ServiceWorkerFetchResult, ServiceWorkerFetchStreamChunk, ServiceWorkerFetchStreamStarted, + ServiceWorkerGetNotifications, ServiceWorkerGetNotificationsResult, + ServiceWorkerLifecycleCompletion, ServiceWorkerLifecycleEvent, ServiceWorkerLifecycleEventKind, + ServiceWorkerMessageCompletion, ServiceWorkerMessageEvent, + ServiceWorkerNavigationPreloadFailure, ServiceWorkerNavigationPreloadResponseStarted, + ServiceWorkerNavigationPreloadStreamChunk, ServiceWorkerNavigationPreloadStreamFinished, + ServiceWorkerNotificationAction, ServiceWorkerNotificationCompletion, + ServiceWorkerNotificationEvent, ServiceWorkerNotificationMetadata, + ServiceWorkerNotificationSnapshot, ServiceWorkerPeriodicSyncCompletion, + ServiceWorkerPeriodicSyncEvent, ServiceWorkerPeriodicSyncGetTags, + ServiceWorkerPeriodicSyncGetTagsResult, ServiceWorkerPeriodicSyncRegistration, + ServiceWorkerPeriodicSyncRegistrationResult, ServiceWorkerPeriodicSyncUnregistration, + ServiceWorkerPeriodicSyncUnregistrationResult, ServiceWorkerPushCompletion, + ServiceWorkerPushEvent, ServiceWorkerPushGetSubscription, ServiceWorkerPushGetSubscriptionResult, ServiceWorkerPushSubscribe, ServiceWorkerPushSubscribeResult, ServiceWorkerPushSubscriptionSnapshot, ServiceWorkerPushUnsubscribe, ServiceWorkerPushUnsubscribeResult, diff --git a/moli-renderer-v8/src/service_worker_runtime/events.rs b/moli-renderer-v8/src/service_worker_runtime/events.rs index ac230c2e24d..d204207e9a9 100644 --- a/moli-renderer-v8/src/service_worker_runtime/events.rs +++ b/moli-renderer-v8/src/service_worker_runtime/events.rs @@ -473,6 +473,7 @@ pub(crate) struct ServiceWorkerFetchRequest { /// Isomorphically decoded wire bytes, ready for the worker's Fetch Headers. pub(crate) headers: Vec<(String, String)>, pub(crate) body: Option, + pub(crate) body_stream: Option, pub(crate) destination: ServiceWorkerRequestDestination, pub(crate) request_mode: moli_fetch::RequestMode, pub(crate) credentials_mode: moli_fetch::RequestCredentialsMode, @@ -672,6 +673,7 @@ pub(crate) struct ServiceWorkerFetchResponse { #[derive(Clone, Debug)] pub(crate) enum ServiceWorkerFetchResult { Fallback, + FallbackStream(moli_fetch::UploadBody), Response(ServiceWorkerFetchResponse), Failure(String), } @@ -739,10 +741,26 @@ pub(crate) struct MaterializedServiceWorkerFetchResponseHead { #[derive(Debug)] pub(crate) enum ServiceWorkerDirectFetchResult { Fallback, + FallbackStream(moli_fetch::UploadBody), Response(ServiceWorkerDirectFetchResponse), + Stream(Box), Failure(String), } +#[derive(Debug)] +pub(crate) struct ServiceWorkerDirectFetchStream { + pub(crate) body_source_id: crate::types::NetworkBodySourceId, + pub(crate) head: moli_fetch::ResponseHead, + pub(crate) response_filter: Option, + pub(crate) events: tokio::sync::mpsc::UnboundedReceiver, +} + +#[derive(Debug)] +pub(crate) enum ServiceWorkerDirectFetchStreamEvent { + Chunk(Vec), + Finished(Result<(), String>), +} + #[derive(Debug)] pub(crate) struct ServiceWorkerDirectFetchResponse { /// The worker response's URL before applying the request-URL fallback. @@ -760,6 +778,7 @@ pub(crate) struct ServiceWorkerFetchCompletion { } pub(crate) struct ServiceWorkerFetchDispatch { + pub(crate) request_body_owner: Option, pub(crate) internal_id: u64, pub(crate) request: ServiceWorkerFetchRequest, pub(crate) redirect_check: Option, diff --git a/moli-renderer-v8/src/service_worker_runtime/service.rs b/moli-renderer-v8/src/service_worker_runtime/service.rs index fa33e10ecb5..420de9a424d 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service.rs @@ -872,6 +872,7 @@ mod tests { request_url: Url, ) -> ServiceWorkerFetchRequest { ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -900,6 +901,9 @@ mod tests { cancel_handle: moli_fetch::FetchCancelHandle, ) -> ServiceWorkerFetchJob { ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/event_completion.rs b/moli-renderer-v8/src/service_worker_runtime/service/event_completion.rs index 8bae2c0ef3c..e73c68e4924 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/event_completion.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/event_completion.rs @@ -159,7 +159,14 @@ impl ServiceWorkerRuntimeService { return; }; job.cancel_pending_navigation_preload(); - if let Some(version) = state.versions.get_mut(&version_id) { + if matches!( + completion.result, + ServiceWorkerFetchResult::FallbackStream(_) + ) { + state + .pending_fetch_body_uploads + .insert(completion.event_id, job.owner().clone()); + } else if let Some(version) = state.versions.get_mut(&version_id) { version.in_flight_event_count = version.in_flight_event_count.saturating_sub(1); } let unregistration_progress = @@ -186,6 +193,19 @@ impl ServiceWorkerRuntimeService { ServiceWorkerFetchResult::Fallback => { self.dispatch_fetch_fallback(job); } + ServiceWorkerFetchResult::FallbackStream(body) => { + let runtime = self.clone(); + let owner = job.owner().clone(); + let transmitted = body.transmission(); + job.resource_task_runner.spawn(async move { + let _ = transmitted.await; + runtime.finish_fetch_body_upload(completion.event_id, owner); + }); + let mut job = job; + job.request = job.request.with_upload_body(body); + job.body_stream = None; + self.dispatch_fetch_fallback(job); + } ServiceWorkerFetchResult::Response(response) => { self.complete_fetch_with_service_worker_response(job, response); } @@ -195,6 +215,45 @@ impl ServiceWorkerRuntimeService { } } + fn finish_fetch_body_upload( + &self, + event_id: ServiceWorkerEventId, + owner: ServiceWorkerRunOwner, + ) { + let (idle_timeout, lifecycle_progress) = { + let mut state = self.inner.state.lock(); + if state.pending_fetch_body_uploads.get(&event_id) != Some(&owner) { + return; + } + state.pending_fetch_body_uploads.remove(&event_id); + let Some(version) = state.versions.get_mut(&owner.version_id()) else { + return; + }; + if &version.run != owner.run_identity() { + return; + } + version.in_flight_event_count = version.in_flight_event_count.saturating_sub(1); + let mut progress = self.unregistration_progress_for_version_if_ready_locked( + &mut state, + owner.version_id(), + ); + if progress.is_empty() { + progress.extend(self.activation_progress_for_active_version_if_ready_locked( + &mut state, + owner.version_id(), + )); + } + let idle = self.maybe_schedule_idle_timeout_locked(&mut state, owner.version_id()); + (idle, progress) + }; + for progress in lifecycle_progress { + self.run_lifecycle_progress(progress); + } + if let Some(idle) = idle_timeout { + self.schedule_idle_timeout(idle); + } + } + pub(super) fn finish_message_event_completed( &self, completion: ServiceWorkerMessageCompletion, @@ -501,7 +560,7 @@ pub(super) fn service_worker_fetch_diagnostic_from_job_result( result: &ServiceWorkerFetchResult, ) -> crate::runtime::RendererServiceWorkerFetchDiagnostic { let result = match result { - ServiceWorkerFetchResult::Fallback => { + ServiceWorkerFetchResult::Fallback | ServiceWorkerFetchResult::FallbackStream(_) => { crate::runtime::RendererServiceWorkerFetchDiagnosticResult::Fallback } ServiceWorkerFetchResult::Response(response) => { diff --git a/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs b/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs index 27d4fadba73..ed550c6c47b 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs @@ -241,6 +241,9 @@ impl ServiceWorkerRuntimeService { pub(crate) fn dispatch_controlled_fetch(&self, dispatch: ServiceWorkerFetchDispatch) -> bool { let request = dispatch.request.clone(); let fetch_job = ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: dispatch.request_body_owner, + body_stream: request.body_stream.clone(), request: { let origin = dispatch.network_context.request_origin.clone(); let mut network_request = moli_fetch::Request::new_browser( diff --git a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs index c80f7a6442a..312bc421f7a 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs @@ -51,6 +51,7 @@ fn service_worker_redirect_target( fn fetch_request_for_job(job: &ServiceWorkerFetchJob) -> ServiceWorkerFetchRequest { ServiceWorkerFetchRequest { + body_stream: job.body_stream.clone(), client_id: job.client_id, resulting_client_id: job.resulting_client_id, url: job.request.url.clone(), @@ -78,7 +79,9 @@ pub(super) fn service_worker_network_fallback_request_for_job( .policy_context .network_credentials_mode(job.request.request_mode, job.request.credentials_mode), ) - .with_use_cors_preflight(job.metadata.use_cors_preflight) + .with_use_cors_preflight( + job.metadata.use_cors_preflight || job.request.body_source_is_null(), + ) .with_browser_request_metadata(service_worker_fetch_browser_metadata( job.network_context.resource_type, )) @@ -143,22 +146,24 @@ fn service_worker_fetch_can_forward_stream( response_head.final_url.as_ref(), &response_head.headers, )?; - Ok(job.direct_completion_tx.is_none() - && job.metadata.integrity.is_empty() - && !matches!( - job.network_context.resource_type, - crate::types::SubresourceResourceType::Audio - | crate::types::SubresourceResourceType::Font - | crate::types::SubresourceResourceType::Image - | crate::types::SubresourceResourceType::Media - | crate::types::SubresourceResourceType::TextTrack - | crate::types::SubresourceResourceType::Video - ) - && !is_redirect_status(response_head.status) - && matches!( - response_head.response_type.as_str(), - "default" | "basic" | "cors" - )) + Ok( + (job.direct_completion_tx.is_none() || job.request_body_owner.is_some()) + && job.metadata.integrity.is_empty() + && !matches!( + job.network_context.resource_type, + crate::types::SubresourceResourceType::Audio + | crate::types::SubresourceResourceType::Font + | crate::types::SubresourceResourceType::Image + | crate::types::SubresourceResourceType::Media + | crate::types::SubresourceResourceType::TextTrack + | crate::types::SubresourceResourceType::Video + ) + && !is_redirect_status(response_head.status) + && matches!( + response_head.response_type.as_str(), + "default" | "basic" | "cors" + ), + ) } fn apply_service_worker_synthetic_redirect( @@ -166,6 +171,9 @@ fn apply_service_worker_synthetic_redirect( response: ServiceWorkerFetchResponse, next_url: Url, ) -> Result<(), String> { + if response.status != 303 && job.request.body_source_is_null() { + return Err("Cannot replay a streaming request body after a redirect".to_owned()); + } let from_url = response .final_url .unwrap_or_else(|| job.request.url.clone()); @@ -186,6 +194,10 @@ fn apply_service_worker_synthetic_redirect( negotiated_http_version: None, }) .map_err(|error| error.to_string())?; + if response.status == 303 { + job.body_stream = None; + job.metadata.body_source_is_null = job.request.body_source_is_null(); + } job.cors_preflight_request_headers = job.request.request_headers.to_byte_strings(); Ok(()) } @@ -214,9 +226,11 @@ impl ServiceWorkerRuntimeService { crate::page_task_queue::RendererResourceCompletionSender::direct_completion_only(); let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 0, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: Some(client_id), url: request.url.clone(), @@ -255,6 +269,10 @@ impl ServiceWorkerRuntimeService { } match direct_completion_rx.await { + Ok( + ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::Stream(_), + ) => Err("worker script requests cannot contain an author stream".to_owned()), Ok(ServiceWorkerDirectFetchResult::Fallback) => Ok(None), Ok(ServiceWorkerDirectFetchResult::Response(response)) => Ok(Some(*response.response)), Ok(ServiceWorkerDirectFetchResult::Failure(message)) => Err(message), @@ -266,12 +284,31 @@ impl ServiceWorkerRuntimeService { pub(super) fn dispatch_fetch_fallback(&self, mut job: ServiceWorkerFetchJob) { job.cancel_pending_navigation_preload(); + if let Some(stream) = job.body_stream.take() { + // Startup failure can select network fallback before a FetchEvent + // ever acquires its receiver. Return that pipe to the exact client + // script owner; IO retains only the bounded native upload. + let Some(owner) = job.request_body_owner.as_ref() else { + self.complete_fetch_with_failure( + job, + "Missing request body owner for fallback".to_owned(), + ); + return; + }; + let (sender, body) = moli_fetch::UploadBody::channel(); + owner(stream, sender, job.cancel_handle.clone()); + job.request = job.request.with_upload_body(body); + } if let Some(completion_tx) = job.direct_completion_tx.take() { if job.request.redirect_count() != 0 { self.dispatch_direct_fetch_network_fallback(job, completion_tx); return; } - let _ = completion_tx.send(ServiceWorkerDirectFetchResult::Fallback); + let result = job.request.upload_body().cloned().map_or( + ServiceWorkerDirectFetchResult::Fallback, + ServiceWorkerDirectFetchResult::FallbackStream, + ); + let _ = completion_tx.send(result); return; } let request_client = job.request_client.clone(); @@ -381,7 +418,7 @@ impl ServiceWorkerRuntimeService { return; } - let Some((completion_tx, request_client, request, streaming_started)) = ({ + let Some((completion_tx, request_client, request, streaming_started, direct)) = ({ let mut state = self.inner.state.lock(); let Some(job) = state.pending_fetch_jobs.get_mut(&started.event_id) else { return; @@ -399,6 +436,27 @@ impl ServiceWorkerRuntimeService { } } job.streaming_body_source_id = Some(started.body_source_id); + let direct = job.direct_completion_tx.take().map(|completion| { + let (sender, events) = tokio::sync::mpsc::unbounded_channel(); + job.direct_streaming_tx = Some(sender); + ( + completion, + super::super::events::ServiceWorkerDirectFetchStream { + body_source_id: started.body_source_id, + head: service_worker_fetch_stream_response_head( + job, + &started.response_head, + ), + response_filter: service_worker_fetch_response_head_filter( + &started.response_head.response_type, + started.response_head.cors_exposed_header_names.as_deref(), + started.response_head.status, + job.request.redirect_mode(), + ), + events, + }, + ) + }); Some(( job.completion_tx.clone(), job.request_client.clone(), @@ -420,11 +478,16 @@ impl ServiceWorkerRuntimeService { network_request_headers: None, head: service_worker_fetch_stream_response_head(job, &started.response_head), }, + direct, )) }) else { return; }; request_client.observe_service_worker_response_links(&request, &streaming_started.head); + if let Some((completion, stream)) = direct { + let _ = completion.send(ServiceWorkerDirectFetchResult::Stream(Box::new(stream))); + return; + } let _ = completion_tx.send_async_subresource_event( AsyncSubresourceFetchEvent::StreamingStarted(Box::new(streaming_started)), ); @@ -511,18 +574,24 @@ impl ServiceWorkerRuntimeService { } pub(super) fn finish_fetch_stream_chunk(&self, chunk: ServiceWorkerFetchStreamChunk) { - let Some(completion_tx) = ({ + let Some((completion_tx, direct)) = ({ let state = self.inner.state.lock(); state .pending_fetch_jobs .get(&chunk.event_id) .and_then(|job| { (job.streaming_body_source_id == Some(chunk.body_source_id)) - .then(|| job.completion_tx.clone()) + .then(|| (job.completion_tx.clone(), job.direct_streaming_tx.clone())) }) }) else { return; }; + if let Some(direct) = direct { + let _ = direct.send( + super::super::events::ServiceWorkerDirectFetchStreamEvent::Chunk(chunk.bytes), + ); + return; + } let _ = completion_tx.send_async_subresource_event( AsyncSubresourceFetchEvent::StreamingChunk(AsyncSubresourceStreamingChunk { body_source_id: chunk.body_source_id, @@ -660,6 +729,11 @@ impl ServiceWorkerRuntimeService { job.request_client .observe_service_worker_response_links(&job.request, &navigation_response.head()); } + if let Some(direct) = job.direct_streaming_tx.take() { + let _ = direct + .send(super::super::events::ServiceWorkerDirectFetchStreamEvent::Finished(Ok(()))); + return; + } if let Some(completion_tx) = job.direct_completion_tx.take() { let _ = completion_tx.send(ServiceWorkerDirectFetchResult::Response( ServiceWorkerDirectFetchResponse { @@ -720,6 +794,12 @@ impl ServiceWorkerRuntimeService { if network_error_text.is_none() { network_error_text = service_worker_fetch_failure_network_error_text(&message); } + if let Some(direct) = job.direct_streaming_tx.take() { + let _ = direct.send( + super::super::events::ServiceWorkerDirectFetchStreamEvent::Finished(Err(message)), + ); + return; + } if let Some(completion_tx) = job.direct_completion_tx.take() { let _ = completion_tx.send(ServiceWorkerDirectFetchResult::Failure(message)); return; @@ -1167,6 +1247,9 @@ mod tests { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -2303,6 +2386,9 @@ mod tests { let completion_queue = crate::page_task_queue::RendererResourceCompletionTestHarness::new(); let request_url = url("https://example.test/app/post"); let mut job = ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&request_url); let initiator = request_url.clone(); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/clients.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/clients.rs index 1ffcd08944c..8686fa87fb8 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/clients.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/clients.rs @@ -2329,9 +2329,11 @@ async fn controlled_fetch_from_worker_client_dispatches_to_active_worker() { let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); assert!( service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 90, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url.clone(), diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs index ef648151d38..6eaec51be2a 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs @@ -370,6 +370,9 @@ fn pending_unregistration_waits_for_active_fetch_to_complete_before_delete() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -678,9 +681,11 @@ fn resource_store_restores_no_fetch_handler_metadata_for_controlled_fetch() { let (direct_completion_tx, mut direct_completion_rx) = tokio::sync::oneshot::channel(); assert!( second_service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 89, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -838,6 +843,9 @@ fn restart_start_failure_rejects_pending_fetch_job() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = document_url.clone(); @@ -901,6 +909,7 @@ fn restart_start_failure_rejects_pending_fetch_job() { event_id, owner: test_run_owner(version_id, &run), request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -1624,9 +1633,11 @@ fn no_fetch_handler_controlled_fetch_falls_back_without_dispatching_event() { let (direct_completion_tx, mut direct_completion_rx) = tokio::sync::oneshot::channel(); assert!( service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 88, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url.clone(), @@ -1716,9 +1727,11 @@ fn controlled_fetch_waits_for_activating_active_version() { assert!( service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 91, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -1826,9 +1839,11 @@ fn empty_fetch_handler_controlled_fetch_falls_back_without_dispatching_event() { let (direct_completion_tx, mut direct_completion_rx) = tokio::sync::oneshot::channel(); assert!( service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 89, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -1906,6 +1921,7 @@ fn empty_fetch_handler_pending_start_fetch_falls_back_after_worker_start() { let client_id = client_id_for_document(&service, &document_url); let host = new_loading_test_host(version_id, &run); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url.clone(), @@ -1926,6 +1942,9 @@ fn empty_fetch_handler_pending_start_fetch_falls_back_after_worker_start() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -2054,6 +2073,9 @@ fn fetch_completion_schedules_idle_timeout_for_running_active_worker() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -2284,6 +2306,9 @@ fn active_fetch_completion_queues_waiting_activation_after_controllees_are_gone( state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -2477,6 +2502,9 @@ fn activating_new_worker_fails_replaced_active_fetch_and_pending_start_events() state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = document_url.clone(); @@ -2541,6 +2569,7 @@ fn activating_new_worker_fails_replaced_active_fetch_and_pending_start_events() event_id: pending_event_id, owner: test_run_owner(active_version_id, &active_run), request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url.clone(), @@ -2562,6 +2591,7 @@ fn activating_new_worker_fails_replaced_active_fetch_and_pending_start_events() event_id: activation_wait_event_id, owner: test_run_owner(active_version_id, &active_run), request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs index 7145f491cea..50d22ea33bf 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs @@ -227,6 +227,9 @@ fn pending_unregistration_deletion_clears_owner_state() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&request_url); let initiator = request_url.clone(); diff --git a/moli-renderer-v8/src/service_worker_runtime/state.rs b/moli-renderer-v8/src/service_worker_runtime/state.rs index 8aff4607e66..694fe819362 100644 --- a/moli-renderer-v8/src/service_worker_runtime/state.rs +++ b/moli-renderer-v8/src/service_worker_runtime/state.rs @@ -181,6 +181,7 @@ pub(super) struct ServiceWorkerRuntimeState { pub(super) versions: HashMap, pub(super) pending_ready_jobs: Vec, pub(super) pending_fetch_jobs: HashMap, + pub(super) pending_fetch_body_uploads: HashMap, pub(super) lifecycle_watchers: Vec, pub(super) live_clients: HashMap, pub(super) notification_records: Vec, @@ -286,6 +287,7 @@ impl ServiceWorkerRuntimeState { versions: HashMap::new(), pending_ready_jobs: Vec::new(), pending_fetch_jobs: HashMap::new(), + pending_fetch_body_uploads: HashMap::new(), lifecycle_watchers: Vec::new(), live_clients: HashMap::new(), notification_records: Vec::new(), @@ -768,6 +770,11 @@ pub(super) enum ServiceWorkerPeriodicSyncStart { } pub(super) struct ServiceWorkerFetchJob { + pub(super) direct_streaming_tx: Option< + tokio::sync::mpsc::UnboundedSender, + >, + pub(super) request_body_owner: Option, + pub(super) body_stream: Option, pub(super) request: moli_fetch::Request, pub(super) internal_id: u64, pub(super) owner: Option, diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs index 5b4650b2ce4..363290bac88 100644 --- a/moli-renderer-v8/src/types.rs +++ b/moli-renderer-v8/src/types.rs @@ -1038,6 +1038,10 @@ pub(crate) enum AsyncSubresourceFetchEventTarget { #[derive(Debug)] pub(super) enum AsyncSubresourceFetchEvent { + RequestBodyProducer { + internal_id: u64, + producer: crate::context_bootstrap::RequestBodyProducer, + }, RequestUploadReady { internal_id: u64, result: Result<(), moli_fetch::UploadBodyError>, @@ -1068,6 +1072,11 @@ pub(super) enum AsyncSubresourceFetchEvent { impl AsyncSubresourceFetchEvent { pub(crate) fn target(&self) -> AsyncSubresourceFetchEventTarget { match self { + Self::RequestBodyProducer { internal_id, .. } => { + AsyncSubresourceFetchEventTarget::RequestUpload { + internal_id: *internal_id, + } + } Self::RequestUploadReady { internal_id, .. } => { AsyncSubresourceFetchEventTarget::RequestUpload { internal_id: *internal_id, diff --git a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs index 7506766780a..12e34ed7a22 100644 --- a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs +++ b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs @@ -590,9 +590,11 @@ fn dispatch_worker_content_security_policy_report_to_service_worker( load.attach_cancel_handle(cancel_handle.clone()); let request_metadata = service_worker_fetch_request_metadata(&request); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request.url.clone(), @@ -641,6 +643,29 @@ fn dispatch_worker_content_security_policy_report_to_service_worker( let task_runner = load.task_runner(); task_runner.spawn(async move { match direct_completion_rx.await { + Ok(ServiceWorkerDirectFetchResult::Stream(_)) => { + load.finish(); + send_worker_content_security_policy_report_failure( + parent_tx, + request_handle, + continue_internal_id, + document_url, + request, + request_body, + "CSP report requests do not use a response stream route".to_owned(), + ); + } + Ok(ServiceWorkerDirectFetchResult::FallbackStream(body)) => { + spawn_worker_content_security_policy_report_network( + parent_tx, + load, + request_handle, + continue_internal_id, + document_url, + request.with_upload_body(body), + request_body, + ); + } Ok(ServiceWorkerDirectFetchResult::Fallback) => { spawn_worker_content_security_policy_report_network( parent_tx, diff --git a/moli-renderer-v8/src/worker/global_scope/extendable_events.rs b/moli-renderer-v8/src/worker/global_scope/extendable_events.rs index c375596b688..b321f51ba26 100644 --- a/moli-renderer-v8/src/worker/global_scope/extendable_events.rs +++ b/moli-renderer-v8/src/worker/global_scope/extendable_events.rs @@ -103,6 +103,7 @@ pub(in crate::worker) struct PendingServiceWorkerPeriodicSyncEvent { } pub(in crate::worker) struct PendingServiceWorkerFetchEvent { + pub(in crate::worker) request_for_body: Option>, pub(in crate::worker) completion: ServiceWorkerFetchCompletion, pub(in crate::worker) handled_resolver: Option>, pub(in crate::worker) request_signal_id: Option, @@ -125,6 +126,7 @@ impl PendingServiceWorkerFetchEvent { request_destination: ServiceWorkerRequestDestination, ) -> Self { Self { + request_for_body: None, completion: ServiceWorkerFetchCompletion { result: ServiceWorkerFetchResult::Fallback, ..completion diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index 4ba212fbc67..65c1637c8cd 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -5,9 +5,9 @@ use crate::network_host::{ fetch_browser_subresource_raw_stream_for_owner, local_url_response_with_blob_entry, }; use crate::service_worker_runtime::{ - ServiceWorkerClientId, ServiceWorkerDirectFetchResult, ServiceWorkerFetchDispatch, - ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination, - ServiceWorkerRuntimeService, + ServiceWorkerClientId, ServiceWorkerDirectFetchResult, ServiceWorkerDirectFetchStreamEvent, + ServiceWorkerFetchDispatch, ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, + ServiceWorkerRequestDestination, ServiceWorkerRuntimeService, }; use crate::types::{AsyncSubresourceNetworkContext, SubresourcePolicyContext}; @@ -424,6 +424,8 @@ pub(in crate::worker) fn spawn_worker_fetch_network( timing.observe_head(&head); let _ = completion_tx.send(WorkerFetchEvent::StreamingStarted( WorkerFetchStreamingStarted { + response_filter: None, + skip_fetch_security_validation: false, fetch_id, body_source_id, head: head.clone(), @@ -536,6 +538,8 @@ fn spawn_worker_fetch_service_worker( resolved_url: Url, method: String, body: Option, + body_stream: Option, + request_body_owner: crate::context_bootstrap::RequestBodyOwner, headers: moli_fetch::RequestHeaders, request_mode: RequestMode, credentials_mode: RequestCredentialsMode, @@ -546,9 +550,11 @@ fn spawn_worker_fetch_service_worker( ) { let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: Some(request_body_owner), redirect_check: redirect_check.clone(), internal_id: u64::from(fetch_id), request: ServiceWorkerFetchRequest { + body_stream, client_id, resulting_client_id: None, url: resolved_url.clone(), @@ -600,7 +606,14 @@ fn spawn_worker_fetch_service_worker( // A controlled request can fall back after the client Worker has closed. load.task_runner().spawn(async move { match direct_completion_rx.await { - Ok(ServiceWorkerDirectFetchResult::Fallback) => { + Ok( + result @ (ServiceWorkerDirectFetchResult::Fallback + | ServiceWorkerDirectFetchResult::FallbackStream(_)), + ) => { + let upload = match result { + ServiceWorkerDirectFetchResult::FallbackStream(body) => Some(body), + _ => None, + }; spawn_worker_fetch_network( kind, load, @@ -626,10 +639,63 @@ fn spawn_worker_fetch_service_worker( None, Vec::new(), redirect_check, - None, + upload, ); return; } + Ok(ServiceWorkerDirectFetchResult::Stream(mut stream)) => { + timing.begin_synthetic_response(); + timing.observe_head(&stream.head); + let head = stream.head; + let body_source_id = stream.body_source_id; + let _ = completion_tx.send(WorkerFetchEvent::StreamingStarted( + WorkerFetchStreamingStarted { + fetch_id, + body_source_id, + head: head.clone(), + network_request_headers: None, + response_filter: stream.response_filter, + skip_fetch_security_validation: true, + }, + )); + let mut body = SubresourceResponseBodyWriter::with_disk_pool( + load.request_client().disk_pool(), + ); + let result = loop { + let event = tokio::select! { + _ = cancel_handle.cancelled() => break Err(ABORTED_ERROR_TEXT.to_owned()), + event = stream.events.recv() => event, + }; + match event { + Some(ServiceWorkerDirectFetchStreamEvent::Chunk(bytes)) => { + timing.observe_chunk(bytes.len()); + body.append(&bytes); + let _ = completion_tx.send(WorkerFetchEvent::StreamingChunk( + WorkerFetchStreamingChunk { + fetch_id, + body_source_id, + bytes, + }, + )); + } + Some(ServiceWorkerDirectFetchStreamEvent::Finished(result)) => { + break result; + } + None => break Err("service worker response stream closed".to_owned()), + } + }; + timing.complete(); + let _ = completion_tx.send(WorkerFetchEvent::StreamingFinished( + WorkerFetchStreamingFinished { + fetch_id, + body_source_id, + head, + result: result.map(|()| body.finish()), + }, + )); + let _ = completion_tx.send(WorkerFetchEvent::ResourceTiming { fetch_id, timing }); + return; + } Ok(ServiceWorkerDirectFetchResult::Response(response)) => { if !response.from_network_fallback { timing.begin_synthetic_response(); @@ -2856,6 +2922,44 @@ pub(super) fn start_worker_resource_fetch<'s>( }; if let Some((service_worker_runtime, service_worker_client_id)) = service_worker_controller { + let transferred = if request_metadata.body_source_is_null { + body_stream.as_ref().and_then(|stream| { + let stream = v8::Local::new(scope, stream); + crate::context_bootstrap::transfer_request_body( + scope, + stream, + body_stream_locked, + ) + }) + } else { + None + }; + if request_metadata.body_source_is_null + && body_stream.is_some() + && transferred.is_none() + { + state.borrow_mut().pending_fetches.remove(&fetch_id); + resolver.reject( + scope, + v8::Exception::type_error( + scope, + v8str(scope, "Failed to transfer request body"), + ), + ); + return Some(promise); + } + if let Some(signal) = signal + && let Some(stream) = body_stream.as_ref() + { + let stream = v8::Local::new(scope, stream); + crate::context_bootstrap::install_request_body_abort(scope, stream, signal); + } + let events = completion_tx.clone(); + let request_body_owner = + crate::context_bootstrap::request_body_owner(scope, move |producer| { + let _ = + events.send(WorkerFetchEvent::RequestBodyProducer { fetch_id, producer }); + }); spawn_worker_fetch_service_worker( kind, service_worker_runtime, @@ -2872,6 +2976,8 @@ pub(super) fn start_worker_resource_fetch<'s>( resolved_url, method, body, + transferred, + request_body_owner, headers, request_mode, credentials_mode, @@ -3036,6 +3142,84 @@ pub(in crate::worker) fn drain_worker_fetch_completion( event: WorkerFetchEvent, ) { match event { + WorkerFetchEvent::RequestBodyProducer { + fetch_id, + mut producer, + } => { + let delivery = { + let state = state.borrow(); + state + .pending_fetches + .get(&fetch_id) + .filter(|pending| !pending.load.is_cancelled()) + .map(|pending| { + ( + pending.resolver.clone(), + pending.load.task_runner(), + state.fetch_completion_tx.clone(), + ) + }) + }; + if let Some((resolver, runner, completion)) = delivery { + let stream = crate::context_bootstrap::build_readable_stream_clone_shell(scope); + let payload = producer.take_stream(); + if crate::context_bootstrap::initialize_request_body_stream(scope, stream, &payload) + .is_some() + { + let resolver = v8::Local::new(scope, resolver); + match crate::network_host::RequestUpload::with_sender( + scope, + stream, + resolver, + false, + runner, + producer.cancel.clone(), + move |result| { + let _ = completion + .send(WorkerFetchEvent::RequestUploadReady { fetch_id, result }); + }, + producer.take_sender(), + ) { + Ok(upload) => { + state + .borrow_mut() + .pending_fetches + .get_mut(&fetch_id) + .expect("body producer fetch") + .upload = Some(upload.clone()); + upload.start(scope); + } + Err(reason) => { + resolver.reject(scope, reason); + } + } + } + } + } + WorkerFetchEvent::ServiceWorkerUploadReady { event_id, result } => { + let upload = state + .borrow() + .pending_service_worker_request_uploads + .get(&event_id) + .cloned(); + if let Some(upload) = upload { + upload.ready(scope, result); + } + } + WorkerFetchEvent::ServiceWorkerUploadFinished { event_id, result } => { + let upload = state + .borrow_mut() + .pending_service_worker_request_uploads + .remove(&event_id); + if let Some(upload) = upload { + if result.is_ok() { + upload.finish(scope); + } else { + let reason = v8::Exception::type_error(scope, v8str(scope, "Failed to fetch")); + upload.stop(scope, reason); + } + } + } WorkerFetchEvent::RequestUploadReady { fetch_id, result } => { let upload = state .borrow() @@ -3161,7 +3345,11 @@ pub(in crate::worker) fn start_worker_streaming_fetch( let Some(pending) = state_ref.pending_fetches.get(&started.fetch_id) else { return; }; - worker_fetch_response_csp_violations(&state_ref, pending, &started.head) + if started.skip_fetch_security_validation { + (None, None) + } else { + worker_fetch_response_csp_violations(&state_ref, pending, &started.head) + } }; if let Some(violation) = report_only_violation { dispatch_worker_content_security_policy_violation_event_for_state(scope, state, &violation); @@ -3185,35 +3373,42 @@ pub(in crate::worker) fn start_worker_streaming_fetch( return; }; let request_origin = pending.timing.origin().clone(); - if let Err(message) = validate_fetch_response_headers( - &request_origin, - &started.head, - pending.request_mode, - pending.credentials_mode, - pending.policy_context, - ) { + let validation = if started.skip_fetch_security_validation { + Ok(()) + } else { + validate_fetch_response_headers( + &request_origin, + &started.head, + pending.request_mode, + pending.credentials_mode, + pending.policy_context, + ) + }; + if let Err(message) = validation { pending.load.cancel(); reject = Some((pending.resolver.clone(), message)); None } else { - pending.streaming_needs_orb_body_validation = - crate::network_host::fetch_response_needs_orb_body_validation( + pending.streaming_needs_orb_body_validation = !started.skip_fetch_security_validation + && crate::network_host::fetch_response_needs_orb_body_validation( &request_origin, &started.head.final_url, &started.head.headers, pending.request_mode, ); let observable_head = started.head.clone(); - let response_filter = crate::network_host::FetchResponseRequest { - method: &pending.request_method, - mode: pending.request_mode, - redirect_mode: pending.redirect_mode, - } - .network_response_filter( - &request_origin, - &observable_head, - pending.credentials_mode, - ); + let response_filter = started.response_filter.clone().unwrap_or_else(|| { + crate::network_host::FetchResponseRequest { + method: &pending.request_method, + mode: pending.request_mode, + redirect_mode: pending.redirect_mode, + } + .network_response_filter( + &request_origin, + &observable_head, + pending.credentials_mode, + ) + }); pending.streaming_body_source_id = Some(started.body_source_id); Some(( pending.resolver.clone(), diff --git a/moli-renderer-v8/src/worker/global_scope/network_state.rs b/moli-renderer-v8/src/worker/global_scope/network_state.rs index af5da57af01..5bd4033ff8a 100644 --- a/moli-renderer-v8/src/worker/global_scope/network_state.rs +++ b/moli-renderer-v8/src/worker/global_scope/network_state.rs @@ -35,6 +35,18 @@ pub(in crate::worker) struct PendingWorkerFetch { } pub(in crate::worker) enum WorkerFetchEvent { + RequestBodyProducer { + fetch_id: u32, + producer: crate::context_bootstrap::RequestBodyProducer, + }, + ServiceWorkerUploadReady { + event_id: crate::runtime::ServiceWorkerEventId, + result: Result<(), moli_fetch::UploadBodyError>, + }, + ServiceWorkerUploadFinished { + event_id: crate::runtime::ServiceWorkerEventId, + result: Result<(), moli_fetch::UploadBodyError>, + }, RequestUploadReady { fetch_id: u32, result: Result<(), moli_fetch::UploadBodyError>, @@ -65,6 +77,8 @@ pub(in crate::worker) struct WorkerFetchCompletion { } pub(in crate::worker) struct WorkerFetchStreamingStarted { + pub(super) response_filter: Option, + pub(super) skip_fetch_security_validation: bool, pub(super) fetch_id: u32, pub(super) body_source_id: NetworkBodySourceId, pub(super) head: ResponseHead, diff --git a/moli-renderer-v8/src/worker/global_scope/state.rs b/moli-renderer-v8/src/worker/global_scope/state.rs index f74c86e50fb..df937f6a18c 100644 --- a/moli-renderer-v8/src/worker/global_scope/state.rs +++ b/moli-renderer-v8/src/worker/global_scope/state.rs @@ -263,6 +263,8 @@ pub(crate) struct WorkerGlobalState { /// and minimal `waitUntil()` promises to finish. pub(in crate::worker) pending_service_worker_fetch_events: HashMap, + pub(in crate::worker) pending_service_worker_request_uploads: + HashMap, /// Navigation preload promises and response bodies stay alive until preload complete/error. pub(in crate::worker) pending_service_worker_navigation_preloads: HashMap, diff --git a/moli-renderer-v8/src/worker/thread/dispatch.rs b/moli-renderer-v8/src/worker/thread/dispatch.rs index e9905c8ce63..179ae133dec 100644 --- a/moli-renderer-v8/src/worker/thread/dispatch.rs +++ b/moli-renderer-v8/src/worker/thread/dispatch.rs @@ -1096,6 +1096,9 @@ fn dispatch_service_worker_fetch_event_in_context<'s>( event.request.destination, ); pending.handled_resolver = Some(v8::Global::new(scope, handled_resolver)); + if event.request.body_stream.is_some() { + pending.request_for_body = Some(v8::Global::new(scope, request)); + } if event.navigation_preload_sent { state.pending_service_worker_navigation_preloads.insert( event.event_id, @@ -1119,6 +1122,7 @@ fn dispatch_service_worker_fetch_event_in_context<'s>( if default_prevented_without_response { mark_service_worker_fetch_default_prevented(state, event.event_id); } + reject_consumed_streaming_fallback(scope, state, event.event_id); mark_service_worker_fetch_dispatch_finished(state, event.event_id); settle_service_worker_fetch_handled_after_dispatch(scope, state, event.event_id); maybe_send_service_worker_fetch_completion(state, event.event_id, scope); @@ -1763,7 +1767,12 @@ fn new_service_worker_fetch_request<'s>( set_object_string(scope, headers, name, value); } let _ = init.set(scope, v8str(scope, "headers").into(), headers.into()); - if !matches!(event.request.method.as_str(), "GET" | "HEAD") + if let Some(payload) = event.request.body_stream.as_ref() { + let stream = crate::context_bootstrap::build_readable_stream_clone_shell(scope); + crate::context_bootstrap::initialize_request_body_stream(scope, stream, payload)?; + let _ = init.set(scope, v8str(scope, "body").into(), stream.into()); + set_object_string(scope, init, "duplex", "half"); + } else if !matches!(event.request.method.as_str(), "GET" | "HEAD") && let Some(body) = event.request.body.clone() { // The mutable JS buffer must not alias shared immutable upload bytes. @@ -3409,7 +3418,9 @@ fn settle_service_worker_fetch_handled_for_pending( }; let resolver = v8::Local::new(scope, resolver); match &pending.completion.result { - ServiceWorkerFetchResult::Response(_) | ServiceWorkerFetchResult::Fallback => { + ServiceWorkerFetchResult::Response(_) + | ServiceWorkerFetchResult::Fallback + | ServiceWorkerFetchResult::FallbackStream(_) => { let value = v8::undefined(scope); let _ = resolver.resolve(scope, value.into()); } @@ -3601,12 +3612,49 @@ fn maybe_send_service_worker_lifecycle_completion( )); } +fn reject_consumed_streaming_fallback( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + event_id: ServiceWorkerEventId, +) { + let request = { + let state = state.borrow(); + let Some(pending) = state.pending_service_worker_fetch_events.get(&event_id) else { + return; + }; + if !matches!( + pending.completion.result, + ServiceWorkerFetchResult::Fallback + ) { + return; + } + pending.request_for_body.clone() + }; + if let Some(request) = request { + let request = v8::Local::new(scope, request); + if let Some(body) = crate::network_host::body_stream_object(scope, request) + && (crate::context_bootstrap::readable_stream_locked(scope, body) + || crate::context_bootstrap::readable_stream_disturbed(scope, body)) + { + state + .borrow_mut() + .pending_service_worker_fetch_events + .get_mut(&event_id) + .expect("current FetchEvent") + .completion + .result = ServiceWorkerFetchResult::Failure( + "Cannot use a consumed streaming body for network fallback".to_owned(), + ); + } + } +} + fn maybe_send_service_worker_fetch_completion( state: &Rc>, event_id: ServiceWorkerEventId, scope: &mut v8::PinScope<'_, '_>, ) { - let (parent_tx, completion, handled_settled) = { + let (parent_tx, mut completion, handled_settled, request_body) = { let mut state = state.borrow_mut(); let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else { return; @@ -3619,9 +3667,73 @@ fn maybe_send_service_worker_fetch_completion( } let handled_settled = settle_service_worker_fetch_handled_for_pending(scope, pending); let completion = pending.completion.clone(); + let request_body = pending.request_for_body.clone(); state.pending_service_worker_fetch_events.remove(&event_id); - (state.parent_tx.clone(), completion, handled_settled) + ( + state.parent_tx.clone(), + completion, + handled_settled, + request_body, + ) }; + if matches!(completion.result, ServiceWorkerFetchResult::Fallback) + && let Some(body) = request_body + { + let request = v8::Local::new(scope, body); + let body = crate::network_host::body_stream_object(scope, request) + .expect("streaming FetchEvent body"); + completion.result = if crate::context_bootstrap::readable_stream_locked(scope, body) + || crate::context_bootstrap::readable_stream_disturbed(scope, body) + { + ServiceWorkerFetchResult::Failure( + "Cannot use a consumed streaming body for network fallback".to_owned(), + ) + } else { + let (runner, events) = { + let state = state.borrow(); + ( + state.loader.task_runner(), + state.fetch_completion_tx.clone(), + ) + }; + let resolver = v8::PromiseResolver::new(scope).expect("fallback upload resolver"); + resolver.get_promise(scope).mark_as_handled(); + let ready = events.clone(); + match crate::network_host::RequestUpload::new( + scope, + body, + resolver, + false, + runner.clone(), + moli_fetch::FetchCancelHandle::new(), + move |result| { + let _ = ready.send( + super::super::global_scope::WorkerFetchEvent::ServiceWorkerUploadReady { + event_id, + result, + }, + ); + }, + ) { + Ok((upload, body)) => { + state + .borrow_mut() + .pending_service_worker_request_uploads + .insert(event_id, upload.clone()); + upload.start(scope); + let transmission = body.transmission(); + runner.spawn(async move { + let result = transmission.await; + let _ = events.send(super::super::global_scope::WorkerFetchEvent::ServiceWorkerUploadFinished { event_id, result }); + }); + ServiceWorkerFetchResult::FallbackStream(body) + } + Err(_) => ServiceWorkerFetchResult::Failure( + "Failed to acquire fallback request body".to_owned(), + ), + } + }; + } if handled_settled { perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope); } diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index abbcdef4971..8678a9ef2ae 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -1924,6 +1924,7 @@ async fn worker_main( service_worker_window_interaction_allowed_count: 0, pending_service_worker_lifecycle_events: std::collections::HashMap::new(), pending_service_worker_fetch_events: std::collections::HashMap::new(), + pending_service_worker_request_uploads: std::collections::HashMap::new(), pending_service_worker_navigation_preloads: std::collections::HashMap::new(), pending_service_worker_message_events: std::collections::HashMap::new(), pending_service_worker_notification_events: std::collections::HashMap::new(), @@ -3818,6 +3819,10 @@ async fn worker_main( crate::context_bootstrap::retire_indexed_db_context(ctx); runtime_inspector.context_destroyed(ctx); } + state + .borrow_mut() + .pending_service_worker_request_uploads + .clear(); let common = Rc::clone(&state.borrow().common); common.clear_for_context_teardown(); state.borrow_mut().rtp_transformers.clear(); diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs index 1c6545d7bea..646f0b888a3 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs @@ -615,6 +615,7 @@ async fn service_worker_navigation_requests_preserve_native_flags_until_init_ove let native = moli_fetch::Request::get_with_url(url.clone()).with_browser_navigation_kind(kind); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), resulting_client_id: None, url, @@ -679,6 +680,7 @@ async fn service_worker_fetch_event_request_exposes_destination_metadata() { ); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), resulting_client_id: None, url: url::Url::parse("https://example.test/app/script.js").unwrap(), @@ -737,6 +739,7 @@ async fn service_worker_fetch_event_exposes_resulting_client_metadata() { let resulting_client_id = crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(8); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: Some(resulting_client_id), url: url::Url::parse("https://example.test/app/").unwrap(), @@ -935,6 +938,7 @@ async fn service_worker_fetch_event_request_body_used_guards_inherited_body() { ); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), resulting_client_id: None, url: url::Url::parse("https://example.test/app/post").unwrap(), diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs index f879eacdea7..ffde3fd16a0 100644 --- a/moli-renderer-v8/src/worker/thread/tests/mod.rs +++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs @@ -417,6 +417,7 @@ async fn dispatch_service_worker_fetch_event_for_test( fn service_worker_fetch_request_for_test() -> ServiceWorkerFetchRequest { ServiceWorkerFetchRequest { + body_stream: None, client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), resulting_client_id: None, url: url::Url::parse("https://example.test/app/data.txt").unwrap(), diff --git a/moli-renderer-v8/tests/fixtures/controlled-request-upload-worker.js b/moli-renderer-v8/tests/fixtures/controlled-request-upload-worker.js new file mode 100644 index 00000000000..eccac231741 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/controlled-request-upload-worker.js @@ -0,0 +1,31 @@ +self.oninstall = event => event.waitUntil(skipWaiting()); +self.onactivate = event => event.waitUntil(clients.claim()); +self.onfetch = event => { + const url = new URL(event.request.url); + if (url.pathname !== '/upload') return; + const mode = url.searchParams.get('mode'); + if (mode === 'byob') { + event.respondWith((async () => { + const reader = event.request.body.getReader({mode: 'byob'}); + const bytes = []; + while (true) { + const {done, value} = await reader.read(new Uint8Array(3)); + bytes.push(...value); + if (done) break; + } + return new Response(JSON.stringify(bytes)); + })()); + } else if (mode === 'constant') { + event.respondWith(new Response('constant')); + } else if (mode === 'echo') { + event.respondWith(new Response(event.request.body)); + } else if (mode === 'used') { + event.request.text().catch(() => {}); + } else if (mode === 'clone') { + event.request.clone().text().catch(() => {}); + } else if (mode === 'forward') { + event.respondWith(fetch(event.request)); + } else if (mode === 'redirect') { + event.respondWith(Response.redirect(new URL('/done', url), +url.searchParams.get('status'))); + } +};