mirror of
https://github.com/lexmount/moli.git
synced 2026-11-19 16:03:39 +00:00
fix(websocket): settle stream writes in their terminal owner task
Extracted from wpt-misc-fix (00e46a2fb4).
Validation: cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast (32 build jobs / test threads).
Summary [ 122.402s] 20926 tests run: 20926 passed (9 slow), 19 skipped
This commit is contained in:
@@ -41,7 +41,6 @@ const WEBSOCKET_STREAM_ERROR_SLOT: &str = "__moliWebSocketStreamError";
|
||||
const WEBSOCKET_STREAM_PROMISE_RESOLVER_SLOT: &str = "__moliWebSocketStreamPromiseResolver";
|
||||
const WEBSOCKET_STREAM_SINK_CLOSED_PROMISE_SLOT: &str = "__moliWebSocketStreamSinkClosedPromise";
|
||||
const WEBSOCKET_STREAM_PENDING_WRITES_SLOT: &str = "__moliWebSocketStreamPendingWrites";
|
||||
const WEBSOCKET_STREAM_SEND_REJECTED_SLOT: &str = "__moliWebSocketStreamSendRejected";
|
||||
|
||||
const CONNECTING: f64 = 0.0;
|
||||
const OPEN: f64 = 1.0;
|
||||
|
||||
@@ -61,7 +61,7 @@ pub(super) fn websocket_send_callback<'s>(
|
||||
WebSocketSendPayload::Text(text) => host.send_websocket_text(socket_id, text),
|
||||
WebSocketSendPayload::Binary(bytes) => host.send_websocket_binary(socket_id, bytes),
|
||||
};
|
||||
if !sent {
|
||||
if !matches!(sent, Some(Ok(()))) {
|
||||
add_buffered_amount(scope, args.this(), -amount);
|
||||
set_websocket_ready_state(scope, args.this(), CLOSED);
|
||||
}
|
||||
|
||||
@@ -36,8 +36,6 @@ struct WebSocketStreamWritableSinkDeclaration<'scope> {
|
||||
closed: Option<v8::Local<'scope, v8::Value>>,
|
||||
#[webapi(slot = WEBSOCKET_STREAM_PENDING_WRITES_SLOT, init = "array")]
|
||||
pending_writes: (),
|
||||
#[webapi(slot = WEBSOCKET_STREAM_SEND_REJECTED_SLOT, init = false)]
|
||||
send_rejected: (),
|
||||
#[webapi(method, callback = websocket_stream_sink_write_callback, length = 1)]
|
||||
write: (),
|
||||
#[webapi(method, callback = websocket_stream_sink_close_callback, length = 0)]
|
||||
@@ -353,28 +351,24 @@ fn websocket_stream_sink_write_callback<'s>(
|
||||
return;
|
||||
}
|
||||
};
|
||||
let mut sent = false;
|
||||
if let Some(socket_id) = websocket_id(scope, args.this())
|
||||
let admission = if let Some(socket_id) = websocket_id(scope, args.this())
|
||||
&& let Some(host_ptr) = context_host_ptr_from_global_bridge(scope)
|
||||
{
|
||||
let host = unsafe { &mut *host_ptr };
|
||||
sent = match payload {
|
||||
let host = unsafe { &*host_ptr };
|
||||
match payload {
|
||||
WebSocketSendPayload::Text(text) => host.send_websocket_text(socket_id, text),
|
||||
WebSocketSendPayload::Binary(bytes) => host.send_websocket_binary(socket_id, bytes),
|
||||
};
|
||||
}
|
||||
if sent {
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if admission.is_some() {
|
||||
// The transport may already have queued its terminal event when command
|
||||
// admission fails. Keep the write pending until that owner's Close or
|
||||
// Error task settles it together with the stream, instead of exposing
|
||||
// the transport's state before the realm has observed closure.
|
||||
enqueue_websocket_stream_pending_write(scope, args.this(), resolver);
|
||||
} else {
|
||||
// Native admission can end before the queued Close reaches this realm.
|
||||
// Remember that this write failed even after WritableStream has drained
|
||||
// its rejection reactions and no native pending-write record exists.
|
||||
set_private_value(
|
||||
scope,
|
||||
args.this(),
|
||||
WEBSOCKET_STREAM_SEND_REJECTED_SLOT,
|
||||
v8::Boolean::new(scope, true).into(),
|
||||
);
|
||||
let error = websocket_dom_exception_value(
|
||||
scope,
|
||||
"InvalidStateError",
|
||||
@@ -476,8 +470,6 @@ fn websocket_stream_has_interrupted_write<'s>(
|
||||
return false;
|
||||
};
|
||||
websocket_stream_pending_writes(scope, sink).is_some_and(|pending| pending.length() > 0)
|
||||
|| get_private_value(scope, sink, WEBSOCKET_STREAM_SEND_REJECTED_SLOT)
|
||||
.is_some_and(|value| value.boolean_value(scope))
|
||||
}
|
||||
|
||||
fn websocket_stream_pending_writes<'s>(
|
||||
|
||||
@@ -13,20 +13,26 @@ impl JsContextHost {
|
||||
self.page_websocket_sender().signal_readable_pull(socket_id);
|
||||
}
|
||||
|
||||
pub(crate) fn send_websocket_text(&self, socket_id: u64, text: String) -> bool {
|
||||
pub(crate) fn send_websocket_text(
|
||||
&self,
|
||||
socket_id: u64,
|
||||
text: String,
|
||||
) -> Option<Result<(), moli_websocket::SendError>> {
|
||||
self.websockets
|
||||
.get(&socket_id)
|
||||
.and_then(|state| state.connection.as_ref())
|
||||
.map(|connection| connection.send_text(text).is_ok())
|
||||
.unwrap_or(false)
|
||||
.map(|connection| connection.send_text(text))
|
||||
}
|
||||
|
||||
pub(crate) fn send_websocket_binary(&self, socket_id: u64, bytes: Vec<u8>) -> bool {
|
||||
pub(crate) fn send_websocket_binary(
|
||||
&self,
|
||||
socket_id: u64,
|
||||
bytes: Vec<u8>,
|
||||
) -> Option<Result<(), moli_websocket::SendError>> {
|
||||
self.websockets
|
||||
.get(&socket_id)
|
||||
.and_then(|state| state.connection.as_ref())
|
||||
.map(|connection| connection.send_binary(bytes).is_ok())
|
||||
.unwrap_or(false)
|
||||
.map(|connection| connection.send_binary(bytes))
|
||||
}
|
||||
|
||||
pub(crate) fn close_websocket(
|
||||
|
||||
@@ -462,8 +462,9 @@ async fn websocket_stream_send_completion_body_defers_write_reactions() {
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn websocket_stream_close_remembers_write_rejected_before_close_dispatch() {
|
||||
async fn websocket_stream_close_owns_rejected_native_admission() {
|
||||
run_page_vm_async_test(async move {
|
||||
for late_handler in [false, true] {
|
||||
let (url, server) = spawn_close_after_goodbye_websocket_server().await;
|
||||
let url = serde_json::to_string(&url).unwrap();
|
||||
let page_vm = test_page_vm();
|
||||
@@ -472,13 +473,24 @@ async fn websocket_stream_close_remembers_write_rejected_before_close_dispatch()
|
||||
let mut page_vm = page_vm;
|
||||
page_vm.vm_mut().eval(&format!(r#"
|
||||
globalThis.__closeEvents = [];
|
||||
globalThis.__lateWriteHandler = {late_handler};
|
||||
globalThis.__noteInterruptedWrite = error => {{
|
||||
globalThis.__interruptedWrite = error;
|
||||
__closeEvents.push(`write:${{error.name}}:${{error instanceof DOMException}}`);
|
||||
}};
|
||||
addEventListener('unhandledrejection', event => {{
|
||||
__closeEvents.push(`unhandled:${{event.reason?.name}}`);
|
||||
}});
|
||||
globalThis.__closeStream = new WebSocketStream({url});
|
||||
__closeStream.opened.then(opened => {{
|
||||
globalThis.__closeWriter = opened.writable.getWriter();
|
||||
}});
|
||||
__closeStream.closed.then(
|
||||
() => __closeEvents.push('closed-ok'),
|
||||
error => __closeEvents.push(`closed:${{error.constructor === WebSocketError}}:${{error.closeCode}}:${{error.reason}}`)
|
||||
error => {{
|
||||
__closeEvents.push(`closed:${{error.constructor === WebSocketError}}:${{error.closeCode}}:${{error.reason}}`);
|
||||
if (__lateWriteHandler) __interruptedWritePromise.catch(__noteInterruptedWrite);
|
||||
}}
|
||||
);
|
||||
"queued"
|
||||
"#))?;
|
||||
@@ -492,10 +504,8 @@ async fn websocket_stream_close_remembers_write_rejected_before_close_dispatch()
|
||||
.borrow().websocket_connection_for_test(socket_id).unwrap();
|
||||
page_vm.vm_mut().eval(r#"
|
||||
__closeWriter.write('Goodbye').then(() => __closeEvents.push('goodbye'));
|
||||
__closeWriter.write('queued').catch(error => {
|
||||
globalThis.__interruptedWrite = error;
|
||||
__closeEvents.push(`write:${error.name}:${error instanceof DOMException}`);
|
||||
});
|
||||
globalThis.__interruptedWritePromise = __closeWriter.write('queued');
|
||||
if (!__lateWriteHandler) __interruptedWritePromise.catch(__noteInterruptedWrite);
|
||||
"queued"
|
||||
"#)?;
|
||||
// Claim the first send completion to free ingress capacity, but let
|
||||
@@ -513,8 +523,16 @@ async fn websocket_stream_close_remembers_write_rejected_before_close_dispatch()
|
||||
}).await?;
|
||||
page_vm.run_claimed_selected_page_task_for_test(sent, &loader).await?;
|
||||
assert_eq!(page_vm.vm_mut().eval("__closeEvents.join('|')")?,
|
||||
"goodbye|write:InvalidStateError:true",
|
||||
"the queued write must fail before the Close task is dispatched");
|
||||
"goodbye",
|
||||
"native admission failure must wait for the owner's terminal task");
|
||||
page_vm.vm_mut().with_default_context_scope_for_test(|scope, _| {
|
||||
let global = scope.get_current_context().global(scope);
|
||||
let key = v8::String::new(scope, "__interruptedWritePromise").unwrap();
|
||||
let value = global.get(scope, key.into()).unwrap();
|
||||
let promise = v8::Local::<v8::Promise>::try_from(value).unwrap();
|
||||
assert_eq!(promise.state(), v8::PromiseState::Pending);
|
||||
Ok::<_, anyhow::Error>(())
|
||||
})?;
|
||||
let closed = wait_for_websocket_candidate(
|
||||
&mut page_vm, claim_ready_websocket_selected_task, "peer Close",
|
||||
).await?;
|
||||
@@ -524,9 +542,52 @@ async fn websocket_stream_close_remembers_write_rejected_before_close_dispatch()
|
||||
__closeWriter.write('later').catch(error => __closeEvents.push(`later:${error === __interruptedWrite}`));
|
||||
"checked"
|
||||
"#)?;
|
||||
// On main, promise rejection reporting runs at the task's existing
|
||||
// microtask checkpoint rather than through a separate Page task.
|
||||
assert_eq!(page_vm.vm_mut().eval("__closeEvents.join('|')")?,
|
||||
"goodbye|write:InvalidStateError:true|closed:true:1000:goodbye|writer:true|later:true");
|
||||
"goodbye|closed:true:1000:goodbye|write:InvalidStateError:true|writer:true|later:true");
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.expect("close after rejected queued write");
|
||||
}
|
||||
}).await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn websocket_stream_write_after_native_retirement_rejects_without_a_close_task() {
|
||||
run_page_vm_async_test(async move {
|
||||
let (url, server) = spawn_close_after_goodbye_websocket_server().await;
|
||||
let url = serde_json::to_string(&url).unwrap();
|
||||
let page_vm = test_page_vm();
|
||||
let local_executor = page_vm.local_executor.clone();
|
||||
local_executor.run(async move {
|
||||
let mut page_vm = page_vm;
|
||||
page_vm.vm_mut().eval(&format!(r#"
|
||||
globalThis.__retiredStream = new WebSocketStream({url});
|
||||
__retiredStream.opened.then(opened => {{
|
||||
globalThis.__retiredWriter = opened.writable.getWriter();
|
||||
}});
|
||||
"queued"
|
||||
"#))?;
|
||||
let opened = wait_for_websocket_candidate(
|
||||
&mut page_vm, claim_ready_websocket_selected_task, "retired stream open",
|
||||
).await?;
|
||||
let socket_id = opened.websocket_owner().unwrap().socket_id();
|
||||
let loader = page_vm.request_client.clone();
|
||||
page_vm.run_claimed_selected_page_task_for_test(opened, &loader).await?;
|
||||
assert!(page_vm.vm().context_host_weak_for_test().upgrade().unwrap()
|
||||
.borrow_mut().retire_websocket(socket_id));
|
||||
page_vm.vm_mut().eval(r#"
|
||||
globalThis.__retiredWrite = 'pending';
|
||||
__retiredWriter.write('orphaned').then(
|
||||
() => { __retiredWrite = 'fulfilled'; },
|
||||
error => { __retiredWrite = error.name; }
|
||||
);
|
||||
"queued"
|
||||
"#)?;
|
||||
assert_eq!(page_vm.vm_mut().eval("__retiredWrite")?, "InvalidStateError",
|
||||
"retirement cancels native delivery, so an orphaned writer must not wait for Close");
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.expect("write after native connection retirement");
|
||||
server.await.expect("retired stream server");
|
||||
}).await;
|
||||
}
|
||||
|
||||
@@ -102,6 +102,15 @@ impl ScriptVm {
|
||||
self.with_context_scope_by_ptr(context_ptr, op)
|
||||
}
|
||||
|
||||
/// Inspect the current realm without completing a task or running reactions.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn with_default_context_scope_for_test<T>(
|
||||
&mut self,
|
||||
op: impl FnOnce(&mut v8::PinScope<'_, '_>, *mut JsContextHost) -> Result<T>,
|
||||
) -> Result<T> {
|
||||
self.with_default_context_scope(op)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn lazy_constructor_materialization_count_for_test(
|
||||
&mut self,
|
||||
|
||||
Reference in New Issue
Block a user