Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

refactor(websocket): unify message send completion events

ldm011da0d4720df
diff --git a/moli-renderer-v8/src/context_bootstrap/websocket.rs b/moli-renderer-v8/src/context_bootstrap/websocket.rs
index 05f649d71..376829bfc 100644
--- a/moli-renderer-v8/src/context_bootstrap/websocket.rs
+++ b/moli-renderer-v8/src/context_bootstrap/websocket.rs
@@ -50,6 +50,7 @@ const WEBSOCKET_STREAM_PROMISE_RESOLVE_SLOT: &str = "__moliWebSocketStreamPromis
const WEBSOCKET_STREAM_PROMISE_REJECT_SLOT: &str = "__moliWebSocketStreamPromiseReject";
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/dispatch.rs b/moli-renderer-v8/src/context_bootstrap/websocket/dispatch.rs
index faa617bbd..268fcc3d9 100644
--- a/moli-renderer-v8/src/context_bootstrap/websocket/dispatch.rs
+++ b/moli-renderer-v8/src/context_bootstrap/websocket/dispatch.rs
@@ -73,11 +73,10 @@ pub(crate) fn dispatch_websocket_event<'s>(
)
.into()
}
- WebSocketEvent::BufferedAmountConsumed { amount, .. } => {
- add_buffered_amount(scope, socket, -(*amount as f64));
+ WebSocketEvent::SendCompleted { payload_length, .. } => {
+ add_buffered_amount(scope, socket, -(*payload_length as f64));
WebSocketDispatchResult::Noop
}
- WebSocketEvent::FrameSent { .. } => WebSocketDispatchResult::Noop,
WebSocketEvent::Error { message, .. } => {
set_websocket_ready_state(scope, socket, CLOSED);
if !message.is_empty() {
diff --git a/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs b/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs
index e177ccb73..84803d1b0 100644
--- a/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs
+++ b/moli-renderer-v8/src/context_bootstrap/websocket/stream.rs
@@ -44,6 +44,8 @@ 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)]
@@ -208,14 +210,13 @@ pub(super) fn dispatch_websocket_stream_event<'s>(
let _ = enqueue_chunk(scope, readable, value.into());
WebSocketDispatchResult::Dispatched
}
- WebSocketEvent::FrameSent { .. } => {
+ WebSocketEvent::SendCompleted { .. } => {
if resolve_next_websocket_stream_pending_write(scope, stream) {
WebSocketDispatchResult::Dispatched
} else {
WebSocketDispatchResult::Noop
}
}
- WebSocketEvent::BufferedAmountConsumed { .. } => WebSocketDispatchResult::Noop,
WebSocketEvent::Error { message, .. } => {
let error = new_websocket_error_object(scope, message, Some(1006), "");
set_websocket_value_slot(scope, stream, WEBSOCKET_STREAM_ERROR_SLOT, error);
@@ -252,7 +253,7 @@ pub(super) fn dispatch_websocket_stream_event<'s>(
..
} => {
if *was_clean {
- let mut had_pending_write = false;
+ let mut had_interrupted_write = false;
if let Some(readable) =
websocket_object_slot(scope, stream, WEBSOCKET_STREAM_READABLE_SLOT)
{
@@ -261,8 +262,7 @@ pub(super) fn dispatch_websocket_stream_event<'s>(
if let Some(writable) =
websocket_object_slot(scope, stream, WEBSOCKET_STREAM_WRITABLE_SLOT)
{
- had_pending_write =
- websocket_stream_pending_write_count_for_writable(scope, writable) > 0;
+ had_interrupted_write = websocket_stream_has_interrupted_write(scope, writable);
let error = websocket_dom_exception_value(
scope,
"InvalidStateError",
@@ -272,7 +272,7 @@ pub(super) fn dispatch_websocket_stream_event<'s>(
reject_all_websocket_stream_pending_writes(scope, writable, error);
error_writable_stream_with_value(scope, writable, error);
}
- if had_pending_write {
+ if had_interrupted_write {
// WPT treats remote close that interrupts a queued write as a
// WebSocketStream close error, while the interrupted write and
// later writes reject with InvalidStateError from the writable.
@@ -429,6 +429,15 @@ fn websocket_stream_sink_write_callback<'s>(
if sent {
enqueue_websocket_stream_pending_write(scope, args.this(), promise, resolve, reject);
} 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",
@@ -524,14 +533,16 @@ fn websocket_stream_pending_writes_for_stream<'s>(
Some((sink, pending))
}
-fn websocket_stream_pending_write_count_for_writable<'s>(
+fn websocket_stream_has_interrupted_write<'s>(
scope: &mut v8::PinScope<'s, '_>,
writable: v8::Local<'s, v8::Object>,
-) -> u32 {
- stream_slot_object(scope, writable, WRITABLE_STREAM_SINK_SLOT)
- .and_then(|sink| websocket_stream_pending_writes(scope, sink))
- .map(|pending| pending.length())
- .unwrap_or(0)
+) -> bool {
+ let Some(sink) = stream_slot_object(scope, writable, WRITABLE_STREAM_SINK_SLOT) else {
+ 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 7501c2336..d86a3135c 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
@@ -1,6 +1,14 @@
use super::super::JsContextHost;
impl JsContextHost {
+ #[cfg(test)]
+ pub(crate) fn websocket_connection_for_test(
+ &self,
+ socket_id: u64,
+ ) -> Option<moli_websocket::ConnectionHandle> {
+ self.websockets.get(&socket_id)?.connection.clone()
+ }
+
pub(crate) fn signal_websocket_stream_pull(&self, socket_id: u64) {
self.page_websocket_sender().signal_readable_pull(socket_id);
}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs
index 409b9846a..ce9e4d548 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs
@@ -20,6 +20,7 @@ async fn websocket_text_echo_delivers_browser_style_async_events() {
globalThis.__wsEvents.push(`open:${{socket.readyState}}:${{socket.protocol}}`);
socket.send('hello');
globalThis.__wsEvents.push(`bufferedAfterSend:${{socket.bufferedAmount}}`);
+ Promise.resolve().then(() => globalThis.__wsEvents.push(`bufferedInMicrotask:${{socket.bufferedAmount}}`));
}});
socket.addEventListener('message', event => {{
globalThis.__wsEvents.push(`message:${{event.data}}:${{socket.bufferedAmount}}`);
@@ -60,7 +61,7 @@ async fn websocket_text_echo_delivers_browser_style_async_events() {
server.await.expect("websocket echo server should finish");
assert_eq!(
events,
- r#"["constructed:0","open:1:","bufferedAfterSend:5","message:hello:0","afterCloseCall:2","close:3:1000:done:true"]"#
+ r#"["constructed:0","open:1:","bufferedAfterSend:5","bufferedInMicrotask:5","message:hello:0","afterCloseCall:2","close:3:1000:done:true"]"#
);
})
.await;
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 d00641efe..0334198d4 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
@@ -205,9 +205,10 @@ globalThis.__webSocketInternalStateSocket = new WebSocket({url_literal});
.vm()
.websocket_sender_for_test()
.event_sender()
- .send(moli_websocket::Event::BufferedAmountConsumed {
+ .send(moli_websocket::Event::SendCompleted {
socket_id,
- amount: 0,
+ opcode: moli_websocket::FrameOpcode::Text,
+ payload_length: 0,
})
.await,
"internal WebSocket transition should enter the typed source"
@@ -410,3 +411,122 @@ async fn websocket_selected_dispatcher_owns_checkpoint_and_runtime_follow_up() {
})
.await;
}
+
+#[tokio::test(flavor = "current_thread")]
+async fn websocket_stream_send_completion_body_defers_write_reactions() {
+ run_page_vm_async_test(async move {
+ // This server discards application messages, so the empty write must
+ // complete through its own receipt without an incoming echo.
+ 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.__completionEvents = [];
+ globalThis.__completionStream = new WebSocketStream({url});
+ __completionStream.opened.then(opened => {{
+ globalThis.__completionWriter = opened.writable.getWriter();
+ }});
+ "queued"
+ "#))?;
+ let opened = wait_for_websocket_candidate(
+ &mut page_vm, claim_ready_websocket_selected_task, "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?;
+ page_vm.vm_mut().eval(r#"
+ __completionWriter.write("").then(() => __completionEvents.push("resolved"));
+ __completionEvents.push("after-write");
+ "queued"
+ "#)?;
+ let task = wait_for_websocket_candidate(
+ &mut page_vm, take_ready_websocket_body_task_for_test, "empty write completion",
+ ).await?;
+ assert!(matches!(task.event(), moli_websocket::Event::SendCompleted {
+ socket_id: actual, payload_length: 0, ..
+ } if *actual == socket_id));
+ let outcome = page_vm.apply_selected_page_websocket_turn(task)?;
+ assert_eq!(outcome.action.target_effect,
+ crate::page_task_queue::PageWebSocketTargetEffect::CallbackVisibleWorkAppliedToCurrentDocument);
+ assert_eq!(page_vm.vm_mut().eval("__completionEvents.join('|')")?, "after-write",
+ "settling a write must leave reactions for selected-task completion");
+ // This boundary witness deliberately omits task completion. Dropping
+ // the Page then retires its connection and the passive test server.
+ Ok::<_, anyhow::Error>(())
+ }).await.expect("stream completion body witness");
+ server.await.expect("passive completion server");
+ }).await;
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn websocket_stream_close_remembers_write_rejected_before_close_dispatch() {
+ 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.__closeEvents = [];
+ 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}}`)
+ );
+ "queued"
+ "#))?;
+ let opened = wait_for_websocket_candidate(
+ &mut page_vm, claim_ready_websocket_selected_task, "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?;
+ let connection = page_vm.vm().context_host_weak_for_test().upgrade().unwrap()
+ .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}`);
+ });
+ "queued"
+ "#)?;
+ // Claim the first send completion to free ingress capacity, but let
+ // the peer finish closing before executing its Page task. The next
+ // WritableStream write must then fail native admission, with Close
+ // still waiting for its own selected Page task.
+ let sent = wait_for_websocket_candidate(
+ &mut page_vm, claim_ready_websocket_selected_task, "Goodbye completion",
+ ).await?;
+ tokio::time::timeout(Duration::from_secs(2), server).await??;
+ tokio::time::timeout(Duration::from_secs(2), async {
+ while !connection.is_closed() {
+ tokio::task::yield_now().await;
+ }
+ }).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");
+ let closed = wait_for_websocket_candidate(
+ &mut page_vm, claim_ready_websocket_selected_task, "peer Close",
+ ).await?;
+ page_vm.run_claimed_selected_page_task_for_test(closed, &loader).await?;
+ page_vm.vm_mut().eval(r#"
+ __closeWriter.closed.catch(error => __closeEvents.push(`writer:${error === __interruptedWrite}`));
+ __closeWriter.write('later').catch(error => __closeEvents.push(`later:${error === __interruptedWrite}`));
+ "checked"
+ "#)?;
+ assert_eq!(page_vm.vm_mut().eval("__closeEvents.join('|')")?,
+ "goodbye|write:InvalidStateError:true|closed:true:1000:goodbye|writer:true|later:true");
+ Ok::<_, anyhow::Error>(())
+ }).await.expect("close after rejected queued write");
+ }).await;
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/wpt_target.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/wpt_target.rs
index 2a72397e2..585435cc3 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/wpt_target.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/wpt_target.rs
@@ -768,7 +768,7 @@ async fn websocket_wpt_target_buffered_amount_binary_payload_lengths() {
seen++;
// See the unicode bufferedAmount test: the stable contract here is
// immediate byte accounting plus eventual drain, not exact
- // BufferedAmountConsumed/message event ordering.
+ // send-completion/message event ordering.
globalThis.__wsEvents.push(`message:${{seen}}:${{event.data.byteLength}}`);
if (seen === 3) socket.close(1000, 'buffered-binary');
}});
diff --git a/moli-renderer-v8/src/script_vm/websocket_event_body.rs b/moli-renderer-v8/src/script_vm/websocket_event_body.rs
index 7b7959dc5..0063c1dac 100644
--- a/moli-renderer-v8/src/script_vm/websocket_event_body.rs
+++ b/moli-renderer-v8/src/script_vm/websocket_event_body.rs
@@ -44,7 +44,7 @@ impl ScriptVm {
let previous_owner_context = dispatch_scope.enter(scope);
match event {
- moli_websocket::Event::FrameSent {
+ moli_websocket::Event::SendCompleted {
opcode,
payload_length,
..
diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs
index 16c3dd19e..5fd52e79a 100644
--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs
+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs
@@ -1411,8 +1411,7 @@ pub(in crate::worker) fn dispatch_worker_websocket_event(
| WebSocketEvent::Open { socket_id, .. }
| WebSocketEvent::TextMessage { socket_id, .. }
| WebSocketEvent::BinaryMessage { socket_id, .. }
- | WebSocketEvent::FrameSent { socket_id, .. }
- | WebSocketEvent::BufferedAmountConsumed { socket_id, .. }
+ | WebSocketEvent::SendCompleted { socket_id, .. }
| WebSocketEvent::Error { socket_id, .. }
| WebSocketEvent::Closing { socket_id }
| WebSocketEvent::Close { socket_id, .. } => *socket_id,
@@ -1503,7 +1502,7 @@ pub(in crate::worker) fn dispatch_worker_websocket_event(
.with_websocket_socket_id(socket_id),
));
}
- WebSocketEvent::FrameSent {
+ WebSocketEvent::SendCompleted {
opcode,
payload_length,
..
@@ -1572,8 +1571,7 @@ pub(in crate::worker) fn dispatch_worker_websocket_event(
}
WebSocketEvent::HandshakeResponse { .. }
| WebSocketEvent::TextMessage { .. }
- | WebSocketEvent::BinaryMessage { .. }
- | WebSocketEvent::BufferedAmountConsumed { .. } => {}
+ | WebSocketEvent::BinaryMessage { .. } => {}
}
for message in parent_messages {
let _ = parent_tx.send(message);
diff --git a/moli-websocket/src/native_tests.rs b/moli-websocket/src/native_tests.rs
index 9782218a0..29e84a88b 100644
--- a/moli-websocket/src/native_tests.rs
+++ b/moli-websocket/src/native_tests.rs
@@ -28,8 +28,8 @@ async fn native_send_accounting_does_not_require_a_server_echo() {
let handle = spawn_connection(70, url, Vec::new(), test_websocket_context(), tx);
recv_open_event(&mut rx).await;
handle.send_text("without echo".to_owned()).unwrap();
- assert_frame_sent(&mut rx, 70, FrameOpcode::Text, 12).await;
- assert_buffered_amount_consumed(&mut rx, 70, 12).await;
+ assert_send_completed(&mut rx, 70, FrameOpcode::Text, 12).await;
+
timeout(Duration::from_secs(3), received_rx)
.await
.unwrap()
diff --git a/moli-websocket/src/session.rs b/moli-websocket/src/session.rs
index 80946fae9..87de929c9 100644
--- a/moli-websocket/src/session.rs
+++ b/moli-websocket/src/session.rs
@@ -269,7 +269,7 @@ impl Session {
&& self
.outbox
.iter()
- .filter(|event| matches!(event, Event::FrameSent { .. }))
+ .filter(|event| matches!(event, Event::SendCompleted { .. }))
.count()
>= MAX_QUEUED_MESSAGES
{
@@ -378,15 +378,11 @@ impl Session {
.outgoing
.pop_front()
.expect("completed message is resident");
- self.outbox.push_back(Event::FrameSent {
+ self.outbox.push_back(Event::SendCompleted {
socket_id: self.socket_id,
opcode: message.opcode,
payload_length: message.data.len(),
});
- self.outbox.push_back(Event::BufferedAmountConsumed {
- socket_id: self.socket_id,
- amount: message.data.len(),
- });
// The admission reservation drops only at native completion.
}
}
diff --git a/moli-websocket/src/session/tests.rs b/moli-websocket/src/session/tests.rs
index 97b8a81d8..ea3ed534d 100644
--- a/moli-websocket/src/session/tests.rs
+++ b/moli-websocket/src/session/tests.rs
@@ -54,8 +54,8 @@ async fn native_close_waits_for_queued_data_before_starting_timeout() {
"queued data was interrupted: {premature:?}"
);
resume_tx.send(()).unwrap();
- assert_frame_sent(&mut rx, 80, FrameOpcode::Binary, MESSAGE_BYTES).await;
- assert_buffered_amount_consumed(&mut rx, 80, MESSAGE_BYTES).await;
+ assert_send_completed(&mut rx, 80, FrameOpcode::Binary, MESSAGE_BYTES).await;
+
assert_close(&mut rx, 80, 1000, "", true).await;
timeout(Duration::from_secs(3), server)
.await
@@ -165,8 +165,7 @@ async fn native_fragmented_sends_complete_while_incoming_sink_is_blocked() {
.unwrap();
assert_text_message(&mut rx, 82, "blocked").await;
for _ in 0..2 {
- assert_frame_sent(&mut rx, 82, FrameOpcode::Binary, MESSAGE_BYTES).await;
- assert_buffered_amount_consumed(&mut rx, 82, MESSAGE_BYTES).await;
+ assert_send_completed(&mut rx, 82, FrameOpcode::Binary, MESSAGE_BYTES).await;
}
handle.close(Some(1000), String::new()).unwrap();
assert_closing(&mut rx, 82).await;
@@ -209,7 +208,7 @@ async fn completed_send_notifications_bound_further_message_scheduling() {
);
assert!(matches!(
session.outbox.pop_front(),
- Some(Event::FrameSent { .. })
+ Some(Event::SendCompleted { .. })
));
for _ in 0..2 {
let (frame, flight) = session
@@ -224,7 +223,7 @@ async fn completed_send_notifications_bound_further_message_scheduling() {
session
.outbox
.iter()
- .filter(|event| matches!(event, Event::FrameSent { .. }))
+ .filter(|event| matches!(event, Event::SendCompleted { .. }))
.count(),
MAX_QUEUED_MESSAGES
);
diff --git a/moli-websocket/src/synthetic.rs b/moli-websocket/src/synthetic.rs
index a8ffd944f..1d6df49d7 100644
--- a/moli-websocket/src/synthetic.rs
+++ b/moli-websocket/src/synthetic.rs
@@ -50,35 +50,25 @@ pub(crate) async fn run_synthetic_websocket_connection(
let amount = text.len();
send_event(
&event_tx,
- Event::FrameSent {
+ Event::SendCompleted {
socket_id,
opcode: FrameOpcode::Text,
payload_length: amount,
},
)
.await?;
- send_event(
- &event_tx,
- Event::BufferedAmountConsumed { socket_id, amount },
- )
- .await?;
}
Command::SendBinary(bytes) => {
let amount = bytes.len();
send_event(
&event_tx,
- Event::FrameSent {
+ Event::SendCompleted {
socket_id,
opcode: FrameOpcode::Binary,
payload_length: amount,
},
)
.await?;
- send_event(
- &event_tx,
- Event::BufferedAmountConsumed { socket_id, amount },
- )
- .await?;
}
Command::ReceiveText(data) => {
send_event(&event_tx, Event::TextMessage { socket_id, data }).await?;
diff --git a/moli-websocket/src/test_support.rs b/moli-websocket/src/test_support.rs
index c6ded99c5..a5caacb33 100644
--- a/moli-websocket/src/test_support.rs
+++ b/moli-websocket/src/test_support.rs
@@ -118,8 +118,7 @@ pub async fn recv_open_event(event_rx: &mut mpsc::Receiver<Event>) -> OpenEvent
}
Event::TextMessage { .. }
| Event::BinaryMessage { .. }
- | Event::FrameSent { .. }
- | Event::BufferedAmountConsumed { .. }
+ | Event::SendCompleted { .. }
| Event::Closing { .. } => {}
}
}
@@ -140,8 +139,7 @@ pub async fn recv_handshake_failure_events(event_rx: &mut mpsc::Receiver<Event>)
}
Event::TextMessage { .. }
| Event::BinaryMessage { .. }
- | Event::FrameSent { .. }
- | Event::BufferedAmountConsumed { .. }
+ | Event::SendCompleted { .. }
| Event::Closing { .. } => {}
}
};
@@ -170,8 +168,7 @@ pub async fn recv_handshake_failure_events(event_rx: &mut mpsc::Receiver<Event>)
}
Event::TextMessage { .. }
| Event::BinaryMessage { .. }
- | Event::FrameSent { .. }
- | Event::BufferedAmountConsumed { .. }
+ | Event::SendCompleted { .. }
| Event::Closing { .. } => {}
}
}
@@ -184,14 +181,14 @@ async fn recv_next_event(event_rx: &mut mpsc::Receiver<Event>) -> Event {
.expect("websocket event channel should stay open")
}
-pub async fn assert_frame_sent(
+pub async fn assert_send_completed(
event_rx: &mut mpsc::Receiver<Event>,
expected_socket_id: u64,
expected_opcode: FrameOpcode,
expected_payload_length: usize,
) {
match recv_next_event(event_rx).await {
- Event::FrameSent {
+ Event::SendCompleted {
socket_id,
opcode,
payload_length,
@@ -200,21 +197,7 @@ pub async fn assert_frame_sent(
assert_eq!(opcode, expected_opcode);
assert_eq!(payload_length, expected_payload_length);
}
- event => panic!("expected frame-sent event, got {event:?}"),
- }
-}
-
-pub async fn assert_buffered_amount_consumed(
- event_rx: &mut mpsc::Receiver<Event>,
- expected_socket_id: u64,
- expected_amount: usize,
-) {
- match recv_next_event(event_rx).await {
- Event::BufferedAmountConsumed { socket_id, amount } => {
- assert_eq!(socket_id, expected_socket_id);
- assert_eq!(amount, expected_amount);
- }
- event => panic!("expected buffered amount event, got {event:?}"),
+ event => panic!("expected send completion, got {event:?}"),
}
}
diff --git a/moli-websocket/src/tests.rs b/moli-websocket/src/tests.rs
index c52da93e1..63533f55a 100644
--- a/moli-websocket/src/tests.rs
+++ b/moli-websocket/src/tests.rs
@@ -590,13 +590,13 @@ async fn websocket_synthetic_delivery_stops_after_first_rejected_event() {
),
)
.await
- .expect("synthetic producer must stop when FrameSent is rejected")
+ .expect("synthetic producer must stop when SendCompleted is rejected")
.expect_err("synthetic event sink is closed");
assert!(command_tx.is_closed());
assert!(matches!(observed_rx.try_recv(), Ok(Event::Open { .. })));
assert!(matches!(
observed_rx.try_recv(),
- Ok(Event::FrameSent { .. })
+ Ok(Event::SendCompleted { .. })
));
assert!(
observed_rx.try_recv().is_err(),
@@ -718,7 +718,7 @@ async fn websocket_synthetic_connection_opens_accounts_send_and_closes_cleanly()
.expect("synthetic frame sent should arrive")
.expect("synthetic websocket event channel should stay open");
match event {
- Event::FrameSent {
+ Event::SendCompleted {
socket_id,
opcode,
payload_length,
@@ -729,17 +729,6 @@ async fn websocket_synthetic_connection_opens_accounts_send_and_closes_cleanly()
}
event => panic!("expected synthetic websocket frame sent, got {event:?}"),
}
- let event = timeout(Duration::from_secs(1), event_rx.recv())
- .await
- .expect("synthetic buffered amount consumption should arrive")
- .expect("synthetic websocket event channel should stay open");
- match event {
- Event::BufferedAmountConsumed { socket_id, amount } => {
- assert_eq!(socket_id, 92);
- assert_eq!(amount, 5);
- }
- event => panic!("expected synthetic buffered amount event, got {event:?}"),
- }
command_tx
.close(Some(1000), "done".to_owned())
@@ -1228,15 +1217,15 @@ async fn websocket_transport_sends_text_binary_and_reports_buffered_amount_consu
command_tx
.send_text("hello".to_owned())
.expect("send text command");
- assert_frame_sent(&mut event_rx, 4, FrameOpcode::Text, 5).await;
- assert_buffered_amount_consumed(&mut event_rx, 4, 5).await;
+ assert_send_completed(&mut event_rx, 4, FrameOpcode::Text, 5).await;
+
assert_text_message(&mut event_rx, 4, "hello").await;
command_tx
.send_binary(vec![1, 2, 3, 4])
.expect("send binary command");
- assert_frame_sent(&mut event_rx, 4, FrameOpcode::Binary, 4).await;
- assert_buffered_amount_consumed(&mut event_rx, 4, 4).await;
+ assert_send_completed(&mut event_rx, 4, FrameOpcode::Binary, 4).await;
+
assert_binary_message(&mut event_rx, 4, &[1, 2, 3, 4]).await;
command_tx
@@ -1281,8 +1270,7 @@ async fn websocket_transport_reads_while_sending_many_large_messages() {
Event::HandshakeResponse { .. }
| Event::Open { .. }
| Event::BinaryMessage { .. }
- | Event::FrameSent { .. }
- | Event::BufferedAmountConsumed { .. }
+ | Event::SendCompleted { .. }
| Event::Closing { .. } => {}
}
}
diff --git a/moli-websocket/src/types.rs b/moli-websocket/src/types.rs
index 7ba0fd250..584ac80b6 100644
--- a/moli-websocket/src/types.rs
+++ b/moli-websocket/src/types.rs
@@ -42,15 +42,13 @@ pub enum Event {
socket_id: u64,
data: Vec<u8>,
},
- FrameSent {
+ /// One complete outgoing message, including an empty message.
+ /// Drives browser byte accounting, stream writes and CDP message records.
+ SendCompleted {
socket_id: u64,
opcode: FrameOpcode,
payload_length: usize,
},
- BufferedAmountConsumed {
- socket_id: u64,
- amount: usize,
- },
Error {
socket_id: u64,
message: String,
@@ -73,8 +71,7 @@ impl Event {
| Self::Open { socket_id, .. }
| Self::TextMessage { socket_id, .. }
| Self::BinaryMessage { socket_id, .. }
- | Self::FrameSent { socket_id, .. }
- | Self::BufferedAmountConsumed { socket_id, .. }
+ | Self::SendCompleted { socket_id, .. }
| Self::Error { socket_id, .. }
| Self::Closing { socket_id }
| Self::Close { socket_id, .. } => *socket_id,