Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(websocket): separate handshake validation and event delivery
ldm0c1c936b338d7
diff --git a/moli-websocket/src/connection.rs b/moli-websocket/src/connection.rsindex a72a30df3..c828ef0d9 100644--- a/moli-websocket/src/connection.rs+++ b/moli-websocket/src/connection.rs@@ -6,7 +6,7 @@ use tokio_tungstenite::tungstenite::protocol::{CloseFrame, Message};use crate::{Command, ConnectOptions, Event, FrameOpcode,- events::{EventSender, send_error_and_close, send_event},+ events::{EventResult, EventSender, send_error_and_close, send_event},handle::AbortOnDrop,headers::header_map_entries,limits::{acquire_pending_websocket_handshake_slot, acquire_websocket_connection_slot},@@ -21,22 +21,22 @@ pub(crate) async fn run_websocket_connection(context: ConnectOptions,mut command_rx: mpsc::UnboundedReceiver<Command>,event_tx: EventSender,-) {+) -> EventResult {let Some(_connection_slot) = acquire_websocket_connection_slot() else {send_error_and_close(&event_tx,socket_id,"WebSocket connection failed: insufficient resources".to_owned(),)- .await;- return;+ .await?;+ return Ok(());};let request = match build_websocket_request(&url, &protocols, &context) {Ok(request) => request,Err(error) => {- send_error_and_close(&event_tx, socket_id, error).await;- return;+ send_error_and_close(&event_tx, socket_id, error).await?;+ return Ok(());}};@@ -47,8 +47,8 @@ pub(crate) async fn run_websocket_connection(socket_id,"WebSocket connection failed: too many pending handshakes".to_owned(),)- .await;- return;+ .await?;+ return Ok(());};let handshake = open_websocket_stream(request, &context);tokio::pin!(handshake);@@ -64,8 +64,8 @@ pub(crate) async fn run_websocket_connection(socket_id,"WebSocket connection closed before opening".to_owned(),)- .await;- return;+ .await?;+ return Ok(());}Some(Command::SendText(_))| Some(Command::SendBinary(_))@@ -77,7 +77,7 @@ pub(crate) async fn run_websocket_connection(// queueing frames before the opening handshake has succeeded.}Some(Command::ContinueOpen { .. }) | Some(Command::FailOpen(_)) => {}- None => return,+ None => return Ok(()),}}connected = &mut handshake => {@@ -93,8 +93,8 @@ pub(crate) async fn run_websocket_connection(socket_id,format!("WebSocket connection failed: {error}"),)- .await;- return;+ .await?;+ return Ok(());}}}@@ -104,7 +104,7 @@ pub(crate) async fn run_websocket_connection(let mut response_status = response.status().as_u16();let mut response_headers = header_map_entries(response.headers());if context.pause_after_handshake {- let _ = send_event(+ send_event(&event_tx,Event::HandshakeResponse {socket_id,@@ -119,7 +119,7 @@ pub(crate) async fn run_websocket_connection(response_headers: response_headers.clone(),},)- .await;+ .await?;loop {match command_rx.recv().await {Some(Command::ContinueOpen {@@ -135,8 +135,8 @@ pub(crate) async fn run_websocket_connection(break;}Some(Command::FailOpen(message)) => {- send_error_and_close(&event_tx, socket_id, message).await;- return;+ send_error_and_close(&event_tx, socket_id, message).await?;+ return Ok(());}Some(Command::Close { .. }) => {send_error_and_close(@@ -144,8 +144,8 @@ pub(crate) async fn run_websocket_connection(socket_id,"WebSocket connection closed before opening".to_owned(),)- .await;- return;+ .await?;+ return Ok(());}Some(Command::SendText(_))| Some(Command::SendBinary(_))@@ -155,7 +155,7 @@ pub(crate) async fn run_websocket_connection(// Browser-visible `send()` throws until the open event, so crate users// cannot enqueue application data while a response-stage pause is active.}- None => return,+ None => return Ok(()),}}}@@ -165,7 +165,7 @@ pub(crate) async fn run_websocket_connection(let extensions = response_header(&response_headers, "sec-websocket-extensions").unwrap_or_default().to_owned();- let _ = send_event(+ send_event(&event_tx,Event::Open {socket_id,@@ -176,9 +176,9 @@ pub(crate) async fn run_websocket_connection(response_headers,},)- .await;+ .await?;- run_open_websocket_connection(socket_id, stream, command_rx, event_tx).await;+ run_open_websocket_connection(socket_id, stream, command_rx, event_tx).await}async fn run_open_websocket_connection(@@ -188,7 +188,7 @@ async fn run_open_websocket_connection(>,command_rx: mpsc::UnboundedReceiver<Command>,event_tx: EventSender,-) {+) -> EventResult {let (write, mut read) = stream.split();let (writer_event_tx, mut writer_event_rx) = mpsc::unbounded_channel();let (writer_control_tx, writer_control_rx) = mpsc::unbounded_channel();@@ -215,12 +215,12 @@ async fn run_open_websocket_connection(socket_id,&mut pending_buffered_amount,)- .await;- let _ = send_event(&event_tx, Event::TextMessage {+ .await?;+ send_event(&event_tx, Event::TextMessage {socket_id,data: text.to_string(),})- .await;+ .await?;}Some(Ok(Message::Binary(data))) => {send_next_buffered_amount(@@ -228,12 +228,12 @@ async fn run_open_websocket_connection(socket_id,&mut pending_buffered_amount,)- .await;- let _ = send_event(&event_tx, Event::BinaryMessage {+ .await?;+ send_event(&event_tx, Event::BinaryMessage {socket_id,data: data.to_vec(),})- .await;+ .await?;}Some(Ok(Message::Close(frame))) => {flush_pending_buffered_amount(@@ -241,11 +241,11 @@ async fn run_open_websocket_connection(socket_id,&mut pending_buffered_amount,)- .await;+ .await?;let (code, reason) = frame.map(|frame| (u16::from(frame.code), frame.reason.to_string())).unwrap_or((1005, String::new()));- let _ = send_event(+ send_event(&event_tx,Event::Close {socket_id,@@ -254,7 +254,7 @@ async fn run_open_websocket_connection(was_clean: true,},)- .await;+ .await?;break;}Some(Ok(Message::Ping(payload))) => {@@ -283,7 +283,7 @@ async fn run_open_websocket_connection(&mut pending_buffered_amount,&mut writer_done,)- .await,+ .await?,WriterEventOutcome::Terminate) {// The drain itself surfaced a writer `Error` and@@ -301,8 +301,8 @@ async fn run_open_websocket_connection(socket_id,&mut pending_buffered_amount,)- .await;- let _ = send_event(+ .await?;+ send_event(&event_tx,Event::Close {socket_id,@@ -311,20 +311,20 @@ async fn run_open_websocket_connection(was_clean: true,},)- .await;+ .await?;} else {flush_pending_buffered_amount(&event_tx,socket_id,&mut pending_buffered_amount,)- .await;+ .await?;send_error_and_close(&event_tx,socket_id,format!("WebSocket receive failed: {error}"),)- .await;+ .await?;}break;}@@ -342,7 +342,7 @@ async fn run_open_websocket_connection(&mut pending_buffered_amount,&mut writer_done,)- .await,+ .await?,WriterEventOutcome::Terminate) {break;@@ -352,12 +352,12 @@ async fn run_open_websocket_connection(socket_id,&mut pending_buffered_amount,)- .await;+ .await?;let (code, reason, was_clean) = sent_close.clone().map(|(code, reason)| (code, reason, true)).unwrap_or((1006, String::new(), false));- let _ = send_event(+ send_event(&event_tx,Event::Close {socket_id,@@ -366,7 +366,7 @@ async fn run_open_websocket_connection(was_clean,},)- .await;+ .await?;break;}}@@ -385,7 +385,7 @@ async fn run_open_websocket_connection(&mut pending_buffered_amount,&mut writer_done,)- .await,+ .await?,WriterEventOutcome::Terminate) {break;@@ -393,6 +393,7 @@ async fn run_open_websocket_connection(}}}+ Ok(())}enum WebSocketWriterEvent {@@ -536,25 +537,26 @@ async fn send_next_buffered_amount(event_tx: &EventSender,socket_id: u64,pending_buffered_amount: &mut VecDeque<usize>,-) {+) -> EventResult {let Some(amount) = pending_buffered_amount.pop_front() else {- return;+ return Ok(());};- let _ = send_event(+ send_event(event_tx,Event::BufferedAmountConsumed { socket_id, amount },)- .await;+ .await}async fn flush_pending_buffered_amount(event_tx: &EventSender,socket_id: u64,pending_buffered_amount: &mut VecDeque<usize>,-) {+) -> EventResult {while !pending_buffered_amount.is_empty() {- send_next_buffered_amount(event_tx, socket_id, pending_buffered_amount).await;+ send_next_buffered_amount(event_tx, socket_id, pending_buffered_amount).await?;}+ Ok(())}/// Outcome of processing a single `WebSocketWriterEvent`. `Terminate` means@@ -580,13 +582,13 @@ async fn handle_writer_event(sent_close: &mut Option<(u16, String)>,pending_buffered_amount: &mut VecDeque<usize>,writer_done: &mut bool,-) -> WriterEventOutcome {+) -> EventResult<WriterEventOutcome> {match writer_event {WebSocketWriterEvent::FrameSent {opcode,payload_length,} => {- let _ = send_event(+ send_event(event_tx,Event::FrameSent {socket_id,@@ -594,24 +596,24 @@ async fn handle_writer_event(payload_length,},)- .await;+ .await?;pending_buffered_amount.push_back(payload_length);- WriterEventOutcome::Continue+ Ok(WriterEventOutcome::Continue)}WebSocketWriterEvent::Closing { code, reason } => {*sent_close = Some((code, reason));- let _ = send_event(event_tx, Event::Closing { socket_id }).await;- flush_pending_buffered_amount(event_tx, socket_id, pending_buffered_amount).await;- WriterEventOutcome::Continue+ send_event(event_tx, Event::Closing { socket_id }).await?;+ flush_pending_buffered_amount(event_tx, socket_id, pending_buffered_amount).await?;+ Ok(WriterEventOutcome::Continue)}WebSocketWriterEvent::Error(message) => {- flush_pending_buffered_amount(event_tx, socket_id, pending_buffered_amount).await;- send_error_and_close(event_tx, socket_id, message).await;- WriterEventOutcome::Terminate+ flush_pending_buffered_amount(event_tx, socket_id, pending_buffered_amount).await?;+ send_error_and_close(event_tx, socket_id, message).await?;+ Ok(WriterEventOutcome::Terminate)}WebSocketWriterEvent::Done => {*writer_done = true;- WriterEventOutcome::Continue+ Ok(WriterEventOutcome::Continue)}}}@@ -637,7 +639,7 @@ async fn drain_pending_writer_events(sent_close: &mut Option<(u16, String)>,pending_buffered_amount: &mut VecDeque<usize>,writer_done: &mut bool,-) -> WriterEventOutcome {+) -> EventResult<WriterEventOutcome> {while let Ok(writer_event) = writer_event_rx.try_recv() {if matches!(handle_writer_event(@@ -648,11 +650,11 @@ async fn drain_pending_writer_events(pending_buffered_amount,writer_done,)- .await,+ .await?,WriterEventOutcome::Terminate) {- return WriterEventOutcome::Terminate;+ return Ok(WriterEventOutcome::Terminate);}}- WriterEventOutcome::Continue+ Ok(WriterEventOutcome::Continue)}diff --git a/moli-websocket/src/events.rs b/moli-websocket/src/events.rsindex 80c782ba8..c0de69db2 100644--- a/moli-websocket/src/events.rs+++ b/moli-websocket/src/events.rs@@ -98,15 +98,26 @@ impl std::fmt::Debug for EventSender {}}-pub(crate) async fn send_event(event_tx: &EventSender, event: Event) -> bool {- event_tx.send(event).await+#[derive(Debug)]+pub(crate) struct EventSinkClosed;++pub(crate) type EventResult<T = ()> = Result<T, EventSinkClosed>;++pub(crate) async fn send_event(event_tx: &EventSender, event: Event) -> EventResult {+ event_tx+ .send(event)+ .await+ .then_some(())+ .ok_or(EventSinkClosed)}-pub(crate) async fn send_error_and_close(event_tx: &EventSender, socket_id: u64, message: String) {- if !send_event(event_tx, Event::Error { socket_id, message }).await {- return;- }- let _ = send_event(+pub(crate) async fn send_error_and_close(+ event_tx: &EventSender,+ socket_id: u64,+ message: String,+) -> EventResult {+ send_event(event_tx, Event::Error { socket_id, message }).await?;+ send_event(event_tx,Event::Close {socket_id,@@ -115,5 +126,5 @@ pub(crate) async fn send_error_and_close(event_tx: &EventSender, socket_id: u64,was_clean: false,},)- .await;+ .await}diff --git a/moli-websocket/src/handshake.rs b/moli-websocket/src/handshake.rsindex c87452dfc..935c66fc8 100644--- a/moli-websocket/src/handshake.rs+++ b/moli-websocket/src/handshake.rs@@ -1,87 +1,9 @@-use tokio::{- io::{AsyncReadExt, AsyncWriteExt},- net::TcpStream,-};-use tokio_tungstenite::{- MaybeTlsStream, WebSocketStream,- tungstenite::{- handshake::{client::Response, derive_accept_key},- protocol::Role,- },-};+//! Browser handshake validation, independent of the socket transport.+use tokio_tungstenite::tungstenite::handshake::derive_accept_key;-const MAX_WEBSOCKET_HANDSHAKE_RESPONSE_SIZE: usize = 64 * 1024;+pub(crate) type HandshakeResponse = http::Response<()>;-pub(crate) async fn browser_client_handshake(- request: http::Request<()>,- mut stream: MaybeTlsStream<TcpStream>,-) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), String> {- write_handshake_request(&mut stream, &request).await?;- let (response, tail) = read_handshake_response(&mut stream).await?;- validate_handshake_response(&request, &response)?;- let stream = WebSocketStream::from_partially_read(stream, tail, Role::Client, None).await;- Ok((stream, response))-}--async fn write_handshake_request(- stream: &mut MaybeTlsStream<TcpStream>,- request: &http::Request<()>,-) -> Result<(), String> {- let request_target = request- .uri()- .path_and_query()- .map(|path| path.as_str())- .unwrap_or("/");- let mut raw = format!("GET {request_target} HTTP/1.1\r\n").into_bytes();- for (name, value) in request.headers() {- raw.extend_from_slice(name.as_str().as_bytes());- raw.extend_from_slice(b": ");- raw.extend_from_slice(value.as_bytes());- raw.extend_from_slice(b"\r\n");- }- raw.extend_from_slice(b"\r\n");- stream- .write_all(&raw)- .await- .map_err(|error| format!("failed to write WebSocket handshake request: {error}"))?;- stream- .flush()- .await- .map_err(|error| format!("failed to flush WebSocket handshake request: {error}"))-}--async fn read_handshake_response(- stream: &mut MaybeTlsStream<TcpStream>,-) -> Result<(Response, Vec<u8>), String> {- let mut raw = Vec::new();- let mut chunk = [0_u8; 512];- loop {- let count = stream- .read(&mut chunk)- .await- .map_err(|error| format!("failed to read WebSocket handshake response: {error}"))?;- if count == 0 {- return Err("WebSocket server closed during handshake".to_owned());- }- raw.extend_from_slice(&chunk[..count]);- if let Some(header_end) = find_header_end(&raw) {- let tail = raw[header_end..].to_vec();- let response = parse_handshake_response(&raw[..header_end - 4])?;- return Ok((response, tail));- }- if raw.len() > MAX_WEBSOCKET_HANDSHAKE_RESPONSE_SIZE {- return Err("WebSocket handshake response is too large".to_owned());- }- }-}--fn find_header_end(raw: &[u8]) -> Option<usize> {- raw.windows(4)- .position(|window| window == b"\r\n\r\n")- .map(|position| position + 4)-}--fn parse_handshake_response(raw_headers: &[u8]) -> Result<Response, String> {+pub(crate) fn parse_handshake_response(raw_headers: &[u8]) -> Result<HandshakeResponse, String> {let headers = std::str::from_utf8(raw_headers).map_err(|error| format!("WebSocket handshake response is not UTF-8: {error}"))?;let mut lines = headers.split("\r\n");@@ -100,7 +22,7 @@ fn parse_handshake_response(raw_headers: &[u8]) -> Result<Response, String> {.ok_or_else(|| "WebSocket handshake response is missing status code".to_owned())?.parse::<u16>().map_err(|error| format!("WebSocket handshake response has invalid status: {error}"))?;- let mut response = Response::new(None);+ let mut response = HandshakeResponse::new(());*response.status_mut() = http::StatusCode::from_u16(status).map_err(|error| format!("WebSocket handshake response has invalid status: {error}"))?;@@ -126,9 +48,9 @@ fn parse_handshake_response(raw_headers: &[u8]) -> Result<Response, String> {Ok(response)}-fn validate_handshake_response(+pub(crate) fn validate_handshake_response(request: &http::Request<()>,- response: &Response,+ response: &HandshakeResponse,) -> Result<(), String> {if response.status() != http::StatusCode::SWITCHING_PROTOCOLS {return Err(format!(@@ -176,7 +98,7 @@ fn header_values_contain_token(fn validate_response_subprotocol(request: &http::Request<()>,- response: &Response,+ response: &HandshakeResponse,) -> Result<(), String> {let selected_protocols = response.headers()diff --git a/moli-websocket/src/runtime.rs b/moli-websocket/src/runtime.rsindex ee855ce7c..f6480b7cf 100644--- a/moli-websocket/src/runtime.rs+++ b/moli-websocket/src/runtime.rs@@ -18,7 +18,8 @@ pub fn spawn_connection(let event_tx = event_tx.into();let (command_tx, command_rx) = mpsc::unbounded_channel();let task = websocket_runtime().spawn(async move {- run_websocket_connection(socket_id, url, protocols, context, command_rx, event_tx).await;+ let _ = run_websocket_connection(socket_id, url, protocols, context, command_rx, event_tx)+ .await;});ConnectionHandle::new(command_tx, task.abort_handle())}@@ -31,7 +32,7 @@ pub fn spawn_failed_connection(let event_tx = event_tx.into();let (command_tx, _command_rx) = mpsc::unbounded_channel();let task = websocket_runtime().spawn(async move {- send_error_and_close(&event_tx, socket_id, message).await;+ let _ = send_error_and_close(&event_tx, socket_id, message).await;});ConnectionHandle::new(command_tx, task.abort_handle())}@@ -46,7 +47,7 @@ pub fn spawn_synthetic_connection(let event_tx = event_tx.into();let (command_tx, command_rx) = mpsc::unbounded_channel();let task = websocket_runtime().spawn(async move {- run_synthetic_websocket_connection(+ let _ = run_synthetic_websocket_connection(socket_id,command_rx,event_tx,diff --git a/moli-websocket/src/stream.rs b/moli-websocket/src/stream.rsindex 61877f0cb..36b7d3326 100644--- a/moli-websocket/src/stream.rs+++ b/moli-websocket/src/stream.rs@@ -1,11 +1,12 @@use tokio::net::TcpStream;-use tokio_tungstenite::{- MaybeTlsStream, WebSocketStream, tungstenite::handshake::client::Response,-};+use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};++mod handshake;+use handshake::browser_client_handshake;use crate::{ConnectOptions,- handshake::browser_client_handshake,+ handshake::HandshakeResponse,proxy::{connect_websocket_via_http_proxy_tunnel, websocket_proxy_url, websocket_target_authority,},@@ -15,7 +16,13 @@ use crate::{pub(crate) async fn open_websocket_stream(request: http::Request<()>,context: &ConnectOptions,-) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), String> {+) -> Result<+ (+ WebSocketStream<MaybeTlsStream<TcpStream>>,+ HandshakeResponse,+ ),+ String,+> {let proxy_url = websocket_proxy_url(request.uri(), context)?;let tcp_stream = match proxy_url {Some(proxy_url) => {diff --git a/moli-websocket/src/stream/handshake.rs b/moli-websocket/src/stream/handshake.rsnew file mode 100644index 000000000..e5ae8a339--- /dev/null+++ b/moli-websocket/src/stream/handshake.rs@@ -0,0 +1,83 @@+use crate::handshake::{HandshakeResponse, parse_handshake_response, validate_handshake_response};+use tokio::{+ io::{AsyncReadExt, AsyncWriteExt},+ net::TcpStream,+};+use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, tungstenite::protocol::Role};++const MAX_WEBSOCKET_HANDSHAKE_RESPONSE_SIZE: usize = 64 * 1024;++pub(crate) async fn browser_client_handshake(+ request: http::Request<()>,+ mut stream: MaybeTlsStream<TcpStream>,+) -> Result<+ (+ WebSocketStream<MaybeTlsStream<TcpStream>>,+ HandshakeResponse,+ ),+ String,+> {+ write_handshake_request(&mut stream, &request).await?;+ let (response, tail) = read_handshake_response(&mut stream).await?;+ validate_handshake_response(&request, &response)?;+ let stream = WebSocketStream::from_partially_read(stream, tail, Role::Client, None).await;+ Ok((stream, response))+}++async fn write_handshake_request(+ stream: &mut MaybeTlsStream<TcpStream>,+ request: &http::Request<()>,+) -> Result<(), String> {+ let request_target = request+ .uri()+ .path_and_query()+ .map(|path| path.as_str())+ .unwrap_or("/");+ let mut raw = format!("GET {request_target} HTTP/1.1\r\n").into_bytes();+ for (name, value) in request.headers() {+ raw.extend_from_slice(name.as_str().as_bytes());+ raw.extend_from_slice(b": ");+ raw.extend_from_slice(value.as_bytes());+ raw.extend_from_slice(b"\r\n");+ }+ raw.extend_from_slice(b"\r\n");+ stream+ .write_all(&raw)+ .await+ .map_err(|error| format!("failed to write WebSocket handshake request: {error}"))?;+ stream+ .flush()+ .await+ .map_err(|error| format!("failed to flush WebSocket handshake request: {error}"))+}++async fn read_handshake_response(+ stream: &mut MaybeTlsStream<TcpStream>,+) -> Result<(HandshakeResponse, Vec<u8>), String> {+ let mut raw = Vec::new();+ let mut chunk = [0_u8; 512];+ loop {+ let count = stream+ .read(&mut chunk)+ .await+ .map_err(|error| format!("failed to read WebSocket handshake response: {error}"))?;+ if count == 0 {+ return Err("WebSocket server closed during handshake".to_owned());+ }+ raw.extend_from_slice(&chunk[..count]);+ if let Some(header_end) = find_header_end(&raw) {+ let tail = raw[header_end..].to_vec();+ let response = parse_handshake_response(&raw[..header_end - 4])?;+ return Ok((response, tail));+ }+ if raw.len() > MAX_WEBSOCKET_HANDSHAKE_RESPONSE_SIZE {+ return Err("WebSocket handshake response is too large".to_owned());+ }+ }+}++fn find_header_end(raw: &[u8]) -> Option<usize> {+ raw.windows(4)+ .position(|window| window == b"\r\n\r\n")+ .map(|position| position + 4)+}diff --git a/moli-websocket/src/synthetic.rs b/moli-websocket/src/synthetic.rsindex 9a414e5c9..d9da639dd 100644--- a/moli-websocket/src/synthetic.rs+++ b/moli-websocket/src/synthetic.rs@@ -2,7 +2,7 @@ use tokio::sync::mpsc;use crate::{Command, Event, FrameOpcode,- events::{EventSender, send_error_and_close, send_event},+ events::{EventResult, EventSender, send_error_and_close, send_event},limits::acquire_websocket_connection_slot,};@@ -13,15 +13,15 @@ pub(crate) async fn run_synthetic_websocket_connection(request_headers: Vec<(String, String)>,response_status: u16,response_headers: Vec<(String, String)>,-) {+) -> EventResult {let Some(_connection_slot) = acquire_websocket_connection_slot() else {send_error_and_close(&event_tx,socket_id,"WebSocket connection failed: insufficient resources".to_owned(),)- .await;- return;+ .await?;+ return Ok(());};let protocol = response_header(&response_headers, "sec-websocket-protocol")@@ -30,7 +30,7 @@ pub(crate) async fn run_synthetic_websocket_connection(let extensions = response_header(&response_headers, "sec-websocket-extensions").unwrap_or_default().to_owned();- let _ = send_event(+ send_event(&event_tx,Event::Open {socket_id,@@ -41,13 +41,13 @@ pub(crate) async fn run_synthetic_websocket_connection(response_headers,},)- .await;+ .await?;while let Some(command) = command_rx.recv().await {match command {Command::SendText(text) => {let amount = text.len();- let _ = send_event(+ send_event(&event_tx,Event::FrameSent {socket_id,@@ -55,16 +55,16 @@ pub(crate) async fn run_synthetic_websocket_connection(payload_length: amount,},)- .await;- let _ = send_event(+ .await?;+ send_event(&event_tx,Event::BufferedAmountConsumed { socket_id, amount },)- .await;+ .await?;}Command::SendBinary(bytes) => {let amount = bytes.len();- let _ = send_event(+ send_event(&event_tx,Event::FrameSent {socket_id,@@ -72,23 +72,23 @@ pub(crate) async fn run_synthetic_websocket_connection(payload_length: amount,},)- .await;- let _ = send_event(+ .await?;+ send_event(&event_tx,Event::BufferedAmountConsumed { socket_id, amount },)- .await;+ .await?;}Command::ReceiveText(data) => {- let _ = send_event(&event_tx, Event::TextMessage { socket_id, data }).await;+ send_event(&event_tx, Event::TextMessage { socket_id, data }).await?;}Command::ReceiveBinary(data) => {- let _ = send_event(&event_tx, Event::BinaryMessage { socket_id, data }).await;+ send_event(&event_tx, Event::BinaryMessage { socket_id, data }).await?;}Command::ServerClose { code, reason } => {let close_event_code = code.unwrap_or(1005);let close_event_reason = code.map(|_| reason).unwrap_or_default();- let _ = send_event(+ send_event(&event_tx,Event::Close {socket_id,@@ -97,14 +97,14 @@ pub(crate) async fn run_synthetic_websocket_connection(was_clean: true,},)- .await;- return;+ .await?;+ return Ok(());}Command::Close { code, reason } => {let close_event_code = code.unwrap_or(1005);let close_event_reason = code.map(|_| reason).unwrap_or_default();- let _ = send_event(&event_tx, Event::Closing { socket_id }).await;- let _ = send_event(+ send_event(&event_tx, Event::Closing { socket_id }).await?;+ send_event(&event_tx,Event::Close {socket_id,@@ -113,18 +113,18 @@ pub(crate) async fn run_synthetic_websocket_connection(was_clean: true,},)- .await;- return;+ .await?;+ return Ok(());}Command::ContinueOpen { .. } => {}Command::FailOpen(message) => {- send_error_and_close(&event_tx, socket_id, message).await;- return;+ send_error_and_close(&event_tx, socket_id, message).await?;+ return Ok(());}}}- let _ = send_event(+ send_event(&event_tx,Event::Close {socket_id,@@ -133,7 +133,7 @@ pub(crate) async fn run_synthetic_websocket_connection(was_clean: false,},)- .await;+ .await}fn response_header<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {diff --git a/moli-websocket/src/tests.rs b/moli-websocket/src/tests.rsindex 843e6f7b8..468170fd7 100644--- a/moli-websocket/src/tests.rs+++ b/moli-websocket/src/tests.rs@@ -487,6 +487,119 @@ impl Drop for WebSocketSinkDropSignal {}}+#[tokio::test]+async fn websocket_rejected_handshake_or_open_event_releases_transport() {+ use futures_util::StreamExt;++ for pause_after_handshake in [false, true] {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let url = format!("ws://{}/closed-sink", listener.local_addr().unwrap());+ let (command_tx, command_rx) = mpsc::unbounded_channel();+ let mut context = test_websocket_context();+ context.pause_after_handshake = pause_after_handshake;+ let server = async move {+ let (stream, _) = listener.accept().await.unwrap();+ let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap();+ let terminal = socket.next().await;+ assert!(terminal.is_none() || terminal.is_some_and(|result| result.is_err()));+ };+ let client = crate::connection::run_websocket_connection(+ 64,+ url,+ Vec::new(),+ context,+ command_rx,+ EventSender::closed(),+ );+ let (result, ()) = timeout(Duration::from_secs(3), async {+ tokio::join!(client, server)+ })+ .await+ .expect("a closed sink must release the connection before waiting for commands");+ result.expect_err("delivery should report the unavailable sink");+ assert!(command_tx.is_closed());+ }+}++#[tokio::test]+async fn websocket_rejected_message_event_releases_transport_and_writer() {+ use futures_util::{SinkExt, StreamExt};++ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let url = format!(+ "ws://{}/closed-message-sink",+ listener.local_addr().unwrap()+ );+ let (command_tx, command_rx) = mpsc::unbounded_channel();+ let sink =+ EventSender::with_async_sink(+ |event| async move { !matches!(event, Event::TextMessage { .. }) },+ );+ let server = async move {+ let (stream, _) = listener.accept().await.unwrap();+ let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap();+ socket.send("reject delivery".into()).await.unwrap();+ let terminal = socket.next().await;+ assert!(terminal.is_none() || terminal.is_some_and(|result| result.is_err()));+ };+ let client = crate::connection::run_websocket_connection(+ 65,+ url,+ Vec::new(),+ test_websocket_context(),+ command_rx,+ sink,+ );+ let (result, ()) = timeout(Duration::from_secs(3), async {+ tokio::join!(client, server)+ })+ .await+ .expect("message delivery rejection must stop both transport tasks");+ result.expect_err("message sink is closed");+ assert!(command_tx.is_closed());+}++#[tokio::test]+async fn websocket_synthetic_delivery_stops_after_first_rejected_event() {+ let (command_tx, command_rx) = mpsc::unbounded_channel();+ command_tx+ .send(Command::SendText("hello".to_owned()))+ .unwrap();+ let (observed_tx, mut observed_rx) = mpsc::unbounded_channel();+ let sink = EventSender::with_async_sink(move |event| {+ let observed_tx = observed_tx.clone();+ async move {+ let accept = matches!(event, Event::Open { .. });+ observed_tx.send(event).unwrap();+ accept+ }+ });+ timeout(+ Duration::from_secs(3),+ crate::synthetic::run_synthetic_websocket_connection(+ 66,+ command_rx,+ sink,+ Vec::new(),+ 101,+ Vec::new(),+ ),+ )+ .await+ .expect("synthetic producer must stop when FrameSent 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 { .. })+ ));+ assert!(+ observed_rx.try_recv().is_err(),+ "no further delivery attempts after rejection"+ );+}+#[tokio::test]async fn websocket_cancel_releases_blocked_sink_and_open_writer() {use futures_util::{SinkExt, StreamExt};