diff --git a/moli-renderer-v8/src/context_bootstrap/websocket.rs b/moli-renderer-v8/src/context_bootstrap/websocket.rs index 3e908e6aa8a..e89f706af8f 100644 --- a/moli-renderer-v8/src/context_bootstrap/websocket.rs +++ b/moli-renderer-v8/src/context_bootstrap/websocket.rs @@ -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; diff --git a/moli-renderer-v8/src/context_bootstrap/websocket/methods.rs b/moli-renderer-v8/src/context_bootstrap/websocket/methods.rs index cc79e810414..0199726e498 100644 --- a/moli-renderer-v8/src/context_bootstrap/websocket/methods.rs +++ b/moli-renderer-v8/src/context_bootstrap/websocket/methods.rs @@ -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); } diff --git a/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs b/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs index e3106048352..1954f6bcc94 100644 --- a/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs +++ b/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs @@ -36,8 +36,6 @@ struct WebSocketStreamWritableSinkDeclaration<'scope> { closed: Option>, #[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>( diff --git a/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs b/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs index b06d7e41245..89694a2f32d 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs @@ -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> { 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) -> bool { + pub(crate) fn send_websocket_binary( + &self, + socket_id: u64, + bytes: Vec, + ) -> Option> { 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( diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/completion.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/completion.rs index 0334198d4a8..b6de6053dbc 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/completion.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/completion.rs @@ -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::::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; } diff --git a/moli-renderer-v8/src/script_vm/context_scope.rs b/moli-renderer-v8/src/script_vm/context_scope.rs index 38a15f35030..d41646b34b8 100644 --- a/moli-renderer-v8/src/script_vm/context_scope.rs +++ b/moli-renderer-v8/src/script_vm/context_scope.rs @@ -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( + &mut self, + op: impl FnOnce(&mut v8::PinScope<'_, '_>, *mut JsContextHost) -> Result, + ) -> Result { + self.with_default_context_scope(op) + } + #[cfg(test)] pub(crate) fn lazy_constructor_materialization_count_for_test( &mut self,