mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 16:02:34 +00:00
feat(fetch): carry streams through controlled service workers
Preserve byte streams across FetchEvent dispatch, clone and network fallback. Keep upload and abort lifetimes independent of synthetic responses, and stream Service Worker replies to controlled Worker clients. Validation: fmt, full workspace clippy and nextest pass (25094 tests, 19 skipped). Ordinary debug and release each improve the selected original WPT cohort from 107/117 to 112/117, with every prior passing case retained.
This commit is contained in:
@@ -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)]
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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<v8::Local<'s, v8::Object>> {
|
||||
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::<v8::Uint8Array>::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 => {
|
||||
|
||||
@@ -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<ReadableStreamClonePayload>,
|
||||
sender: Option<moli_fetch::UploadBodySender>,
|
||||
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<ReadableStreamClonePayload> {
|
||||
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::<v8::Value>::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::<v8::Function>::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<v8::Local<'s, v8::Object>> {
|
||||
let (binding, _) = crate::common_runtime::CommonRuntimeBinding::from_scope(scope)?;
|
||||
binding.callback_execution_context(scope)?;
|
||||
let state = v8::Local::<v8::Object>::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::<v8::Uint8Array>::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<v8::Local<'s, v8::Value>>,
|
||||
) {
|
||||
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::<v8::Object>::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::<v8::Function>::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());
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
{
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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<v8::PromiseResolver>,
|
||||
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,
|
||||
|
||||
@@ -1877,6 +1877,7 @@ impl JsContextHost {
|
||||
metadata: ServiceWorkerFetchRequestMetadata,
|
||||
) -> ServiceWorkerFetchRequest {
|
||||
ServiceWorkerFetchRequest {
|
||||
body_stream: None,
|
||||
client_id,
|
||||
resulting_client_id: None,
|
||||
url,
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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<Option<u64>> {
|
||||
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,
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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<Self, v8::Local<'s, v8::Value>> {
|
||||
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<Upload>).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
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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)),
|
||||
|
||||
@@ -7,6 +7,8 @@ use tokio_rustls::rustls::{
|
||||
pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer},
|
||||
};
|
||||
|
||||
mod controlled;
|
||||
|
||||
#[derive(Default)]
|
||||
struct Wire {
|
||||
bytes: Vec<u8>,
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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),
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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<AsyncSubresourceFetchBodyActivity> {
|
||||
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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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<bytes::Bytes>,
|
||||
pub(crate) body_stream: Option<crate::context_bootstrap::ReadableStreamClonePayload>,
|
||||
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<ServiceWorkerDirectFetchStream>),
|
||||
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<crate::types::AsyncSubresourceFetchResponseFilter>,
|
||||
pub(crate) events: tokio::sync::mpsc::UnboundedReceiver<ServiceWorkerDirectFetchStreamEvent>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum ServiceWorkerDirectFetchStreamEvent {
|
||||
Chunk(Vec<u8>),
|
||||
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<crate::context_bootstrap::RequestBodyOwner>,
|
||||
pub(crate) internal_id: u64,
|
||||
pub(crate) request: ServiceWorkerFetchRequest,
|
||||
pub(crate) redirect_check: Option<moli_fetch::RequestRedirectCheck>,
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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,
|
||||
|
||||
+3
@@ -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();
|
||||
|
||||
@@ -181,6 +181,7 @@ pub(super) struct ServiceWorkerRuntimeState {
|
||||
pub(super) versions: HashMap<ServiceWorkerVersionId, ServiceWorkerVersion>,
|
||||
pub(super) pending_ready_jobs: Vec<ServiceWorkerReadyJob>,
|
||||
pub(super) pending_fetch_jobs: HashMap<ServiceWorkerEventId, ServiceWorkerFetchJob>,
|
||||
pub(super) pending_fetch_body_uploads: HashMap<ServiceWorkerEventId, ServiceWorkerRunOwner>,
|
||||
pub(super) lifecycle_watchers: Vec<ServiceWorkerLifecycleWatcher>,
|
||||
pub(super) live_clients: HashMap<ServiceWorkerClientId, ServiceWorkerClient>,
|
||||
pub(super) notification_records: Vec<ServiceWorkerNotificationRecord>,
|
||||
@@ -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<super::events::ServiceWorkerDirectFetchStreamEvent>,
|
||||
>,
|
||||
pub(super) request_body_owner: Option<crate::context_bootstrap::RequestBodyOwner>,
|
||||
pub(super) body_stream: Option<crate::context_bootstrap::ReadableStreamClonePayload>,
|
||||
pub(super) request: moli_fetch::Request,
|
||||
pub(super) internal_id: u64,
|
||||
pub(super) owner: Option<ServiceWorkerRunOwner>,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -103,6 +103,7 @@ pub(in crate::worker) struct PendingServiceWorkerPeriodicSyncEvent {
|
||||
}
|
||||
|
||||
pub(in crate::worker) struct PendingServiceWorkerFetchEvent {
|
||||
pub(in crate::worker) request_for_body: Option<v8::Global<v8::Object>>,
|
||||
pub(in crate::worker) completion: ServiceWorkerFetchCompletion,
|
||||
pub(in crate::worker) handled_resolver: Option<v8::Global<v8::PromiseResolver>>,
|
||||
pub(in crate::worker) request_signal_id: Option<u32>,
|
||||
@@ -125,6 +126,7 @@ impl PendingServiceWorkerFetchEvent {
|
||||
request_destination: ServiceWorkerRequestDestination,
|
||||
) -> Self {
|
||||
Self {
|
||||
request_for_body: None,
|
||||
completion: ServiceWorkerFetchCompletion {
|
||||
result: ServiceWorkerFetchResult::Fallback,
|
||||
..completion
|
||||
|
||||
@@ -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<bytes::Bytes>,
|
||||
body_stream: Option<crate::context_bootstrap::ReadableStreamClonePayload>,
|
||||
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(),
|
||||
|
||||
@@ -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<crate::types::AsyncSubresourceFetchResponseFilter>,
|
||||
pub(super) skip_fetch_security_validation: bool,
|
||||
pub(super) fetch_id: u32,
|
||||
pub(super) body_source_id: NetworkBodySourceId,
|
||||
pub(super) head: ResponseHead,
|
||||
|
||||
@@ -263,6 +263,8 @@ pub(crate) struct WorkerGlobalState {
|
||||
/// and minimal `waitUntil()` promises to finish.
|
||||
pub(in crate::worker) pending_service_worker_fetch_events:
|
||||
HashMap<ServiceWorkerEventId, PendingServiceWorkerFetchEvent>,
|
||||
pub(in crate::worker) pending_service_worker_request_uploads:
|
||||
HashMap<ServiceWorkerEventId, crate::network_host::RequestUpload>,
|
||||
/// Navigation preload promises and response bodies stay alive until preload complete/error.
|
||||
pub(in crate::worker) pending_service_worker_navigation_preloads:
|
||||
HashMap<ServiceWorkerEventId, PendingServiceWorkerNavigationPreload>,
|
||||
|
||||
@@ -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<RefCell<super::WorkerGlobalState>>,
|
||||
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<RefCell<super::WorkerGlobalState>>,
|
||||
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);
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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')));
|
||||
}
|
||||
};
|
||||
Reference in New Issue
Block a user