fix(websocket): settle stream writes in their terminal owner task

A peer can finish closing before the Page processes Close. Keep a write pending when native admission has ended so the owning Close/Error task settles it with stream.closed, rather than reporting its rejection before the caller can handle it.

Preserve missing-connection versus native send failure in the host result. Retired connections still reject immediately, and ordinary WebSocket send keeps its previous success check. Remove the obsolete send-rejected marker.

Use a native-close barrier to cover early and late rejection handlers and error identity, and cover retirement without a future Close task.
This commit is contained in:
ldm0
2026-10-27 05:20:01 +08:00
parent cfc1503e9d
commit 00e46a2fb4
5 changed files with 98 additions and 37 deletions
@@ -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,55 @@ async fn websocket_stream_close_remembers_write_rejected_before_close_dispatch()
__closeWriter.write('later').catch(error => __closeEvents.push(`later:${error === __interruptedWrite}`));
"checked"
"#)?;
while page_vm.run_exact_selected_page_task_for_test(
PageSelectedTaskTestSelector::DomManipulation(
PageDomManipulationTestFamily::PromiseRejection,
), &loader,
).await? {}
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;
}