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 native send admission and completion
ldm033108fcffd81
diff --git a/moli-curl/src/websocket.rs b/moli-curl/src/websocket.rsindex 63eca7d0a..f14be6b63 100644--- a/moli-curl/src/websocket.rs+++ b/moli-curl/src/websocket.rs@@ -21,7 +21,7 @@ use std::{use anyhow::{Context, Result, bail};use curl::multi::MultiWaker;use parking_lot::Mutex;-use tokio::sync::{OwnedSemaphorePermit, Semaphore, mpsc};+use tokio::sync::{OwnedSemaphorePermit, Semaphore, mpsc, oneshot};use crate::{CurlDnsResolution, CurlTlsConfig, CurlTransferId, runtime::identity::next_transfer_id,@@ -30,8 +30,7 @@ pub use curl::easy::{WsFlags, WsFrame};/// Fragment large messages above this layer to bound native write residence.pub const MAX_SEND_FRAME_BYTES: usize = 64 * 1024;-/// Maximum native events queued per connection, including chunks and send receipts.-pub const MAX_PENDING_EVENTS: usize = 8;+const MAX_PENDING_EVENTS: usize = 8;const DATA_CAPACITY: usize = 8;const CONTROL_CAPACITY: usize = 4;const SESSION_CAPACITY: usize = 255;@@ -75,10 +74,6 @@ pub enum CurlWebSocketEvent {data: Vec<u8>,frame: WsFrame,},- Sent {- token: u64,- payload_length: usize,- },/// Emitted once, after all previously admitted events. Ok means TCP EOF;/// it does not assert that a WebSocket close handshake was completed.Closed {@@ -88,7 +83,6 @@ pub enum CurlWebSocketEvent {#[derive(Debug)]pub struct CurlWebSocketSend {- pub token: u64,pub flags: WsFlags,pub data: Vec<u8>,}@@ -120,6 +114,8 @@ struct Control {cancelled: AtomicBool,closed: AtomicBool,reading: AtomicBool,+ data_slots: Arc<Semaphore>,+ control_slots: Arc<Semaphore>,terminal: Mutex<Option<std::result::Result<(), String>>>,waker: MultiWaker,#[cfg(test)]@@ -132,45 +128,99 @@ impl Control {fn wake(&self) {let _ = self.waker.wakeup();}+ fn close_admission(&self) {+ self.data_slots.close();+ self.control_slots.close();+ }fn cancel(&self) {self.cancelled.store(true, Ordering::Release);+ self.close_admission();self.wake();}}+/// Completion of one admitted frame, independent of the receive event queue.+///+/// A retained receipt holds one send slot until it is consumed or dropped.+/// The native write retains the same slot until the frame completes or fails.+#[derive(Debug)]+pub struct CurlWebSocketSendReceipt {+ completion: oneshot::Receiver<usize>,+ _reservation: Arc<OwnedSemaphorePermit>,+}++impl CurlWebSocketSendReceipt {+ /// Waits until libcurl consumes the full frame payload and returns its size.+ /// Transport failure or cancellation before completion returns an error.+ pub async fn wait(self) -> Result<usize> {+ self.completion+ .await+ .context("WebSocket transport closed before frame completion")+ }+}++#[derive(Debug)]+struct QueuedSend {+ frame: CurlWebSocketSend,+ completed: oneshot::Sender<usize>,+ _reservation: Arc<OwnedSemaphorePermit>,+}+/// Cloneable write/control capability; it does not keep a dropped receiver alive.#[derive(Clone, Debug)]pub struct CurlWebSocketSender {- data: mpsc::Sender<CurlWebSocketSend>,- control_frames: mpsc::Sender<CurlWebSocketSend>,+ data: mpsc::Sender<QueuedSend>,+ control_frames: mpsc::Sender<QueuedSend>,control: Arc<Control>,}impl CurlWebSocketSender {- /// Waits only for this connection's bounded queue. The native owner never waits.- pub async fn send(&self, frame: CurlWebSocketSend) -> Result<()> {+ /// Admits one frame, returning a separate native completion receipt.+ ///+ /// Admission waits for a bounded slot covering queued frames, native writes+ /// and unconsumed receipts. Cancelling this future before it returns does+ /// not submit a frame. Dropping its receipt does not cancel an admitted frame.+ pub async fn enqueue_frame(+ &self,+ frame: CurlWebSocketSend,+ ) -> Result<CurlWebSocketSendReceipt> {frame.validate()?;+ let (queue, slots) = if frame.is_control() {+ (&self.control_frames, &self.control.control_slots)+ } else {+ (&self.data, &self.control.data_slots)+ };+ let reservation = Arc::new(+ slots+ .clone()+ .acquire_owned()+ .await+ .context("WebSocket transport is closed")?,+ );if self.control.closed.load(Ordering::Acquire)|| self.control.cancelled.load(Ordering::Acquire){bail!("WebSocket transport is closed");}- let queue = if frame.is_control() {- &self.control_frames- } else {- &self.data- };+ let (completed, completion) = oneshot::channel();+ // A slot also covers the queued frame, so the queue cannot be full here.queue- .send(frame)- .await- .context("WebSocket transport is closed")?;+ .try_send(QueuedSend {+ frame,+ completed,+ _reservation: reservation.clone(),+ })+ .context("WebSocket transport cannot accept a frame")?;self.control.wake();- Ok(())+ Ok(CurlWebSocketSendReceipt {+ completion,+ _reservation: reservation,+ })}/// Handshake delivery starts paused, so application data cannot outrun Open./// Pausing does not retract queued chunks or a read already in progress.- /// Keep receiving events while paused so send receipts can make progress.+ /// Send completions progress independently of reads and received events.pub fn set_reading(&self, enabled: bool) {self.control.reading.store(enabled, Ordering::Release);self.control.wake();@@ -225,8 +275,8 @@ impl Drop for CurlWebSocketConnection {struct SessionIo {events: mpsc::Sender<CurlWebSocketEvent>,- data: mpsc::Receiver<CurlWebSocketSend>,- control_frames: mpsc::Receiver<CurlWebSocketSend>,+ data: mpsc::Receiver<QueuedSend>,+ control_frames: mpsc::Receiver<QueuedSend>,control: Arc<Control>,_slot: OwnedSemaphorePermit,}@@ -243,6 +293,7 @@ impl SessionIo {impl Drop for SessionIo {fn drop(&mut self) {self.control.closed.store(true, Ordering::Release);+ self.control.close_admission();}}@@ -305,6 +356,8 @@ impl CurlWebSocketRuntime {cancelled: AtomicBool::new(false),closed: AtomicBool::new(false),reading: AtomicBool::new(false),+ data_slots: Arc::new(Semaphore::new(DATA_CAPACITY)),+ control_slots: Arc::new(Semaphore::new(CONTROL_CAPACITY)),terminal: Mutex::new(None),waker: self.inner.waker.clone(),#[cfg(test)]diff --git a/moli-curl/src/websocket/owner.rs b/moli-curl/src/websocket/owner.rsindex 59ac19f0f..3ec9741e5 100644--- a/moli-curl/src/websocket/owner.rs+++ b/moli-curl/src/websocket/owner.rs@@ -13,7 +13,7 @@ use curl::{};use super::{- CurlWebSocketEvent, CurlWebSocketSend, SessionIo, Submission,+ CurlWebSocketEvent, QueuedSend, SessionIo, Submission,request::{self, Handshake},};use crate::{CurlDnsResolution, CurlTransferId, dns_adapter::CurlDnsOwnerResidence};@@ -40,7 +40,7 @@ struct Session {}struct PendingSend {- frame: CurlWebSocketSend,+ queued: QueuedSend,offset: usize,}@@ -261,16 +261,6 @@ impl Session {if self.io.cancelled() {return Err(Ok(()));}- // Reserve before native I/O so every completion has bounded residence.- let permit = match self.io.events.try_reserve() {- Ok(permit) => permit,- Err(tokio::sync::mpsc::error::TrySendError::Full(_)) => {- #[cfg(test)]- self.io.control.read_blocked.notify_one();- break;- }- Err(tokio::sync::mpsc::error::TrySendError::Closed(_)) => return Err(Ok(())),- };if self.send.is_none() {self.send = self.io@@ -278,25 +268,20 @@ impl Session {.try_recv().or_else(|_| self.io.data.try_recv()).ok()- .map(|frame| PendingSend { frame, offset: 0 });+ .map(|queued| PendingSend { queued, offset: 0 });}- let mut permit = Some(permit);if let Some(send) = &mut self.send {- match self- .handle- .ws_send(&send.frame.data[send.offset..], 0, send.frame.flags)- {+ match self.handle.ws_send(+ &send.queued.frame.data[send.offset..],+ 0,+ send.queued.frame.flags,+ ) {Ok(count) => {send.offset += count;progressed = true;- if send.offset == send.frame.data.len() {- permit.take().expect("reserved completion slot").send(- CurlWebSocketEvent::Sent {- token: send.frame.token,- payload_length: send.offset,- },- );- self.send = None;+ if send.offset == send.queued.frame.data.len() {+ let send = self.send.take().expect("completed frame");+ let _ = send.queued.completed.send(send.offset);}}Err(error) if error.is_again() => {@@ -306,12 +291,17 @@ impl Session {Err(error) => return Err(Err(format!("WebSocket send failed: {error}"))),}}- drop(permit);if self.received_close || !self.io.control.reading.load(Ordering::Acquire) {break;}- let Ok(permit) = self.io.events.try_reserve() else {- break;+ let permit = match self.io.events.try_reserve() {+ Ok(permit) => permit,+ Err(tokio::sync::mpsc::error::TrySendError::Full(_)) => {+ #[cfg(test)]+ self.io.control.read_blocked.notify_one();+ break;+ }+ Err(tokio::sync::mpsc::error::TrySendError::Closed(_)) => return Err(Ok(())),};let mut data = vec![0; CHUNK_BYTES];match self.handle.ws_recv(&mut data) {@@ -333,10 +323,12 @@ impl Session {}fn wait_fd(&self) -> Option<WaitFd> {- if !self.open || self.io.events.capacity() == 0 {+ if !self.open {return None;}- let reading = !self.received_close && self.io.control.reading.load(Ordering::Acquire);+ let reading = self.io.events.capacity() > 0+ && !self.received_close+ && self.io.control.reading.load(Ordering::Acquire);let writing =self.send.is_some() || !self.io.data.is_empty() || !self.io.control_frames.is_empty();if !reading && !writing {diff --git a/moli-curl/src/websocket/tests.rs b/moli-curl/src/websocket/tests.rsindex f943ff00c..cf9f99c93 100644--- a/moli-curl/src/websocket/tests.rs+++ b/moli-curl/src/websocket/tests.rs@@ -129,55 +129,45 @@ async fn native_fragmented_send_completes_without_echo() {let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();opened(&mut connection).await;let sender = connection.sender();+ let mut receipts = Vec::new();for (i, data) in payload.chunks(MAX_SEND_FRAME_BYTES).enumerate() {+ receipts.push(+ sender+ .enqueue_frame(CurlWebSocketSend {+ data: data.to_vec(),+ flags: if i == 0 {+ WsFlags::BINARY | WsFlags::CONT+ } else {+ WsFlags::BINARY+ },+ })+ .await+ .unwrap(),+ );+ }+ receipts.push(sender- .send(CurlWebSocketSend {- token: i as u64,- data: data.to_vec(),- flags: if i == 0 {- WsFlags::BINARY | WsFlags::CONT- } else {- WsFlags::BINARY- },+ .enqueue_frame(CurlWebSocketSend {+ data: Vec::new(),+ flags: WsFlags::TEXT,}).await- .unwrap();- }- sender- .send(CurlWebSocketSend {- token: 2,- data: Vec::new(),- flags: WsFlags::TEXT,- })- .await- .unwrap();- for token in 0..3 {- match event(&mut connection).await {- CurlWebSocketEvent::Sent {- token: actual,- payload_length,- } => {- assert_eq!(actual, token);- assert_eq!(- payload_length,- if token == 2 { 0 } else { MAX_SEND_FRAME_BYTES }- );- }- unexpected => panic!("expected send completion, got {unexpected:?}"),- }+ .unwrap(),+ );+ for (i, receipt) in receipts.into_iter().enumerate() {+ assert_eq!(+ timeout(DEADLINE, receipt.wait()).await.unwrap().unwrap(),+ if i == 2 { 0 } else { MAX_SEND_FRAME_BYTES }+ );}- sender- .send(CurlWebSocketSend {- token: 3,+ let close = sender+ .enqueue_frame(CurlWebSocketSend {data: 1000u16.to_be_bytes().to_vec(),flags: WsFlags::CLOSE,}).await.unwrap();- assert!(matches!(- event(&mut connection).await,- CurlWebSocketEvent::Sent { token: 3, .. }- ));+ assert_eq!(timeout(DEADLINE, close.wait()).await.unwrap().unwrap(), 2);sender.set_reading(true);assert!(matches!(event(&mut connection).await, CurlWebSocketEvent::Chunk { frame, .. } if frame.flags() == WsFlags::CLOSE)@@ -308,55 +298,32 @@ async fn native_partial_write_retries_preserve_payload_and_control_boundaries()let sender = connection.sender();let sends = async {for i in 0..FRAMES {- sender- .send(CurlWebSocketSend {- token: i as u64,+ let receipt = sender+ .enqueue_frame(CurlWebSocketSend {flags: WsFlags::BINARY,data: vec![(i % 251) as u8; MAX_SEND_FRAME_BYTES],}).await.unwrap();- }- };- let drain = async {- let mut sent = 0;- let mut ping_sent = false;- while sent < FRAMES || !ping_sent {- match event(&mut connection).await {- CurlWebSocketEvent::Sent {- token: u64::MAX, ..- } => {- assert!(!ping_sent);- ping_sent = true;- }- CurlWebSocketEvent::Sent {- token,- payload_length,- } => {- assert_eq!(payload_length, MAX_SEND_FRAME_BYTES);- assert_eq!(token, sent as u64);- sent += 1;- }- unexpected => panic!("expected completion, got {unexpected:?}"),- }+ assert_eq!(receipt.wait().await.unwrap(), MAX_SEND_FRAME_BYTES);}};let resume = async {timeout(DEADLINE, sender.control.write_blocked.notified()).await.expect("server backpressure must reach native writer");- sender- .send(CurlWebSocketSend {- token: u64::MAX,+ let receipt = sender+ .enqueue_frame(CurlWebSocketSend {flags: WsFlags::PING,data: b"between frames".to_vec(),}).await.unwrap();resume_tx.send(()).unwrap();+ assert_eq!(receipt.wait().await.unwrap(), b"between frames".len());};timeout(DEADLINE, async {- tokio::join!(sends, drain, resume);+ tokio::join!(sends, resume);}).await.unwrap();@@ -411,3 +378,165 @@ fn native_wss_configuration_validates_chain_and_hostname() {task.join().unwrap();}}++#[tokio::test]+async fn native_send_receipts_progress_with_full_receive_queue() {+ let (url, task) = server(|mut stream| {+ let tail: Vec<_> = (0..MAX_PENDING_EVENTS).flat_map(|_| [0x82, 1, 7]).collect();+ upgrade(&mut stream, &tail);+ let mut socket = tungstenite::WebSocket::from_raw_socket(+ stream,+ tungstenite::protocol::Role::Server,+ None,+ );+ assert_eq!(+ socket.read().unwrap(),+ Message::Binary(vec![9; 2 * MAX_SEND_FRAME_BYTES].into())+ );+ assert!(matches!(+ socket.read(),+ Err(tungstenite::Error::Protocol(+ tungstenite::error::ProtocolError::ResetWithoutClosingHandshake+ ))+ ));+ });+ let runtime = CurlWebSocketRuntime::new().unwrap();+ let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();+ opened(&mut connection).await;+ let sender = connection.sender();+ sender.set_reading(true);+ timeout(DEADLINE, sender.control.read_blocked.notified())+ .await+ .unwrap();+ assert_eq!(connection.events.len(), MAX_PENDING_EVENTS);+ for flags in [WsFlags::BINARY | WsFlags::CONT, WsFlags::BINARY] {+ let receipt = sender+ .enqueue_frame(CurlWebSocketSend {+ flags,+ data: vec![9; MAX_SEND_FRAME_BYTES],+ })+ .await+ .unwrap();+ assert_eq!(+ timeout(DEADLINE, receipt.wait()).await.unwrap().unwrap(),+ MAX_SEND_FRAME_BYTES+ );+ }+ assert_eq!(connection.events.len(), MAX_PENDING_EVENTS);+ drop(connection);+ task.join().unwrap();+}++#[tokio::test]+async fn native_unconsumed_receipts_bound_admission_and_keep_control_capacity() {+ let (received_tx, received_rx) = oneshot::channel();+ let (url, task) = server(move |stream| {+ let mut socket = tungstenite::accept(stream).unwrap();+ for _ in 0..DATA_CAPACITY {+ assert_eq!(socket.read().unwrap(), Message::Text("x".into()));+ }+ received_tx.send(()).unwrap();+ assert_eq!(+ socket.read().unwrap(),+ Message::Ping(b"control".to_vec().into())+ );+ assert_eq!(socket.read().unwrap(), Message::Text("next".into()));+ // A cancelled admission must not appear on the wire.+ assert!(socket.read().is_err());+ });+ let runtime = CurlWebSocketRuntime::new().unwrap();+ let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();+ opened(&mut connection).await;+ let sender = connection.sender();+ let mut receipts = Vec::new();+ for _ in 0..DATA_CAPACITY {+ receipts.push(+ sender+ .enqueue_frame(CurlWebSocketSend {+ flags: WsFlags::TEXT,+ data: b"x".to_vec(),+ })+ .await+ .unwrap(),+ );+ }+ timeout(DEADLINE, received_rx).await.unwrap().unwrap();+ let mut cancelled = Box::pin(sender.enqueue_frame(CurlWebSocketSend {+ flags: WsFlags::TEXT,+ data: b"cancelled".to_vec(),+ }));+ assert!(+ std::future::poll_fn(|cx| std::task::Poll::Ready(+ std::future::Future::poll(cancelled.as_mut(), cx).is_pending()+ ))+ .await+ );+ drop(cancelled);+ let control = sender+ .enqueue_frame(CurlWebSocketSend {+ flags: WsFlags::PING,+ data: b"control".to_vec(),+ })+ .await+ .unwrap();+ assert_eq!(timeout(DEADLINE, control.wait()).await.unwrap().unwrap(), 7);+ assert_eq!(receipts.pop().unwrap().wait().await.unwrap(), 1);+ let next = sender+ .enqueue_frame(CurlWebSocketSend {+ flags: WsFlags::TEXT,+ data: b"next".to_vec(),+ })+ .await+ .unwrap();+ assert_eq!(timeout(DEADLINE, next.wait()).await.unwrap().unwrap(), 4);+ drop(receipts);+ drop(connection);+ task.join().unwrap();+}++#[tokio::test]+async fn native_cancel_settles_receipts_queued_during_handshake() {+ let (accepted_tx, accepted_rx) = oneshot::channel();+ let (url, task) = server(move |mut stream| {+ read_request(&mut stream);+ accepted_tx.send(()).unwrap();+ assert_eq!(stream.read(&mut [0]).unwrap(), 0);+ });+ let runtime = CurlWebSocketRuntime::new().unwrap();+ let connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();+ timeout(DEADLINE, accepted_rx).await.unwrap().unwrap();+ let sender = connection.sender();+ let abandoned = sender+ .enqueue_frame(CurlWebSocketSend {+ flags: WsFlags::TEXT,+ data: b"abandoned receipt".to_vec(),+ })+ .await+ .unwrap();+ drop(abandoned);+ assert_eq!(+ sender.control.data_slots.available_permits(),+ DATA_CAPACITY - 1,+ "dropping the receipt must retain the still queued frame's slot"+ );+ let receipt = sender+ .enqueue_frame(CurlWebSocketSend {+ flags: WsFlags::TEXT,+ data: b"pending".to_vec(),+ })+ .await+ .unwrap();+ sender.cancel();+ assert!(timeout(DEADLINE, receipt.wait()).await.unwrap().is_err());+ assert!(+ sender+ .enqueue_frame(CurlWebSocketSend {+ flags: WsFlags::TEXT,+ data: Vec::new(),+ })+ .await+ .is_err()+ );+ drop(connection);+ task.join().unwrap();+}diff --git a/moli-websocket/src/session.rs b/moli-websocket/src/session.rsindex 21013b275..3e90b7d78 100644--- a/moli-websocket/src/session.rs+++ b/moli-websocket/src/session.rs@@ -8,17 +8,16 @@ use crate::{frames::{Assembler, Received, close_payload},};use moli_curl::websocket::{- CurlWebSocketConnection, CurlWebSocketEvent, CurlWebSocketSend, MAX_PENDING_EVENTS,- MAX_SEND_FRAME_BYTES, WsFlags,+ CurlWebSocketConnection, CurlWebSocketEvent, CurlWebSocketSend, MAX_SEND_FRAME_BYTES, WsFlags,};use std::{collections::VecDeque, future::Future, pin::Pin};use tokio::time::{Duration, Instant};type Delivery = Pin<Box<dyn Future<Output = EventResult> + Send>>;-type Sending = Pin<Box<dyn Future<Output = Result<(), String>> + Send>>;+type Sending = Pin<Box<dyn Future<Output = Result<Flight, String>> + Send>>;const CLOSE_TIMEOUT: Duration = Duration::from_secs(5);-// A pause can race one native read in addition to the already queued events.-const MAX_PENDING_INCOMING_MESSAGES: usize = MAX_PENDING_EVENTS + 1;+// Browser delivery budget, independent of native queue capacity.+const MAX_PENDING_INCOMING_MESSAGES: usize = 9;#[cfg(test)]mod tests;@@ -45,6 +44,14 @@ struct Closing {deadline: Option<Instant>,}+enum Activity {+ Sent(Result<Flight, String>),+ Delivered(EventResult),+ Command(Option<QueuedCommand>),+ Native(Option<CurlWebSocketEvent>),+ CloseTimeout,+}+struct Session {socket_id: u64,outbox: VecDeque<Event>,@@ -75,14 +82,12 @@ pub(super) async fn run_open_session(};let mut delivery: Option<Delivery> = None;let mut sending: Option<Sending> = None;- let mut flight: Option<Flight> = None;loop {if session.terminal {// Release physical transport and all reservations before awaiting a// potentially blocked final event. Drop/cancel also aborts delivery.sender.cancel();sending = None;- flight = None;session.outgoing.clear();session.pongs.clear();session.assembler = Assembler::default();@@ -98,17 +103,19 @@ pub(super) async fn run_open_session(}if !session.terminal&& sending.is_none()- && flight.is_none()&& let Some((frame, next_flight)) = session.next_frame(){let sender = sender.clone();sending = Some(Box::pin(async move {- sender.send(frame).await.map_err(|error| error.to_string())+ let receipt = sender+ .enqueue_frame(frame)+ .await+ .map_err(|error| error.to_string())?;+ receipt.wait().await.map_err(|error| error.to_string())?;+ Ok(next_flight)}));- flight = Some(next_flight);}- // Apply application backpressure to socket reads, not to the shared- // event queue: Sent must remain consumable to finish outgoing messages.+ // Pause reads at the source while application delivery is backpressured.let should_read = !session.terminal&& ((delivery.is_none() && session.outbox.is_empty())|| session.closing.requested.is_some());@@ -120,42 +127,80 @@ pub(super) async fn run_open_session(.closing.deadline.unwrap_or_else(|| Instant::now() + CLOSE_TIMEOUT);- tokio::select! {- result = async { delivery.as_mut().expect("delivery exists").await }, if delivery.is_some() => {+ let activity = tokio::select! {+ // Already completed writes precede newly observed incoming messages.+ // Other sources remain fair; completed message residence is bounded.+ biased;+ result = async { sending.as_mut().expect("send exists").await }, if sending.is_some() => Activity::Sent(result),+ activity = async {+ tokio::select! {+ result = async { delivery.as_mut().expect("delivery exists").await }, if delivery.is_some() => Activity::Delivered(result),+ command = commands.recv(), if !session.terminal => Activity::Command(command),+ event = connection.recv(), if should_read => Activity::Native(event),+ _ = tokio::time::sleep_until(deadline), if !session.terminal && session.closing.deadline.is_some() => Activity::CloseTimeout,+ }+ } => activity,+ };+ // The owner publishes a frame's receipt before reading its echo. It+ // can finish between the select's send poll and its receive poll, so+ // recheck the receipt before turning native input into browser events.+ if matches!(activity, Activity::Native(_))+ && let Some(pending) = sending.as_mut()+ {+ let completion =+ std::future::poll_fn(|cx| std::task::Poll::Ready(pending.as_mut().poll(cx))).await;+ if let std::task::Poll::Ready(result) = completion {+ sending = None;+ match result {+ Ok(completed) => session.sent(completed),+ Err(error) => session.fail(error),+ }+ if session.terminal {+ continue;+ }+ }+ }+ match activity {+ Activity::Sent(result) => {+ sending = None;+ match result {+ Ok(completed) => session.sent(completed),+ Err(error) => session.fail(error),+ }+ }+ Activity::Delivered(result) => {delivery = None;result?;}- command = commands.recv(), if !session.terminal => {- match command {- Some(command) => session.command(command),- None => return Ok(()),+ Activity::Command(Some(command)) => session.command(command),+ Activity::Command(None) => return Ok(()),+ Activity::Native(Some(CurlWebSocketEvent::Chunk { data, frame })) => {+ match session.assembler.push(data, frame) {+ Ok(Some(received)) => session.received(received),+ Ok(None) => {}+ Err(error) => session.fail(error),}}- result = async { sending.as_mut().expect("send exists").await }, if sending.is_some() => {- sending = None;- if let Err(error) = result { session.fail(error); }- }- event = connection.recv(), if !session.terminal => {- match event {- Some(CurlWebSocketEvent::Chunk { data, frame }) => match session.assembler.push(data, frame) {- Ok(Some(received)) => session.received(received),- Ok(None) => {}- Err(error) => session.fail(error),- },- Some(CurlWebSocketEvent::Sent { .. }) => {- // Completion can race the queue-admission future's next poll.- sending = None;- if let Some(completed) = flight.take() { session.sent(completed); }- }- Some(CurlWebSocketEvent::Closed { result }) => {- session.fail(result.err().unwrap_or_else(|| "WebSocket closed without completing the closing handshake".to_owned()));- }- Some(CurlWebSocketEvent::Handshake { .. }) => session.fail("WebSocket received a duplicate handshake".to_owned()),- None => session.fail("WebSocket transport stopped".to_owned()),+ Activity::Native(Some(CurlWebSocketEvent::Closed { result })) => {+ // Closure can race the first poll above. Terminal delivery+ // settles every receipt and closes admission before this await.+ if let Some(pending) = sending.take()+ && let Ok(completed) = pending.await+ {+ session.sent(completed);}+ if !session.terminal {+ session.fail(result.err().unwrap_or_else(|| {+ "WebSocket closed without completing the closing handshake".to_owned()+ }));+ }+ }+ Activity::Native(Some(CurlWebSocketEvent::Handshake { .. })) => {+ session.fail("WebSocket received a duplicate handshake".to_owned())}- _ = tokio::time::sleep_until(deadline), if !session.terminal && session.closing.deadline.is_some() => {- session.fail("WebSocket closing handshake timed out".to_owned());+ Activity::Native(None) => session.fail("WebSocket transport stopped".to_owned()),+ Activity::CloseTimeout => {+ session.fail("WebSocket closing handshake timed out".to_owned())}}}@@ -210,7 +255,6 @@ impl Session {if let Some(data) = self.pongs.pop_front() {return Some((CurlWebSocketSend {- token: 0,flags: WsFlags::PONG,data,},@@ -242,11 +286,7 @@ impl Session {}let data = message.data[message.offset..end].to_vec();return Some((- CurlWebSocketSend {- token: 0,- flags,- data,- },+ CurlWebSocketSend { flags, data },Flight::Data {count: end - message.offset,last,@@ -263,7 +303,6 @@ impl Session {.get_or_insert_with(|| Instant::now() + CLOSE_TIMEOUT);return Some((CurlWebSocketSend {- token: 0,flags: WsFlags::CLOSE,data,},