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): separate native send admission and completion

ldm033108fcffd81
diff --git a/moli-curl/src/websocket.rs b/moli-curl/src/websocket.rs
index 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.rs
index 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.rs
index 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.rs
index 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,
},