From 14130cb05ef787a2282dcf5cafd5d2470ecc5505 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 15 Nov 2026 06:22:01 -0800 Subject: [PATCH 1/4] chore(quest): claim quest/m2/api-ack-one-primitive.md Quest-Claim: 79ebe9ce878ab3c7 From 609e5e1afa3d9dd0aa89e0ad64c172650e76805e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 15 Nov 2026 06:54:19 -0800 Subject: [PATCH 2/4] wip: the send-stream trait reports acknowledgment one way Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/coding/writer.rs | 319 +++++++++++++------ rs/moq-net/src/fuzz/session.rs | 22 +- rs/moq-net/src/ietf/publisher.rs | 12 - rs/moq-net/src/lite/test_transport.rs | 33 +- rs/moq-net/src/stats.rs | 14 + rs/moq-net/src/transport.rs | 29 -- rs/moq-net/src/transport/boxed.rs | 78 ++--- rs/moq-net/src/transport/memory.rs | 97 ++++-- rs/moq-net/src/transport/open.rs | 24 +- rs/moq-net/tests/integration/support/mock.rs | 18 +- rs/moq-tokio/src/quic/driver/send.rs | 79 ++--- rs/moq-tokio/src/quic/web/send.rs | 99 +++--- rs/moq-tokio/src/quic/web/session.rs | 62 ++-- rs/moq-uring/src/quic/driver/send.rs | 65 ++-- rs/moq-uring/src/quic/web/send.rs | 99 +++--- rs/moq-uring/src/transport/local.rs | 12 - rs/moq-uring/tests/integration/web.rs | 57 ++++ rs/qmux/src/session.rs | 28 +- rs/qmux/src/session/tests.rs | 93 ------ 19 files changed, 647 insertions(+), 593 deletions(-) diff --git a/rs/moq-net/src/coding/writer.rs b/rs/moq-net/src/coding/writer.rs index 2a9510da592..f802591d0ab 100644 --- a/rs/moq-net/src/coding/writer.rs +++ b/rs/moq-net/src/coding/writer.rs @@ -22,7 +22,7 @@ pub struct Writer { /// Bytes the stream took through this writer. written: u64, /// The payload this stream carries, billed as the transport delivers it. See [`Self::bill`]. - delivery: Option>, + delivery: Option>>, } impl Writer { @@ -45,7 +45,7 @@ impl Writer { /// track, so they count alike. pub(crate) fn bill(&mut self, meter: crate::stats::Meter) { if self.delivery.is_none() && meter.is_tracked() { - self.delivery = Some(Box::new(crate::stats::Delivery::new(meter))); + self.delivery = Some(Box::new(Billing::new(meter))); } } @@ -56,23 +56,29 @@ impl Writer { pub(crate) fn frame(&mut self, size: u64) { let start = self.written + (self.buffer.len() - self.flushed) as u64; if let Some(delivery) = &mut self.delivery { - delivery.frame(start, size); + delivery.delivery.frame(start, size); } } - /// Bill the payload the transport has delivered so far. - fn settle(&mut self) { + /// Mint an offset to ask the transport about once a write ends a frame, so a reset still + /// bills each frame acknowledged before it. + fn ask(&mut self) { if let (Some(delivery), Some(stream)) = (&mut self.delivery, &self.stream) { - settle(delivery, stream, self.written); + delivery.ask(stream, self.written, false); } } + /// Bill the payload the transport has delivered so far. + fn settle(&mut self) { + self.poll_settle(&kio::Waiter::noop()); + } + /// [`Self::settle`], then wake `waiter` once more of what the stream took is delivered, so /// a stream idle after its last frame still bills that frame as it lands. A serve loop /// calls this whenever it parks, since a write it just made may be waiting on delivery. pub(crate) fn poll_settle(&mut self, waiter: &kio::Waiter) { if let (Some(delivery), Some(stream)) = (&mut self.delivery, &self.stream) { - poll_settle(delivery, stream, self.written, waiter); + delivery.poll(stream, self.written, waiter); } } @@ -133,6 +139,7 @@ impl Writer { Ok(n) => { self.flushed += n; self.written += n as u64; + self.ask(); } Err(err) => { self.buffer.clear(); @@ -179,6 +186,7 @@ impl Writer { let written = ready!(self.stream.as_mut().unwrap().poll_write_buf(waiter, buf)) .map_err(|err| self.version.transport_error(err))?; self.written += written as u64; + self.ask(); Poll::Ready(Ok(written)) } @@ -331,42 +339,95 @@ impl Writer { } } -/// How much of the `written` bytes the transport delivered: what it reports, or what it took -/// when it cannot tell. -fn delivered(stream: &S, written: u64) -> u64 { - stream.delivered().unwrap_or(written).min(written) +/// A stream's payload billed as the transport acknowledges it, through offsets the writer asks +/// [`poll_acked`](crate::transport::poll::SendStream::poll_acked) about. +pub(crate) struct Billing { + delivery: crate::stats::Delivery, + ack: Ack, } -/// Bill what `stream` delivered of its `written` bytes. A stream with nothing waiting is not -/// asked, since the transport may lock to answer. -fn settle(delivery: &mut crate::stats::Delivery, stream: &S, written: u64) { - if delivery.waiting(written) { - delivery.deliver(delivered(stream, written)); - } +/// What a [`Billing`] learned from the transport about acknowledgments. +enum Ack { + /// Asking: the offsets minted and not yet acknowledged, oldest first, each with the bytes the + /// stream had taken through the writer when it was minted. + /// + /// An offset is minted once a write ends a frame, or at a park for the payload taken so far + /// when no offset is outstanding, so they never outnumber the frames waiting plus one. A reset + /// then bills every frame acknowledged before it. + Asking(std::collections::VecDeque<(O, u64)>), + /// The transport cannot see acknowledgments, so the bytes the stream took bill instead. + Unsupported, + /// The transport will acknowledge no more, as after a reset, so nothing more bills. + Ended, } -/// Bill what `stream` delivered of its `written` bytes, then register `waiter` for more while -/// a frame the stream took waits on delivery. A wake that brings nothing stops it, so a stream -/// that will deliver no more parks instead of spinning. -fn poll_settle( - delivery: &mut crate::stats::Delivery, - stream: &S, - written: u64, - waiter: &kio::Waiter, -) { - // Nothing waits, so nothing to ask the transport, which may lock to answer. - if !delivery.waiting(written) { - return; - } - let mut through = delivered(stream, written); - delivery.deliver(through); - while delivery.waiting(written) && stream.poll_delivered(waiter).is_ready() { - let now = delivered(stream, written); - if now <= through { - return; - } - through = now; - delivery.deliver(through); +impl Billing { + fn new(meter: crate::stats::Meter) -> Self { + Self { + delivery: crate::stats::Delivery::new(meter), + ack: Ack::Asking(Default::default()), + } + } + + /// Mint an offset at `written` if a frame ended since the newest one, or with `idle`, if + /// none is outstanding and payload waits. Returns whether it is the only one outstanding. + fn ask>(&mut self, stream: &S, written: u64, idle: bool) -> bool { + let Ack::Asking(asked) = &mut self.ack else { + return false; + }; + let ask = match asked.back() { + Some(&(_, after)) => self.delivery.ends_between(after, written), + None => match idle { + true => self.delivery.waiting(written), + false => self.delivery.ends_between(self.delivery.through(), written), + }, + }; + if ask { + asked.push_back((stream.offset(), written)); + } + ask && asked.len() == 1 + } + + /// Bill what `stream` acknowledged of its `written` bytes, and register `waiter` for the + /// oldest offset still waiting. + /// + /// The transport is asked nothing while no frame waits, since it may lock to answer. + fn poll>(&mut self, stream: &S, written: u64, waiter: &kio::Waiter) { + use crate::transport::poll::Acked; + + loop { + let asked = match &mut self.ack { + Ack::Asking(asked) => asked, + Ack::Unsupported => { + self.delivery.deliver(written); + return; + } + Ack::Ended => return, + }; + // The oldest first: a transport acknowledges a prefix, so the rest wait behind a + // pending one. + while let Some((offset, through)) = asked.front() { + match stream.poll_acked(waiter, offset) { + Poll::Pending => break, + Poll::Ready(Ok(Acked::Delivered)) => { + self.delivery.deliver(*through); + asked.pop_front(); + } + Poll::Ready(Ok(_)) => { + self.ack = Ack::Unsupported; + break; + } + Poll::Ready(Err(_)) => { + self.ack = Ack::Ended; + break; + } + } + } + // A new offset alone outstanding is polled, which registers the waiter on it. + if matches!(self.ack, Ack::Asking(_)) && !self.ask(stream, written, true) { + return; + } + } } } @@ -377,7 +438,7 @@ pub struct Closing { stream: Option, version: V, written: u64, - delivery: Option>, + delivery: Option>>, } impl Closing { @@ -387,7 +448,7 @@ impl Closing { return Poll::Ready(Ok(())); }; if let Some(delivery) = &mut self.delivery { - poll_settle(delivery, stream, self.written, waiter); + delivery.poll(stream, self.written, waiter); } let closed = ready!(stream.poll_closed(waiter)); self.settle(); @@ -398,7 +459,7 @@ impl Closing { impl Closing { fn settle(&mut self) { if let (Some(delivery), Some(stream)) = (&mut self.delivery, &self.stream) { - settle(delivery, stream, self.written); + delivery.poll(stream, self.written, &kio::Waiter::noop()); } } } @@ -438,7 +499,7 @@ impl Writer { impl Drop for Writer { fn drop(&mut self) { if let (Some(delivery), Some(stream)) = (&mut self.delivery, &self.stream) { - settle(delivery, stream, self.written); + delivery.poll(stream, self.written, &kio::Waiter::noop()); } if let Some(mut stream) = self.stream.take() { // Unlike the Quinn default, we abort the stream on drop. @@ -562,32 +623,64 @@ mod tests { ); } - /// A stream that takes every write, with a delivered prefix the test moves. It counts the - /// polls waiting on delivery, which stay pending. + /// A stream that takes every write, acknowledging a prefix the test moves, or that cannot + /// see acknowledgments. It counts the polls waiting on acknowledgment, which stay pending. #[derive(Clone, Default)] - struct Acked { - acked: std::sync::Arc, - waits: std::sync::Arc, + struct Acking(std::sync::Arc>); + + #[derive(Default)] + struct AckingState { + written: u64, + acked: u64, + unsupported: bool, + reset: bool, + waits: usize, } - impl Acked { + impl Acking { + fn unsupported() -> Self { + let stream = Self::default(); + stream.0.lock().unwrap().unsupported = true; + stream + } + fn ack(&self, through: u64) { - self.acked.store(through, std::sync::atomic::Ordering::Relaxed); + self.0.lock().unwrap().acked = through; } fn waits(&self) -> usize { - self.waits.swap(0, std::sync::atomic::Ordering::Relaxed) + std::mem::take(&mut self.0.lock().unwrap().waits) } } - impl crate::transport::poll::SendStream for Acked { + impl crate::transport::poll::SendStream for Acking { type Error = Stopped; type Group = crate::transport::poll::Ungrouped; - type Offset = (); - - fn offset(&self) -> Self::Offset {} + type Offset = u64; + + fn offset(&self) -> u64 { + self.0.lock().unwrap().written + } + + fn poll_acked( + &self, + _: &kio::Waiter, + offset: &u64, + ) -> Poll> { + let mut state = self.0.lock().unwrap(); + match () { + _ if state.unsupported => Poll::Ready(Ok(crate::transport::poll::Acked::Unsupported)), + _ if *offset <= state.acked => Poll::Ready(Ok(crate::transport::poll::Acked::Delivered)), + _ if state.reset => Poll::Ready(Err(Stopped(0))), + _ => { + state.waits += 1; + Poll::Pending + } + } + } fn poll_write(&mut self, _: &kio::Waiter, buf: &[u8]) -> Poll> { + self.0.lock().unwrap().written += buf.len() as u64; Poll::Ready(Ok(buf.len())) } @@ -601,79 +694,97 @@ mod tests { Ok(()) } - fn reset(&mut self, _: u32) {} + fn reset(&mut self, _: u32) { + self.0.lock().unwrap().reset = true; + } fn poll_closed(&self, _: &kio::Waiter) -> Poll> { Poll::Pending } + } - fn delivered(&self) -> Option { - Some(self.acked.load(std::sync::atomic::Ordering::Relaxed)) - } - - fn poll_delivered(&self, _: &kio::Waiter) -> Poll<()> { - self.waits.fetch_add(1, std::sync::atomic::Ordering::Relaxed); - Poll::Pending - } + /// The payload bytes and frames `registry` billed. + fn billed(registry: &crate::stats::Registry) -> (u64, u64) { + registry + .snapshot() + .traffic() + .into_iter() + .map(|(_, _, traffic)| (traffic.bytes, traffic.frames)) + .fold((0, 0), |(bytes, frames), (b, f)| (bytes + b, frames + f)) } - /// A frame's bytes bill as the transport delivers them, not as the stream takes them, - /// and the frame once its last byte is: a reset never bills what it discarded. A stream - /// waiting on its peer waits on delivery too, so its last frame bills as it lands. - #[test] - fn egress_bills_delivered_payload() { + /// A writer over `stream` that bills to a fresh registry, past a one-byte header. + fn billing(stream: &Acking) -> (Writer, crate::stats::Registry) { let registry = crate::stats::Registry::new(crate::stats::Config::new()); - let billed = || { - registry - .snapshot() - .traffic() - .into_iter() - .map(|(_, _, traffic)| (traffic.bytes, traffic.frames)) - .fold((0, 0), |(bytes, frames), (b, f)| (bytes + b, frames + f)) - }; - let stream = Acked::default(); let mut writer = Writer::new(stream.clone(), crate::lite::Version::Lite05); writer.bill(registry.publisher_meter(crate::Path::from_static("demo"), &crate::stats::Tier::default())); - let waiter = &kio::Waiter::noop(); - - // A one-byte header, then two 100-byte frames, each behind a two-byte size. writer.buffer_varint(0).unwrap(); - for _ in 0..2 { - writer.buffer_varint(100).unwrap(); - writer.frame(100); - writer.buffer_raw(&[b'x'; 100]); - } - assert!(writer.poll_flush(waiter).is_ready()); - assert!(writer.poll_closed(waiter).is_pending()); - assert_eq!(billed(), (0, 0), "the stream took it all, the transport delivered none"); - assert_eq!(stream.waits(), 1, "the wait for the peer waits on delivery too"); + (writer, registry) + } - // Into the first frame's size: none of its payload. - stream.ack(2); + /// Buffer and flush a frame of `size`, writing only its first `written` bytes of payload. + fn write_frame(writer: &mut Writer, size: u64, written: usize) { + writer.buffer_varint(size).unwrap(); + writer.frame(size); + writer.buffer_raw(&vec![b'x'; written]); + assert!(writer.poll_flush(&kio::Waiter::noop()).is_ready()); + } + + /// A frame bills once the transport acknowledges an offset past it, not as the stream takes + /// it: each write that ends a frame asks about its own offset, so a frame acknowledged before + /// a reset still bills, and nothing the reset discarded does. A park with nothing else to ask + /// about asks about a frame still being written, billing its acknowledged bytes. + #[test] + fn egress_bills_acknowledged_payload() { + let stream = Acking::default(); + let (mut writer, registry) = billing(&stream); + let waiter = &kio::Waiter::noop(); + + // The header, then two 100-byte frames, each behind a two-byte size, written apart. + write_frame(&mut writer, 100, 100); + write_frame(&mut writer, 100, 100); assert!(writer.poll_closed(waiter).is_pending()); - assert_eq!(billed(), (0, 0)); + assert_eq!(billed(®istry), (0, 0), "the stream took it all, the transport acknowledged none"); + assert_eq!(stream.waits(), 1, "the wait for the peer waits on acknowledgment too"); - // Through the first frame and half the second. - stream.ack(3 + 100 + 2 + 50); + // Into the second frame: the first bills, though both went out before the park. + stream.ack(1 + 102 + 50); assert!(writer.poll_closed(waiter).is_pending()); - assert_eq!(billed(), (150, 1)); + assert_eq!(billed(®istry), (100, 1)); // All of it: nothing is left to wait on. stream.waits(); - stream.ack(3 + 100 + 2 + 100); + stream.ack(1 + 2 * 102); assert!(writer.poll_closed(waiter).is_pending()); - assert_eq!(billed(), (200, 2)); + assert_eq!(billed(®istry), (200, 2)); assert_eq!(stream.waits(), 0); - // A reset bills what was delivered by then, and nothing after. - writer.buffer_varint(100).unwrap(); - writer.frame(100); - writer.buffer_raw(&[b'x'; 100]); + // Half of a frame, then a park, which asks about the half. + write_frame(&mut writer, 100, 50); + assert!(writer.poll_closed(waiter).is_pending()); + stream.ack(1 + 3 * 102); + assert!(writer.poll_closed(waiter).is_pending()); + assert_eq!(billed(®istry), (250, 2), "the acknowledged half bills, not the frame"); + + // A reset bills what was acknowledged by then, and nothing after. + writer.buffer_raw(&[b'x'; 50]); assert!(writer.poll_flush(waiter).is_ready()); - stream.ack(1 + 2 * (2 + 100) + 2 + 30); + write_frame(&mut writer, 100, 100); + stream.ack(1 + 3 * 102 + 50); writer.abort(&Error::Cancel); stream.ack(u64::MAX); - assert_eq!(billed(), (230, 2)); + assert_eq!(billed(®istry), (300, 3)); + } + + /// A transport that cannot see acknowledgments bills the bytes the stream took. + #[test] + fn egress_bills_taken_payload_without_acknowledgments() { + let stream = Acking::unsupported(); + let (mut writer, registry) = billing(&stream); + write_frame(&mut writer, 100, 100); + write_frame(&mut writer, 100, 60); + writer.poll_settle(&kio::Waiter::noop()); + assert_eq!(billed(®istry), (160, 1)); } /// Writes some bytes, then errors: the shape of a partial encode. diff --git a/rs/moq-net/src/fuzz/session.rs b/rs/moq-net/src/fuzz/session.rs index 4323c626819..9101b61c457 100644 --- a/rs/moq-net/src/fuzz/session.rs +++ b/rs/moq-net/src/fuzz/session.rs @@ -979,9 +979,15 @@ impl Recorder { impl poll::SendStream for Recorded { type Error = memory::Error; type Group = poll::Ungrouped; - type Offset = (); + type Offset = u64; - fn offset(&self) -> Self::Offset {} + fn offset(&self) -> u64 { + self.inner.offset() + } + + fn poll_acked(&self, waiter: &kio::Waiter, offset: &u64) -> Poll> { + self.inner.poll_acked(waiter, offset) + } fn poll_write(&mut self, waiter: &kio::Waiter, buf: &[u8]) -> Poll> { let written = std::task::ready!(self.inner.poll_write(waiter, buf))?; @@ -1016,18 +1022,6 @@ impl poll::SendStream for Recorded { fn poll_closed(&self, waiter: &kio::Waiter) -> Poll> { self.inner.poll_closed(waiter) } - - fn acknowledged(&self) -> Option { - self.inner.acknowledged() - } - - fn delivered(&self) -> Option { - self.inner.delivered() - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - self.inner.poll_delivered(waiter) - } } impl poll::RecvStream for Recorded { diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 4bafca066a2..e62d9bcc764 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -7380,18 +7380,6 @@ impl crate::transport::poll::SendStream f inner.follow(waiter); inner.stream.poll_closed(waiter) } - - fn acknowledged(&self) -> Option { - self.inner.lock().unwrap().stream.acknowledged() - } - - fn delivered(&self) -> Option { - self.inner.lock().unwrap().stream.delivered() - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - self.inner.lock().unwrap().stream.poll_delivered(waiter) - } } /// Write one group's frames in the negotiated draft's FETCH object layout. diff --git a/rs/moq-net/src/lite/test_transport.rs b/rs/moq-net/src/lite/test_transport.rs index b760ba051e7..4e3b2c0a60b 100644 --- a/rs/moq-net/src/lite/test_transport.rs +++ b/rs/moq-net/src/lite/test_transport.rs @@ -324,9 +324,24 @@ impl SinkSend { impl poll::SendStream for SinkSend { type Error = SinkError; type Group = SinkGroup; - type Offset = (); + type Offset = u64; - fn offset(&self) -> Self::Offset {} + fn offset(&self) -> u64 { + self.written + } + + /// Unsupported until the test acknowledges a prefix with [`Log::ack`]. + fn poll_acked(&self, waiter: &kio::Waiter, offset: &u64) -> Poll> { + let answer = |acked: Option| match acked { + None => Poll::Ready(poll::Acked::Unsupported), + Some(acked) if acked >= *offset => Poll::Ready(poll::Acked::Delivered), + Some(_) => Poll::Pending, + }; + match self.log.acked.poll(waiter, |acked| answer(**acked).map(drop)) { + Poll::Ready(acked) => answer(*acked).map(Ok), + Poll::Pending => Poll::Pending, + } + } fn poll_write(&mut self, waiter: &kio::Waiter, buf: &[u8]) -> Poll> { if self.log.writes_fail.load(Ordering::Relaxed) { @@ -414,20 +429,6 @@ impl poll::SendStream for SinkSend { false => Poll::Pending, } } - - fn delivered(&self) -> Option { - self.log.acked.read().map(|acked| acked.min(self.written)) - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - self.log - .acked - .poll(waiter, |acked| match **acked { - Some(acked) if acked >= self.written => Poll::Ready(()), - _ => Poll::Pending, - }) - .map(drop) - } } /// A peer that never speaks and never closes, so a test only ever acts on diff --git a/rs/moq-net/src/stats.rs b/rs/moq-net/src/stats.rs index 4f74ace8d3f..78da46c4467 100644 --- a/rs/moq-net/src/stats.rs +++ b/rs/moq-net/src/stats.rs @@ -2137,6 +2137,20 @@ impl Delivery { !self.frames.is_empty() && self.through < written } + /// The stream offset billed through. + pub(crate) fn through(&self) -> u64 { + self.through + } + + /// Whether a frame waiting on delivery ends after stream offset `after`, at or before `through`. + pub(crate) fn ends_between(&self, after: u64, through: u64) -> bool { + self.frames + .iter() + .rev() + .find(|&&(_, end)| end <= through) + .is_some_and(|&(_, end)| end > after) + } + /// Bill the payload before stream offset `through`, which never goes back. pub(crate) fn deliver(&mut self, through: u64) { if through <= self.through { diff --git a/rs/moq-net/src/transport.rs b/rs/moq-net/src/transport.rs index e01aa853eb1..b1e05f2edba 100644 --- a/rs/moq-net/src/transport.rs +++ b/rs/moq-net/src/transport.rs @@ -807,35 +807,6 @@ pub mod poll { /// resolves once the FIN is sent. fn poll_closed(&self, waiter: &kio::Waiter) -> Poll>; - /// Whether the peer has acknowledged every byte written so far, or `None` when the - /// transport cannot tell, as a browser's WebTransport cannot. - /// - /// A transport answers for all of its streams or for none. A stream that was reset, or - /// that the peer stopped, is never acknowledged. - fn acknowledged(&self) -> Option { - None - } - - /// How many leading bytes written to this stream the transport delivered, counting each - /// once however often it was retransmitted, or `None` when it cannot tell. - /// - /// Delivered means the peer acknowledged it, or on a reliable link such as qmux's, that - /// the link took it. It only grows while the stream lives; after a reset it may stop - /// answering. Egress stats bill a frame's bytes only once delivered, and fall back to the - /// bytes the stream took when this is `None`. - fn delivered(&self) -> Option { - None - } - - /// Resolves once the transport delivered every byte written so far, so a caller - /// tracking [`Self::delivered`] learns of progress without polling for it. It may - /// resolve without progress, and stays pending once nothing more will be delivered, as - /// after a reset. Never resolves by default. - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - let _ = waiter; - Poll::Pending - } - /// Write some of the buffer, returning how many bytes were accepted. fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self> { Write { diff --git a/rs/moq-net/src/transport/boxed.rs b/rs/moq-net/src/transport/boxed.rs index 82796aea831..24b14b9e24b 100644 --- a/rs/moq-net/src/transport/boxed.rs +++ b/rs/moq-net/src/transport/boxed.rs @@ -90,7 +90,7 @@ impl Session { /// The session's open group streams, the lowest ranked first. #[cfg(test)] - pub(crate) fn open_streams(&self) -> Vec { + pub(super) fn open_streams(&self) -> Vec<(open::Rank, Arc)> { self.opens.open_streams() } @@ -397,13 +397,21 @@ impl Listed { self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) } - /// The stream's rank, and whether the peer acknowledged everything written to it. - pub(super) fn read(&self) -> open::OpenStream { + /// Where the stream ranks now. + pub(super) fn rank(&self) -> open::Rank { let state = self.lock(); - open::OpenStream { - rank: open::Rank::new(state.group.as_ref().map(|group| group.read()), state.priority), - acknowledged: state.stream.acknowledged(), - } + open::Rank::new(state.group.as_ref().map(|group| group.read()), state.priority) + } + + /// Whether the peer acknowledged everything written to it, never assumed when the transport + /// cannot tell. + pub(super) fn acknowledged(&self) -> bool { + let state = self.lock(); + let offset = state.stream.offset(); + matches!( + state.stream.poll_acked(&kio::Waiter::noop(), &offset), + Poll::Ready(Ok(poll::Acked::Delivered)) + ) } /// Reset the stream to make room, failing its writer with the reset's code. @@ -605,9 +613,6 @@ trait ErasedSend: Send + Sync { fn finish(&mut self) -> Result<(), Error>; fn reset(&mut self, code: u32); fn poll_closed(&self, waiter: &kio::Waiter) -> Poll>; - fn acknowledged(&self) -> Option; - fn delivered(&self) -> Option; - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()>; fn offset(&self) -> Offset; fn poll_acked(&self, waiter: &kio::Waiter, offset: &Offset) -> Poll>; } @@ -787,18 +792,6 @@ impl + Send + Sync> poll::SendStream::poll_closed(self, waiter).map_err(Error::new) } - fn acknowledged(&self) -> Option { - poll::SendStream::acknowledged(self) - } - - fn delivered(&self) -> Option { - poll::SendStream::delivered(self) - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - poll::SendStream::poll_delivered(self, waiter) - } - fn offset(&self) -> Offset { Offset(Box::new(poll::SendStream::offset(self))) } @@ -1030,18 +1023,6 @@ impl poll::SendStream for SendStream { } } } - - fn acknowledged(&self) -> Option { - self.get().acknowledged() - } - - fn delivered(&self) -> Option { - self.get().delivered() - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - self.get().poll_delivered(waiter) - } } impl poll::RecvStream for RecvStream { @@ -1183,7 +1164,7 @@ mod test { } fn ranks(session: &Session) -> Vec { - session.open_streams().into_iter().map(|stream| stream.rank).collect() + session.open_streams().into_iter().map(|(rank, _)| rank).collect() } fn ungrouped(priority: i64) -> SendOptions<'static, Group> { @@ -1282,8 +1263,7 @@ mod test { )); assert!(poll::SendStream::poll_acked(&stream, &waiter, &five).is_pending()); - let (a, _b) = super::super::memory::pair(Default::default()); - let session = Session::new(a); + let session = Session::new(SinkSession::new(Default::default())); let listed = open_group(&session, ungrouped(0)); let offset = poll::SendStream::offset(&listed); assert!(matches!( @@ -1292,27 +1272,21 @@ mod test { )); } - /// A listed stream reports the peer acknowledging what was written to it, and a reset one - /// never is. + /// A listed stream reads as acknowledged once the peer has everything written to it. #[test] fn a_listed_stream_reports_its_acknowledgement() { let (a, b) = super::super::memory::pair(Default::default()); let session = Session::new(a); let mut stream = open_group(&session, ungrouped(0)); - let acknowledged = || session.open_streams()[0].acknowledged; - assert_eq!(acknowledged(), Some(true), "nothing written is all acknowledged"); + let acknowledged = || session.open_streams()[0].1.acknowledged(); + assert!(acknowledged(), "nothing written is all acknowledged"); let waiter = kio::Waiter::noop(); assert!(matches!( poll::SendStream::poll_write(&mut stream, &waiter, b"group"), Poll::Ready(Ok(5)) )); - assert_eq!(acknowledged(), Some(false)); - assert_eq!( - poll::SendStream::acknowledged(&stream), - Some(false), - "the writer reads the same" - ); + assert!(!acknowledged()); let Poll::Ready(Ok(mut recv)) = poll::Session::poll_accept_uni(&b, &waiter) else { panic!("the peer accepts the stream"); @@ -1321,10 +1295,7 @@ mod test { poll::RecvStream::poll_read_chunk(&mut recv, &waiter, 16), Poll::Ready(Ok(Some(_))) )); - assert_eq!(acknowledged(), Some(true)); - - poll::SendStream::reset(&mut stream, 1); - assert_eq!(poll::SendStream::acknowledged(&stream), Some(false)); + assert!(acknowledged()); } /// A grouped stream ranks by its group's current priority, and follows a move to another @@ -1341,13 +1312,12 @@ mod test { priority: 2, }, ); - let read = |session: &Session| session.open_streams()[0]; - let grouped = |session: &Session| match read(session).rank { + let grouped = |session: &Session| match session.open_streams()[0].0 { open::Rank::Grouped { group, stream, .. } => (group, stream), open::Rank::Ungrouped { .. } => panic!("the stream is in a group"), }; assert_eq!(grouped(&session), (1, 2)); - assert_eq!(read(&session).acknowledged, None); + assert!(!session.open_streams()[0].1.acknowledged()); poll::SendGroup::set_priority(&mut low, 3); assert_eq!(grouped(&session), (3, 2)); diff --git a/rs/moq-net/src/transport/memory.rs b/rs/moq-net/src/transport/memory.rs index e6ba814f325..b19bc5fbace 100644 --- a/rs/moq-net/src/transport/memory.rs +++ b/rs/moq-net/src/transport/memory.rs @@ -483,7 +483,9 @@ struct Channel { messages: VecDeque, /// The bytes in `messages`. queued: usize, - /// The bytes the reader took, which stand in for delivered ones. + /// The bytes the writer queued, which its offsets count. + written: u64, + /// The bytes the reader took, which stand in for acknowledged ones. taken: u64, /// How the channel closed, once it has. end: Option, @@ -544,6 +546,19 @@ impl Channel { self.finished = None; } + /// Whether the reader took every byte before `offset`, which stands in for an + /// acknowledgement, failing once a reset or stop means it never will. + fn acked(&self, offset: u64) -> Poll> { + if offset <= self.taken { + return Poll::Ready(Ok(poll::Acked::Delivered)); + } + match self.end { + Some(End::Reset(_)) => Poll::Ready(Err(Error::Closed)), + Some(End::Stop(code)) => Poll::Ready(Err(Error::Stopped(code))), + _ => Poll::Pending, + } + } + /// How the writer sees the channel close: reset, stopped, or finished and drained. fn sent(&self) -> Poll> { match self.end { @@ -571,9 +586,22 @@ pub struct SendStream { impl poll::SendStream for SendStream { type Error = Error; type Group = crate::transport::poll::Ungrouped; - type Offset = (); + type Offset = u64; - fn offset(&self) -> Self::Offset {} + fn offset(&self) -> u64 { + self.channel.lock().written + } + + /// Delivered once the reader took every byte before `offset`, which stands in for an + /// acknowledgement as it does for [`poll_closed`](poll::SendStream::poll_closed). + fn poll_acked(&self, waiter: &kio::Waiter, offset: &u64) -> Poll> { + // Check the close first, so bytes taken before it still count below. + let closed = poll_close(&self.close, waiter); + if let Poll::Ready(channel) = self.channel.poll(waiter, |channel| channel.acked(*offset).map(drop)) { + return channel.acked(*offset); + } + closed.map(Err) + } fn poll_write(&mut self, waiter: &kio::Waiter, buf: &[u8]) -> Poll> { let mut buf = buf; @@ -614,6 +642,7 @@ impl poll::SendStream for SendStream { lands: landing(self.latency), }); channel.queued += size; + channel.written += size as u64; Poll::Ready(Ok(size)) } @@ -669,31 +698,6 @@ impl poll::SendStream for SendStream { } closed.map(Err) } - - /// Whether the reader took every message written so far, which stands in for an - /// acknowledgement as it does for [`poll_closed`](poll::SendStream::poll_closed). - fn acknowledged(&self) -> Option { - let channel = self.channel.lock(); - // A reset on a closed session leaves the channel as it was, so only `done` records it. - let finished = matches!(channel.end, Some(End::Fin)) && channel.finished.is_none(); - let open = channel.end.is_none() && !self.done; - Some((open || finished) && channel.messages.is_empty()) - } - - /// The bytes the reader took, standing in for delivered ones as it does for - /// [`acknowledged`](poll::SendStream::acknowledged). - fn delivered(&self) -> Option { - Some(self.channel.lock().taken) - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - self.channel - .poll(waiter, |channel| match channel.queued { - 0 => Poll::Ready(()), - _ => Poll::Pending, - }) - .map(drop) - } } impl Drop for SendStream { @@ -1104,12 +1108,10 @@ mod tests { // closed the session now would beat its finish to the reader. send.finish().unwrap(); assert!(send.poll_closed(&noop()).is_pending()); - assert_eq!(send.acknowledged(), Some(false)); let start = kio::clock::now(); assert_eq!(landed(&mut recv).await, None); assert_eq!(start.elapsed(), LATENCY); assert!(ready(send.poll_closed(&noop())).is_ok()); - assert_eq!(send.acknowledged(), Some(true)); // A reader that stops before the finish lands leaves the writer finished. let (mut send, recv) = uni(&a, &b); @@ -1178,6 +1180,41 @@ mod tests { assert!(matches!(ready(send.poll_closed(&noop())), Err(Error::Stopped(0)))); } + /// An offset is acknowledged once the reader took every byte before it, and still is after a + /// reset; the rest fails once a reset or stop means the reader never will take it. + #[test] + fn an_offset_is_acknowledged_once_the_reader_takes_it() { + let acked = |send: &SendStream, offset: u64| send.poll_acked(&noop(), &offset); + let (a, b) = pair(Config::default()); + let (mut send, mut recv) = uni(&a, &b); + assert!(matches!(acked(&send, send.offset()), Poll::Ready(Ok(poll::Acked::Delivered)))); + + ready(write(&mut send, &Bytes::from_static(b"one"))).unwrap(); + let one = send.offset(); + ready(write(&mut send, &Bytes::from_static(b"two"))).unwrap(); + let two = send.offset(); + assert_eq!((one, two), (3, 6)); + assert!(acked(&send, one).is_pending()); + + // A waiter parked on the offset wakes once the reader takes the bytes. + let count = Arc::new(Count::default()); + let waiter = kio::Waiter::new(Waker::from(count.clone())); + assert!(send.poll_acked(&waiter, &one).is_pending()); + assert_eq!(text(read(&mut recv, 4)), "one"); + assert!(count.0.load(Ordering::Relaxed) > 0, "the read did not wake the writer"); + assert!(matches!(acked(&send, one), Poll::Ready(Ok(poll::Acked::Delivered)))); + assert!(acked(&send, two).is_pending()); + + send.reset(1); + assert!(matches!(acked(&send, one), Poll::Ready(Ok(poll::Acked::Delivered)))); + assert!(matches!(acked(&send, two), Poll::Ready(Err(Error::Closed)))); + + let (mut send, mut recv) = uni(&a, &b); + ready(write(&mut send, &Bytes::from_static(b"one"))).unwrap(); + recv.stop(3); + assert!(matches!(acked(&send, send.offset()), Poll::Ready(Err(Error::Stopped(3))))); + } + #[test] fn stop_fails_the_writer() { let (a, b) = pair(Config::default()); diff --git a/rs/moq-net/src/transport/open.rs b/rs/moq-net/src/transport/open.rs index 5ec51b512a2..25dd4402927 100644 --- a/rs/moq-net/src/transport/open.rs +++ b/rs/moq-net/src/transport/open.rs @@ -91,16 +91,6 @@ impl Rank { } } -/// One of a session's open group streams, as its list read it. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) struct OpenStream { - /// Where the stream ranks now. - pub rank: Rank, - /// Whether the peer has acknowledged every byte written to it, or `None` when the - /// transport cannot tell. - pub acknowledged: Option, -} - /// The group streams a session has open, keyed so each can leave. #[derive(Default)] struct Listing { @@ -138,8 +128,8 @@ impl Line { } let open = lines.open_streams(); let open_streams = open.len(); - let acknowledged = open.iter().filter(|stream| stream.acknowledged == Some(true)).count(); - let lowest = open.first().map(|stream| stream.rank); + let acknowledged = open.iter().filter(|(_, stream)| stream.acknowledged()).count(); + let lowest = open.first().map(|(rank, _)| *rank); tracing::debug!( open_streams, acknowledged, @@ -225,7 +215,7 @@ impl Lines { .collect(); let mut open: BTreeMap<(Rank, u64), _> = listed .into_iter() - .map(|(key, stream)| ((stream.read().rank, key), stream)) + .map(|(key, stream)| ((stream.rank(), key), stream)) .collect(); for rank in owed { // An open that cannot preempt the lowest stream finds no lower-priority group open, @@ -256,11 +246,11 @@ impl Lines { /// The session's open group streams, the lowest ranked first. /// /// A stream is open from when it opens until it is finished, reset, or dropped. - pub(crate) fn open_streams(&self) -> Vec { + pub(super) fn open_streams(&self) -> Vec<(Rank, Arc)> { // Read each stream outside the listing's lock, which its owner takes to leave. let streams: Vec<_> = self.listing().streams.values().filter_map(Weak::upgrade).collect(); - let mut open: Vec<_> = streams.iter().map(|stream| stream.read()).collect(); - open.sort_by_key(|stream| stream.rank); + let mut open: Vec<_> = streams.into_iter().map(|stream| (stream.rank(), stream)).collect(); + open.sort_by_key(|(rank, _)| *rank); open } @@ -541,7 +531,7 @@ mod tests { let options = |priority| SendOptions { group: None, priority }; let open = |open: &mut Open, priority| session.poll_open_group(open, &waiter, options(priority), 7); let ranks = |session: &boxed::Session| -> Vec { - session.open_streams().into_iter().map(|stream| stream.rank).collect() + session.open_streams().into_iter().map(|(rank, _)| rank).collect() }; let mut streams: Vec<_> = [2, 1] diff --git a/rs/moq-net/tests/integration/support/mock.rs b/rs/moq-net/tests/integration/support/mock.rs index 50f5523e97b..6852f917c14 100644 --- a/rs/moq-net/tests/integration/support/mock.rs +++ b/rs/moq-net/tests/integration/support/mock.rs @@ -214,9 +214,15 @@ impl MockSendStream { impl poll::SendStream for MockSendStream { type Error = memory::Error; type Group = poll::Ungrouped; - type Offset = (); + type Offset = u64; - fn offset(&self) -> Self::Offset {} + fn offset(&self) -> u64 { + self.inner.offset() + } + + fn poll_acked(&self, waiter: &kio::Waiter, offset: &u64) -> Poll> { + self.inner.poll_acked(waiter, offset) + } fn poll_write(&mut self, waiter: &kio::Waiter, buf: &[u8]) -> Poll> { if self.conn.hold_writes.load(Ordering::Relaxed) { @@ -281,14 +287,6 @@ impl poll::SendStream for MockSendStream { } self.inner.poll_closed(waiter) } - - fn delivered(&self) -> Option { - self.inner.delivered() - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - self.inner.poll_delivered(waiter) - } } impl Drop for MockSendStream { diff --git a/rs/moq-tokio/src/quic/driver/send.rs b/rs/moq-tokio/src/quic/driver/send.rs index aaccdbd8eab..07ad5cdf14d 100644 --- a/rs/moq-tokio/src/quic/driver/send.rs +++ b/rs/moq-tokio/src/quic/driver/send.rs @@ -161,13 +161,7 @@ impl Stream { /// The offset just past the data written so far pub fn offset(&self) -> Offset { - let stream = &self.half.stream; - let mut conn = stream.conn.state.lock(); - Offset { - inner: conn.inner.send_stream(stream.id).offset(), - conn: stream.conn.stable_id(), - id: stream.id, - } + self.half.offset() } /// Reset at `offset` with `code`, instead of at 0 with code 0, if dropped before `finish` @@ -195,23 +189,21 @@ impl Stream { self.half.priority() } - /// Whether the peer acknowledged every byte written so far - #[cfg(feature = "quic")] - pub(crate) fn acknowledged(&self) -> bool { - self.half.acknowledged() - } - /// How many leading bytes the peer acknowledged #[cfg(feature = "quic")] pub(crate) fn acked_len(&self) -> u64 { self.half.acked_len() } - /// Wait for the peer to acknowledge every byte written so far; pending forever once it - /// never will + /// Wait for the peer to acknowledge every byte before `offset` + /// + /// Fails with the peer's stop code once it stopped the stream, or the connection's loss. + /// + /// # Panics + /// - when `offset` came from another stream #[cfg(feature = "quic")] - pub(crate) fn poll_all_acked(&self, waiter: &kio::Waiter) -> Poll<()> { - self.half.poll_all_acked(waiter) + pub(crate) fn poll_acked(&self, waiter: &kio::Waiter, offset: Offset) -> Poll> { + self.half.poll_acked(waiter, offset) } /// Move the stream into a send group, or with `None` back to the ungrouped streams, which @@ -266,10 +258,10 @@ impl Finished { self.half.priority() } - /// Whether the peer acknowledged every byte written. See [`Stream::acknowledged()`]. + /// The offset just past the data written. See [`Stream::offset()`]. #[cfg(feature = "quic")] - pub(crate) fn acknowledged(&self) -> bool { - self.half.acknowledged() + pub(crate) fn offset(&self) -> Offset { + self.half.offset() } /// How many leading bytes the peer acknowledged. See [`Stream::acked_len()`]. @@ -278,10 +270,13 @@ impl Finished { self.half.acked_len() } - /// Wait for every byte to be acknowledged. See [`Stream::poll_all_acked()`]. + /// Wait for the peer to acknowledge every byte before `offset`. See [`Stream::poll_acked()`]. + /// + /// # Panics + /// - when `offset` came from another stream #[cfg(feature = "quic")] - pub(crate) fn poll_all_acked(&self, waiter: &kio::Waiter) -> Poll<()> { - self.half.poll_all_acked(waiter) + pub(crate) fn poll_acked(&self, waiter: &kio::Waiter, offset: Offset) -> Poll> { + self.half.poll_acked(waiter, offset) } /// Move the stream into a send group. See [`Stream::set_group()`]. @@ -394,13 +389,13 @@ impl Half { conn.inner.send_stream(self.stream.id).priority().unwrap_or_default() } - /// Whether the peer acknowledged every byte written so far; never once reset or stopped. - #[cfg(feature = "quic")] - fn acknowledged(&self) -> bool { + fn offset(&self) -> Offset { let mut conn = self.stream.conn.state.lock(); - let mut stream = conn.inner.send_stream(self.stream.id); - let offset = stream.offset(); - stream.acked(offset).unwrap_or(false) + Offset { + inner: conn.inner.send_stream(self.stream.id).offset(), + conn: self.stream.conn.stable_id(), + id: self.stream.id, + } } /// How many leading bytes the peer acknowledged, each counted once. @@ -410,17 +405,29 @@ impl Half { conn.inner.send_stream(self.stream.id).acked_len() } - /// Wait for the peer to acknowledge every byte written so far; pending forever once it - /// never will, as after a reset or `STOP_SENDING`. + /// Wait for the peer to acknowledge every byte before `offset`. #[cfg(feature = "quic")] - fn poll_all_acked(&self, waiter: &kio::Waiter) -> Poll<()> { + fn poll_acked(&self, waiter: &kio::Waiter, offset: Offset) -> Poll> { + self.own(&offset); let mut conn = self.stream.conn.state.lock(); let mut stream = conn.inner.send_stream(self.stream.id); - let offset = stream.offset(); - match stream.poll_acked(waiter, offset) { - Poll::Ready(Ok(())) => Poll::Ready(()), - Poll::Ready(Err(_)) | Poll::Pending => Poll::Pending, + if ready!(stream.poll_acked(waiter, offset.inner)).is_ok() { + return Poll::Ready(Ok(())); } + // A held stream is never released, and a reset consumes its handle, so only the peer's + // stop or the connection's loss leaves its bytes unacknowledged. + let stopped = match stream.end() { + Ok(Some(End::Stopped(code))) => Some(code), + _ => None, + }; + let lost = conn.error(); + // Panicking under the lock would poison it for every handle. + drop(conn); + Poll::Ready(Err(match (stopped, lost) { + (Some(code), _) => Error::Stopped(code), + (None, Some(err)) => Error::Connection(err), + (None, None) => unreachable!("a held stream's acknowledgment failed while the connection lives"), + })) } fn set_group(&mut self, group: Option<&Group>) { diff --git a/rs/moq-tokio/src/quic/web/send.rs b/rs/moq-tokio/src/quic/web/send.rs index 6402acef3db..f76a809465f 100644 --- a/rs/moq-tokio/src/quic/web/send.rs +++ b/rs/moq-tokio/src/quic/web/send.rs @@ -31,13 +31,22 @@ pub struct Stream { unwritten: Bytes, /// The end of the WebTransport header once written, which a reset must still deliver. header: Option, - /// The stream's acknowledged prefix when it was reset, which drops the handle to it. - acked: u64, + /// Where the stream stood when it was reset, which drops the handle to it. + ended: Ended, id: crate::quic::driver::stream::Id, /// Holds the waiter of an [`AsyncWrite`](tokio::io::AsyncWrite) write across polls. park: kio::Park, } +/// Where a reset left a stream, which still answers for its acknowledgments. +#[derive(Debug, Clone, Copy)] +struct Ended { + /// The offset just past the data written. + offset: send::Offset, + /// How many leading bytes the peer acknowledged, header included. + acked: u64, +} + /// The mutable terminal state required by moq-net's poll trait. #[derive(Debug)] enum State { @@ -55,11 +64,14 @@ impl Stream { pub(crate) fn new(stream: send::Stream, close: Arc, header: Bytes) -> Self { let mut this = Self { id: stream.id(), + ended: Ended { + offset: stream.offset(), + acked: 0, + }, state: State::Open(stream), close, unwritten: header, header: None, - acked: 0, park: Default::default(), }; // Write the header now when it fits, so the peer can accept the stream before its @@ -95,15 +107,6 @@ impl Stream { } } - /// How many leading bytes the peer acknowledged, header included. - fn acked_len(&self) -> u64 { - match &self.state { - State::Open(stream) => stream.acked_len(), - State::Finished(stream) => stream.acked_len(), - State::Reset(_) | State::Unsent => self.acked, - } - } - fn open(&mut self) -> Result<&mut send::Stream, Error> { match &mut self.state { State::Open(stream) => Ok(stream), @@ -118,7 +121,17 @@ impl Stream { /// A WebTransport header already written still reaches the peer, so it can tell which /// session the reset belongs to. fn reset_mut(&mut self, code: u32) { - self.acked = self.acked_len(); + self.ended = match &self.state { + State::Open(stream) => Ended { + offset: stream.offset(), + acked: stream.acked_len(), + }, + State::Finished(stream) => Ended { + offset: stream.offset(), + acked: stream.acked_len(), + }, + State::Reset(_) | State::Unsent => return, + }; let code = self.close.encode_stream_code(code); // The driver task can process a STOP_SENDING at any moment. The reset settles, under the // connection lock, whether the peer's stop came first, and only a `closed` future taken @@ -315,9 +328,36 @@ impl tokio::io::AsyncWrite for Stream { impl moq_net::transport::poll::SendStream for Stream { type Error = Error; type Group = send::Group; - type Offset = (); + type Offset = send::Offset; - fn offset(&self) -> Self::Offset {} + /// Counts the WebTransport header, which the offsets of the bytes after it include. + fn offset(&self) -> send::Offset { + match &self.state { + State::Open(stream) => stream.offset(), + State::Finished(stream) => stream.offset(), + State::Reset(_) | State::Unsent => self.ended.offset, + } + } + + /// Once reset, answers from the prefix acknowledged by then, failing for the bytes after it. + fn poll_acked( + &self, + waiter: &kio::Waiter, + offset: &send::Offset, + ) -> Poll> { + let acked = match &self.state { + State::Open(stream) => stream.poll_acked(waiter, *offset), + State::Finished(stream) => stream.poll_acked(waiter, *offset), + State::Reset(_) | State::Unsent => match u64::from(*offset) <= self.ended.acked { + true => Poll::Ready(Ok(())), + false => return Poll::Ready(Err(Error::ClosedStream)), + }, + }; + match std::task::ready!(acked) { + Ok(()) => Poll::Ready(Ok(moq_net::transport::poll::Acked::Delivered)), + Err(err) => poll_error(&self.close, waiter, err).map(Err), + } + } fn poll_write(&mut self, waiter: &kio::Waiter, mut buf: &[u8]) -> Poll> { self.poll_write_buf(waiter, &mut buf) @@ -344,35 +384,6 @@ impl moq_net::transport::poll::SendStream for Stream { Err(err) => Err(err), }) } - fn acknowledged(&self) -> Option { - if self.unwritten.has_remaining() { - return Some(false); - } - Some(match &self.state { - State::Open(stream) => stream.acknowledged(), - State::Finished(stream) => stream.acknowledged(), - State::Reset(_) | State::Unsent => false, - }) - } - - /// The acknowledged bytes past the WebTransport header, none while the header is unwritten, - /// and once reset, those acknowledged by the reset. - fn delivered(&self) -> Option { - if self.unwritten.has_remaining() { - return Some(0); - } - Some(self.acked_len().saturating_sub(self.header.map_or(0, u64::from))) - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - match &self.state { - // The header goes first, and a write waits on it. - _ if self.unwritten.has_remaining() => Poll::Pending, - State::Open(stream) => stream.poll_all_acked(waiter), - State::Finished(stream) => stream.poll_all_acked(waiter), - State::Reset(_) | State::Unsent => Poll::Pending, - } - } } impl moq_net::transport::poll::SendGroup for send::Group { diff --git a/rs/moq-tokio/src/quic/web/session.rs b/rs/moq-tokio/src/quic/web/session.rs index 2d85be34499..87d1de1ba38 100644 --- a/rs/moq-tokio/src/quic/web/session.rs +++ b/rs/moq-tokio/src/quic/web/session.rs @@ -1319,13 +1319,14 @@ mod tests { } } - /// A stream reports the payload the peer acknowledged, past any WebTransport header, and - /// keeps reporting it after a reset drops its handle to the stream, whether the reset cut - /// an open stream or followed its acknowledged FIN. The acknowledgement alone wakes a - /// delivery waiter on a stream still open, with no FIN or further write. + /// An offset past the payload resolves once the peer acknowledges it, header and all, and the + /// acknowledgment alone wakes a waiter on a stream still open, with no FIN or further write. + /// A reset drops the handle to the stream but keeps that answer, whether it cut an open + /// stream or followed an acknowledged FIN, while bytes it cut before their acknowledgment + /// fail. #[tokio::test] - async fn delivered_counts_acknowledged_payload_through_a_reset() { - use moq_net::transport::poll::SendStream; + async fn an_offset_stays_acknowledged_through_a_reset() { + use moq_net::transport::poll::{Acked, SendStream}; for (framed, finish) in [false, true] .into_iter() @@ -1334,8 +1335,8 @@ mod tests { let (client, server, _endpoints) = pair().await; let (client, server) = sessions(framed, client, server).await; let mut send = client.open_uni(Default::default()).await.unwrap(); - assert_eq!(send.delivered(), Some(0), "framed: {framed}"); send.write_all(&b"payload"[..]).await.unwrap(); + let payload = SendStream::offset(&send); let recv = async { let mut recv = server.accept_uni().await.unwrap(); let mut read = Vec::new(); @@ -1344,26 +1345,43 @@ mod tests { } (recv, read) }; - let ((), (recv, read)) = tokio::join!(kio::wait(|waiter| send.poll_delivered(waiter)), recv); + let (acked, (recv, read)) = tokio::join!(kio::wait(|waiter| send.poll_acked(waiter, &payload)), recv); assert_eq!(read, b"payload", "framed: {framed}"); - assert_eq!(send.delivered(), Some(7), "framed: {framed}: delivered while open"); - - if finish { - SendStream::finish(&mut send).unwrap(); - let (closed, ()) = tokio::join!(kio::wait(|waiter| SendStream::poll_closed(&send, waiter)), async { - let mut recv = recv; - assert!(recv.read_chunk(usize::MAX).await.unwrap().is_none(), "framed: {framed}"); - }); - closed.unwrap(); - assert_eq!(send.delivered(), Some(7), "framed: {framed}"); - } + assert!(matches!(acked, Ok(Acked::Delivered)), "framed: {framed}: {acked:?}"); + + // The driver runs on this thread, so nothing acknowledges this before the reset. + let cut = match finish { + true => { + SendStream::finish(&mut send).unwrap(); + let (closed, ()) = + tokio::join!(kio::wait(|waiter| SendStream::poll_closed(&send, waiter)), async { + let mut recv = recv; + assert!(recv.read_chunk(usize::MAX).await.unwrap().is_none(), "framed: {framed}"); + }); + closed.unwrap(); + None + } + false => { + let written = SendStream::poll_write(&mut send, &Waiter::noop(), b"more"); + assert!(matches!(written, Poll::Ready(Ok(4))), "framed: {framed}"); + Some(SendStream::offset(&send)) + } + }; + let end = SendStream::offset(&send); SendStream::reset(&mut send, 1); - assert_eq!( - send.delivered(), - Some(7), + let acked = |offset| SendStream::poll_acked(&send, &Waiter::noop(), offset); + assert!( + matches!(acked(&payload), Poll::Ready(Ok(Acked::Delivered))), "framed: {framed}, finished: {finish}: the reset forgot it" ); + assert_eq!(SendStream::offset(&send), end, "framed: {framed}, finished: {finish}"); + if let Some(cut) = cut { + assert!( + matches!(acked(&cut), Poll::Ready(Err(_))), + "framed: {framed}: the reset cut it" + ); + } } } diff --git a/rs/moq-uring/src/quic/driver/send.rs b/rs/moq-uring/src/quic/driver/send.rs index 719ed197a68..5b1056aef11 100644 --- a/rs/moq-uring/src/quic/driver/send.rs +++ b/rs/moq-uring/src/quic/driver/send.rs @@ -127,7 +127,7 @@ impl Stream { /// The offset just past the data written so far. pub fn offset(&self) -> Offset { - self.0.shared.conn.borrow_mut().send_stream(self.0.id).offset() + self.0.offset() } /// Reset at `offset` with `code`, instead of at 0 with code 0, if dropped before `finish`. @@ -147,20 +147,19 @@ impl Stream { self.0.priority() } - /// Whether the peer acknowledged every byte written so far. - pub(crate) fn acknowledged(&self) -> bool { - self.0.acknowledged() - } - /// How many leading bytes the peer acknowledged. pub(crate) fn acked_len(&self) -> u64 { self.0.acked_len() } - /// Wait for the peer to acknowledge every byte written so far; pending forever once it - /// never will. - pub(crate) fn poll_all_acked(&self, waiter: &kio::Waiter) -> Poll<()> { - self.0.poll_all_acked(waiter) + /// Wait for the peer to acknowledge every byte before `offset`. + /// + /// Fails with the peer's stop code once it stopped the stream, or the connection's loss. + /// + /// # Panics + /// - when `offset` came from another stream + pub(crate) fn poll_acked(&self, waiter: &kio::Waiter, offset: Offset) -> Poll> { + self.0.poll_acked(waiter, offset) } /// Move the stream into a send group, or with `None` back to the ungrouped streams, which @@ -208,9 +207,9 @@ impl Finished { self.0.priority() } - /// Whether the peer acknowledged every byte written. See [`Stream::acknowledged()`]. - pub(crate) fn acknowledged(&self) -> bool { - self.0.acknowledged() + /// The offset just past the data written. See [`Stream::offset()`]. + pub(crate) fn offset(&self) -> Offset { + self.0.offset() } /// How many leading bytes the peer acknowledged. See [`Stream::acked_len()`]. @@ -218,9 +217,12 @@ impl Finished { self.0.acked_len() } - /// Wait for every byte to be acknowledged. See [`Stream::poll_all_acked()`]. - pub(crate) fn poll_all_acked(&self, waiter: &kio::Waiter) -> Poll<()> { - self.0.poll_all_acked(waiter) + /// Wait for the peer to acknowledge every byte before `offset`. See [`Stream::poll_acked()`]. + /// + /// # Panics + /// - when `offset` came from another stream + pub(crate) fn poll_acked(&self, waiter: &kio::Waiter, offset: Offset) -> Poll> { + self.0.poll_acked(waiter, offset) } /// Move the stream into a send group. See [`Stream::set_group()`]. @@ -293,12 +295,8 @@ impl Half { .unwrap_or_default() } - /// Whether the peer acknowledged every byte written so far; never once reset or stopped. - fn acknowledged(&self) -> bool { - let mut conn = self.shared.conn.borrow_mut(); - let mut stream = conn.send_stream(self.id); - let offset = stream.offset(); - stream.acked(offset).unwrap_or(false) + fn offset(&self) -> Offset { + self.shared.conn.borrow_mut().send_stream(self.id).offset() } /// How many leading bytes the peer acknowledged, each counted once. @@ -306,16 +304,25 @@ impl Half { self.shared.conn.borrow_mut().send_stream(self.id).acked_len() } - /// Wait for the peer to acknowledge every byte written so far; pending forever once it - /// never will, as after a reset or `STOP_SENDING`. - fn poll_all_acked(&self, waiter: &kio::Waiter) -> Poll<()> { + /// Wait for the peer to acknowledge every byte before `offset`. + fn poll_acked(&self, waiter: &kio::Waiter, offset: Offset) -> Poll> { let mut conn = self.shared.conn.borrow_mut(); let mut stream = conn.send_stream(self.id); - let offset = stream.offset(); - match stream.poll_acked(waiter, offset) { - Poll::Ready(Ok(())) => Poll::Ready(()), - Poll::Ready(Err(_)) | Poll::Pending => Poll::Pending, + if ready!(stream.poll_acked(waiter, offset)).is_ok() { + return Poll::Ready(Ok(())); } + // A held stream is never released, and a reset consumes its handle, so only the peer's + // stop or the connection's loss leaves its bytes unacknowledged. + let stopped = match stream.end() { + Ok(Some(End::Stopped(code))) => Some(code), + _ => None, + }; + drop(conn); + Poll::Ready(Err(match (stopped, self.shared.closed()) { + (Some(code), _) => Error::Stopped(code), + (None, Some(err)) => Error::Connection(err), + (None, None) => unreachable!("a held stream's acknowledgment failed while the connection lives"), + })) } fn set_group(&mut self, group: Option<&Group>) { diff --git a/rs/moq-uring/src/quic/web/send.rs b/rs/moq-uring/src/quic/web/send.rs index 881627e6e6c..4b4c5ca9d9c 100644 --- a/rs/moq-uring/src/quic/web/send.rs +++ b/rs/moq-uring/src/quic/web/send.rs @@ -29,11 +29,20 @@ pub struct Stream { unwritten: Bytes, /// The end of the WebTransport header once written, which a reset must still deliver. header: Option, - /// The stream's acknowledged prefix when it was reset, which drops the handle to it. - acked: u64, + /// Where the stream stood when it was reset, which drops the handle to it. + ended: Ended, id: crate::quic::stream::Id, } +/// Where a reset left a stream, which still answers for its acknowledgments. +#[derive(Debug, Clone, Copy)] +struct Ended { + /// The offset just past the data written. + offset: send::Offset, + /// How many leading bytes the peer acknowledged, header included. + acked: u64, +} + /// The mutable terminal state required by moq-net's poll trait. #[derive(Debug)] enum State { @@ -51,11 +60,14 @@ impl Stream { pub(super) fn new(stream: send::Stream, close: &Rc, header: Bytes) -> Self { let mut this = Self { id: stream.id(), + ended: Ended { + offset: stream.offset(), + acked: 0, + }, state: State::Open(stream), close: close.clone(), unwritten: header, header: None, - acked: 0, }; // Write the header now when it fits, so the peer can accept the stream before its // first data. Whatever does not fit waits for that data; a failure resurfaces there. @@ -63,15 +75,6 @@ impl Stream { this } - /// How many leading bytes the peer acknowledged, header included. - fn acked_len(&self) -> u64 { - match &self.state { - State::Open(stream) => stream.acked_len(), - State::Finished(stream) => stream.acked_len(), - State::Reset(_) | State::Unsent => self.acked, - } - } - fn open(&mut self) -> Result<&mut send::Stream, Error> { match &mut self.state { State::Open(stream) => Ok(stream), @@ -86,7 +89,17 @@ impl Stream { /// A WebTransport header already written still reaches the peer, so it can tell which /// session the reset belongs to. fn reset_mut(&mut self, code: u32) { - self.acked = self.acked_len(); + self.ended = match &self.state { + State::Open(stream) => Ended { + offset: stream.offset(), + acked: stream.acked_len(), + }, + State::Finished(stream) => Ended { + offset: stream.offset(), + acked: stream.acked_len(), + }, + State::Reset(_) | State::Unsent => return, + }; let code = self.close.encode_stream_code(code); // The connection is driven on this thread, so no STOP_SENDING lands between this check // and the reset: what the stream reports now is what the reset settles. @@ -284,9 +297,36 @@ impl Drop for Stream { impl moq_net::transport::poll::SendStream for Stream { type Error = Error; type Group = send::Group; - type Offset = (); + type Offset = send::Offset; + + /// Counts the WebTransport header, which the offsets of the bytes after it include. + fn offset(&self) -> send::Offset { + match &self.state { + State::Open(stream) => stream.offset(), + State::Finished(stream) => stream.offset(), + State::Reset(_) | State::Unsent => self.ended.offset, + } + } - fn offset(&self) -> Self::Offset {} + /// Once reset, answers from the prefix acknowledged by then, failing for the bytes after it. + fn poll_acked( + &self, + waiter: &kio::Waiter, + offset: &send::Offset, + ) -> Poll> { + let acked = match &self.state { + State::Open(stream) => stream.poll_acked(waiter, *offset), + State::Finished(stream) => stream.poll_acked(waiter, *offset), + State::Reset(_) | State::Unsent => match u64::from(*offset) <= self.ended.acked { + true => Poll::Ready(Ok(())), + false => return Poll::Ready(Err(Error::ClosedStream)), + }, + }; + match std::task::ready!(acked) { + Ok(()) => Poll::Ready(Ok(moq_net::transport::poll::Acked::Delivered)), + Err(err) => poll_error(&self.close, waiter, err).map(Err), + } + } fn poll_write(&mut self, waiter: &kio::Waiter, mut buf: &[u8]) -> Poll> { self.poll_write_buf(waiter, &mut buf) @@ -313,35 +353,6 @@ impl moq_net::transport::poll::SendStream for Stream { Err(err) => Err(err), }) } - fn acknowledged(&self) -> Option { - if self.unwritten.has_remaining() { - return Some(false); - } - Some(match &self.state { - State::Open(stream) => stream.acknowledged(), - State::Finished(stream) => stream.acknowledged(), - State::Reset(_) | State::Unsent => false, - }) - } - - /// The acknowledged bytes past the WebTransport header, none while the header is unwritten, - /// and once reset, those acknowledged by the reset. - fn delivered(&self) -> Option { - if self.unwritten.has_remaining() { - return Some(0); - } - Some(self.acked_len().saturating_sub(self.header.map_or(0, u64::from))) - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - match &self.state { - // The header goes first, and a write waits on it. - _ if self.unwritten.has_remaining() => Poll::Pending, - State::Open(stream) => stream.poll_all_acked(waiter), - State::Finished(stream) => stream.poll_all_acked(waiter), - State::Reset(_) | State::Unsent => Poll::Pending, - } - } } impl moq_net::transport::poll::SendGroup for send::Group { diff --git a/rs/moq-uring/src/transport/local.rs b/rs/moq-uring/src/transport/local.rs index 0b2d247f00e..26e668cde95 100644 --- a/rs/moq-uring/src/transport/local.rs +++ b/rs/moq-uring/src/transport/local.rs @@ -163,18 +163,6 @@ impl poll::SendStream for Local { fn poll_closed(&self, waiter: &kio::Waiter) -> Poll> { self.0.poll_closed(waiter) } - - fn acknowledged(&self) -> Option { - self.0.acknowledged() - } - - fn delivered(&self) -> Option { - self.0.delivered() - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - self.0.poll_delivered(waiter) - } } impl poll::RecvStream for Local { diff --git a/rs/moq-uring/tests/integration/web.rs b/rs/moq-uring/tests/integration/web.rs index eecb6691a62..15f9329942f 100644 --- a/rs/moq-uring/tests/integration/web.rs +++ b/rs/moq-uring/tests/integration/web.rs @@ -284,6 +284,63 @@ fn a_clean_finish_closes_a_stream() { client.join().expect("client thread"); } +/// An offset past the payload resolves once the peer acknowledges it, header and all. A reset +/// drops the handle to the stream but keeps that answer, while bytes it cut before their +/// acknowledgment fail. +#[test] +fn an_offset_stays_acknowledged_through_a_reset() { + use moq_net::transport::poll::{Acked, SendStream}; + + let Some(mut worker) = worker() else { return }; + let handle = worker.handle(); + let certs = support::certs().expect("certificates"); + let endpoint = h3_endpoint(&handle, &certs); + let client = tokio_client(format!("https://{}/acked", endpoint.local_addr()), |session| { + Box::pin(async move { + let mut recv = session.accept_uni().await.expect("accept uni"); + let mut read = Vec::new(); + let mut buf = [0u8; 4096]; + while read.len() < PAYLOAD.len() { + let n = recv.read(&mut &mut buf[..]).await.expect("read").expect("data"); + read.extend_from_slice(&buf[..n]); + } + assert_eq!(read, PAYLOAD); + session.closed().await; + }) + }); + worker + .block_on(async move { + let conn = endpoint.accept().await.expect("accept"); + let request = quic::web::Request::accept(conn).await.expect("handshake"); + let session = request + .respond(web_transport_proto::ConnectResponse::OK.with_protocol(PROTO)) + .await + .expect("respond"); + let mut send = kio::wait(|waiter| session.poll_open_uni(waiter, Default::default())) + .await + .expect("open uni"); + send.write_all(PAYLOAD).await.expect("write"); + let payload = SendStream::offset(&send); + let acked = within(&handle, "the ACK", kio::wait(|waiter| send.poll_acked(waiter, &payload))).await; + assert!(matches!(acked, Ok(Acked::Delivered)), "{acked:?}"); + + // The connection is driven on this thread, so nothing acknowledges this before the reset. + let written = SendStream::poll_write(&mut send, &kio::Waiter::noop(), b"more"); + assert!(matches!(written, Poll::Ready(Ok(4))), "{written:?}"); + let cut = SendStream::offset(&send); + SendStream::reset(&mut send, 1); + let acked = |offset| SendStream::poll_acked(&send, &kio::Waiter::noop(), offset); + assert!(matches!(acked(&payload), Poll::Ready(Ok(Acked::Delivered))), "the reset forgot it"); + assert!(matches!(acked(&cut), Poll::Ready(Err(_))), "the reset cut it"); + assert_eq!(SendStream::offset(&send), cut); + + session.close(0, "done"); + kio::wait(|waiter| session.poll_closed(waiter)).await; + }) + .expect("worker"); + client.join().expect("client thread"); +} + /// Out of the peer's connection window, an open still returns its stream at once and the /// stream's header waits for room with its data, so an open waits only for stream credit. #[test] diff --git a/rs/qmux/src/session.rs b/rs/qmux/src/session.rs index 79b6f303fb9..a5baba7a1bb 100644 --- a/rs/qmux/src/session.rs +++ b/rs/qmux/src/session.rs @@ -529,6 +529,7 @@ impl SendStream { impl poll::SendStream for SendStream { type Error = Error; type Group = SendGroup; + // Writing into TCP is not delivery, so acknowledgments stay unsupported. type Offset = (); fn offset(&self) -> Self::Offset {} @@ -599,33 +600,6 @@ impl poll::SendStream for SendStream { Err(_) => Poll::Ready(Err(Error::StreamClosed)), } } - - /// Whether every byte written so far went to the transport, which acknowledges it on a - /// reliable transport. - fn acknowledged(&self) -> Option { - if self.end == SendEnd::Reset { - return Some(false); - } - let mut state = self.inner.lock(); - let mut stream = state.conn.send_stream(self.id); - let offset = stream.offset(); - Some(stream.acked(offset).unwrap_or(false)) - } - - /// The bytes the transport took, which a reliable transport delivers. - fn delivered(&self) -> Option { - Some(self.inner.lock().conn.send_stream(self.id).acked_len()) - } - - fn poll_delivered(&self, waiter: &kio::Waiter) -> Poll<()> { - let mut state = self.inner.lock(); - let mut stream = state.conn.send_stream(self.id); - let offset = stream.offset(); - match stream.poll_acked(waiter, offset) { - Poll::Ready(Ok(())) => Poll::Ready(()), - Poll::Ready(Err(_)) | Poll::Pending => Poll::Pending, - } - } } impl Drop for SendStream { diff --git a/rs/qmux/src/session/tests.rs b/rs/qmux/src/session/tests.rs index 73cd05434d0..baba75632b0 100644 --- a/rs/qmux/src/session/tests.rs +++ b/rs/qmux/src/session/tests.rs @@ -1,8 +1,6 @@ //! Session tests over an in-memory byte stream, on paused tokio time. use std::pin::Pin; -use std::sync::Arc; -use std::sync::atomic::{AtomicBool, Ordering}; use std::time::Duration; use bytes::{Bytes, BytesMut}; @@ -161,97 +159,6 @@ async fn reading_returns_flow_control_credit() { } } -/// A stream's bytes count as acknowledged once they go to the transport, which a stalled link -/// holds back; a reset stream never is. -#[tokio::test(start_paused = true)] -async fn a_stream_is_acknowledged_once_its_bytes_go_out() { - for &version in Version::ALL { - let (client, server, up, _down) = link(); - let (client, server) = establish(client, server, config(version), config(version)).await; - - let mut send = client.open_uni(SendOptions::default()).await.unwrap(); - assert_eq!(send.acknowledged(), Some(true), "{version:?}: nothing written"); - up.send(Flow::Stall).unwrap(); - // More than the pipe holds, within the peer's stream window. - let data = payload(2 * PIPE, 5); - write_all(&mut send, data.clone()).await; - assert_eq!(send.acknowledged(), Some(false), "{version:?}: the link holds the rest"); - - up.send(Flow::Open).unwrap(); - let mut recv = server.accept_uni().await.unwrap(); - assert_eq!(read_exact(&mut recv, data.len()).await.unwrap(), data, "{version:?}"); - assert_eq!(send.acknowledged(), Some(true), "{version:?}: all of it went out"); - - send.reset(1); - assert_eq!(send.acknowledged(), Some(false), "{version:?}"); - } -} - -/// A byte stream whose room the test can close, as a peer that stops reading does once the -/// buffers between fill. A closed one never wakes the driver for room again. -struct Gate { - inner: Stream, - full: Arc, -} - -impl Transport for Gate { - fn bind(&mut self, config: &Config) { - self.inner.bind(config); - } - - fn poll_recv(&mut self, waiter: &kio::Waiter) -> Poll> { - self.inner.poll_recv(waiter) - } - - fn poll_ready(&mut self, waiter: &kio::Waiter) -> Poll> { - match self.full.load(Ordering::Relaxed) { - true => Poll::Pending, - false => self.inner.poll_ready(waiter), - } - } - - fn send(&mut self, record: Bytes) -> Result<(), Error> { - self.inner.send(record) - } - - fn poll_flush(&mut self, waiter: &kio::Waiter) -> Poll> { - self.inner.poll_flush(waiter) - } - - fn poll_close(&mut self, waiter: &kio::Waiter) -> Poll> { - self.inner.poll_close(waiter) - } -} - -/// A stream's bytes count as delivered once the transport takes them, and never while the -/// transport has no room for them. -#[tokio::test(start_paused = true)] -async fn delivery_counts_only_what_the_transport_took() { - for &version in Version::ALL { - let (client, server) = tokio::io::duplex(PIPE); - let full = Arc::new(AtomicBool::new(false)); - let client = Gate { - inner: Stream::new(client), - full: full.clone(), - }; - let (client, server) = tokio::join!( - Session::connect(client, config(version)), - Session::accept(Stream::new(server), config(version)) - ); - let (client, _server) = (spawn(client.unwrap()), spawn(server.unwrap())); - - let mut send = client.open_uni(SendOptions::default()).await.unwrap(); - write_all(&mut send, payload(1000, 6)).await; - kio::clock::sleep(Duration::from_millis(100)).await; - assert_eq!(send.delivered(), Some(1000), "{version:?}: the transport took it"); - - full.store(true, Ordering::Relaxed); - write_all(&mut send, payload(PIPE, 7)).await; - kio::clock::sleep(Duration::from_millis(100)).await; - assert_eq!(send.delivered(), Some(1000), "{version:?}: the transport had no room"); - } -} - /// Lease `want` bytes, returning how many were leased and handing them back unread, so they /// keep their credit. async fn lease(recv: &mut RecvStream, want: usize) -> Result { From 86dc9bd0aaab407323fc253fd1146a7b35ca4209 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 15 Nov 2026 07:34:20 -0800 Subject: [PATCH 3/4] fix(moq-net): billing asks the transport per frame end; quests updated Co-Authored-By: Claude Opus 5.5 --- quest/m2/api-ack-one-primitive.md | 56 ---------- quest/m3/qos/lag-histogram.md | 12 +- quest/m3/quic-ack-hook.md | 151 ++++++++------------------ rs/moq-net/src/coding/writer.rs | 59 ++++++---- rs/moq-net/src/stats.rs | 10 +- rs/moq-net/src/transport/memory.rs | 10 +- rs/moq-uring/tests/integration/web.rs | 12 +- 7 files changed, 112 insertions(+), 198 deletions(-) delete mode 100644 quest/m2/api-ack-one-primitive.md diff --git a/quest/m2/api-ack-one-primitive.md b/quest/m2/api-ack-one-primitive.md deleted file mode 100644 index 8e0f143be3d..00000000000 --- a/quest/m2/api-ack-one-primitive.md +++ /dev/null @@ -1,56 +0,0 @@ -# [M] The send-stream trait reports acknowledgment one way - -## Goal - -`moq_net::transport::poll::SendStream` carries one acknowledgment primitive -when the cut freezes it: `Offset`, `offset()` and `poll_acked`. The trait is -public and unsealed, so each method that ships becomes one every out-of-tree -transport implements for good. - -- `acknowledged()` and `OpenStream::acknowledged` are gone. The debug log in - `rs/moq-net/src/transport/open.rs` that counts acknowledged open streams - asks `poll_acked` at each stream's current offset instead. -- `delivered()` and `poll_delivered()` are gone. Egress stats - (`stats::Delivery`, driven from `coding::writer`) bill a frame's bytes once - `poll_acked` reports an offset past them as delivered. When it reports - `Unsupported`, they bill the bytes the stream accepted from the writer, as the - writer's fallback does today. They stop billing once it errors. -- Egress over QUIC stays acknowledgment-based: moq-tokio's and moq-uring's - `quic::web` adapters implement `poll_acked` over their drivers before the - stats move, or QUIC egress silently falls back to bytes taken. - -## Plan - -Found by the pre-cut feature review -([moq-dev/moq#8764](https://github.com/moq-dev/moq/pull/8764)) against -[moq-dev/moq#8739](https://github.com/moq-dev/moq/pull/8739), which added -`offset`/`poll_acked` beside the two older shapes. Decided 2026-11-15 -(maintainer): land #8739 as it is and collapse the shapes here, keeping -`offset`/`poll_acked`. - -Decided 2026-11-15 (maintainer): qmux keeps reporting `Acked::Unsupported` -(writing into TCP is not delivery, as decided 2026-10-22 in -[quic-ack-hook](/quest/m3/quic-ack-hook.md)), so qmux egress falls back to the -bytes taken. That is the count the stream accepted from the writer, not what -qmux's `delivered()` reports today (what the link took). The two differ only -while the link is blocked and holds accepted bytes. Rejected: giving the hook -qmux's "the link took it" meaning. - -Guidance: - -- `Delivery` can keep one outstanding offset per stream rather than one per - frame: mint `offset()` at the bytes written when a frame waits, bill - through it once delivered, then mint the next. That bounds memory per - stream. The cost is that a reset can leave unbilled the bytes acknowledged - past the last offset asked about. Measure that against per-frame offsets - before picking. -- moq-quic's `send::Stream::poll_acked` is already public and handles the - reset and STOP_SENDING cases. The adapters forward the driver's offset, - which counts the WebTransport header, so no adjustment is needed. A web - stream that was reset no longer has a driver handle, so it keeps the offset - and the acknowledged prefix it had at the reset. -- The memory transport stands in for acknowledgment with the bytes its reader - took, and moq-net's tests bill against it, so it gets a real `u64` offset. -- This takes part of [quic-ack-hook](/quest/m3/quic-ack-hook.md)'s driver - half (the adapters' `poll_acked`). Update that quest to keep only the public - driver API and its trap tests. diff --git a/quest/m3/qos/lag-histogram.md b/quest/m3/qos/lag-histogram.md index 287f23da277..ae454e80d5d 100644 --- a/quest/m3/qos/lag-histogram.md +++ b/quest/m3/qos/lag-histogram.md @@ -32,7 +32,7 @@ Decided 2026-10-26 (maintainer, on #6791), each with its reason: behind, and every unsubscribe, rendition switch, or session close charges the open group's whole content to `dropped`, so a healthy audience with churn reads a dropped baseline. The frontier instead moves at every - acknowledged frame end through [poll_acked](/quest/m3/quic-ack-hook.md), so + acknowledged frame end through `poll_acked`, so the sampler reads a frontier at most one frame stale. `dropped` counts only the frames written after the newest acknowledged one. This folds in the frontier half of the former starvation-frames quest; a delivery-delay @@ -41,7 +41,10 @@ Decided 2026-10-26 (maintainer, on #6791), each with its reason: it writes, each frame end records its offset and timestamp, and one waiter per stream polls the oldest pending offset, interleaved with later writes so a lagging ACK never stalls sending, retiring every frame at or below what is - acknowledged. + acknowledged. Egress billing already does that: `coding::Writer`'s + `Billing` mints an offset whenever a write ends a frame and retires them + oldest first, so the frontier rides those offsets rather than minting its + own. - **No hook, no fields.** A subscription whose backend reports `poll_acked` unsupported (qmux, the browser transport) keeps no frontier and adds nothing to `lag` or `dropped`. A node serving only such viewers leaves both @@ -99,8 +102,3 @@ Update `doc/concept/stats.md` and the stats section of `doc/bin/relay/config.md`. Changed 2026-11-07 (maintainer, /quest-plan from the API sweep of open PRs and remaining quests): [moq-dev/moq#8266](https://github.com/moq-dev/moq/pull/8266) makes `stats::Registry::report` take `now` and the handle's arguments `#[non_exhaustive]` before the cut, so this adds fields and is not breaking. - -## Required - -- [poll_acked on moq-net's send stream](/quest/m3/quic-ack-hook.md) - the - per-frame acknowledgement the frontier moves on diff --git a/quest/m3/quic-ack-hook.md b/quest/m3/quic-ack-hook.md index 5efc741a9cf..d41acfa7b6c 100644 --- a/quest/m3/quic-ack-hook.md +++ b/quest/m3/quic-ack-hook.md @@ -1,52 +1,27 @@ -# [S] moq-net's send stream awaits an acknowledged offset +# [S] The QUIC drivers' acknowledgment wait is public and tested at its traps ## Goal -moq-net's own `transport::poll::SendStream` lets a sender await -acknowledgment of a named byte offset on a send stream, the moq-tokio and -moq-uring adapters implement it over `moq-quic`, and every other backend -reports that it cannot rather than returning a guess. +moq-tokio's and moq-uring's QUIC drivers let a caller await acknowledgment +of a minted `send::Offset` on `send::Stream` and `send::Finished`, publicly, +and each driver's tests cover the traps that wait has. ## Plan -Decided in the 2026-10-05 audit: re-planned on moq-net's own transport -traits. moq-net has no `web-transport-trait` dependency, so it could not -call a hook that exists only upstream. The method lives on -`rs/moq-net/src/transport.rs`'s `poll::SendStream`, implemented by the -moq-tokio and moq-uring adapters (moq-tokio's through `quic::web`); no -`web-transport-trait` release is needed. Rejected: keeping the method -upstream. This quest supersedes the design in moq-dev/web-transport#368, -whose snapshot-counter shape loses the -wakeups a latency sample needs. - -Decided 2026-11-07 (maintainer, /quest-plan from the API sweep of open PRs -and remaining quests): no `Option<()>` outcome, and one offset type on both -layers. Add an offset type and two methods to `SendStream`, in the trait's -poll style: - -```rust -type Offset: 'static; -fn offset(&self) -> Self::Offset; -fn poll_acked(&self, waiter: &kio::Waiter, offset: &Self::Offset) -> Poll>; - -#[non_exhaustive] -pub enum Acked { Delivered, Unsupported } -``` - -It is ready with `Delivered` once every byte below `offset` has been acknowledged. -It carries no instant: the caller records one when woken, which includes the -peer's delayed-ACK timer (up to `max_ack_delay`) as well as the return trip. -Decided 2026-10-17 on #5817, which dropped `moq-quic`'s ACK-delay-corrected -instant until a consumer shows it matters. It resolves -with an error once the stream is reset by either side or the session closes, -so a waiter never hangs on bytes the peer will never acknowledge. The default -implementation is ready with `Ok(Acked::Unsupported)` immediately. A default -body cannot construct a backend's own `Self::Error`, so unsupported has to -live in the return type rather than the error, and a consumer must treat -`Unsupported` as unknown, never as delivered. - -Each QUIC driver, moq-tokio's `quic::driver` and moq-uring's, gets the hook -first, in the drivers' caller-owned waiter shape, +moq-net's half landed: `transport::poll::SendStream` carries `Offset`, +`offset()`, and `poll_acked` as its only acknowledgment primitive, and the +moq-tokio and moq-uring `quic::web` adapters implement it over crate-private +driver methods ([api-ack-one-primitive](https://github.com/moq-dev/moq/pull/8845)). +Those methods, `poll_acked` on `send::Stream` and `send::Finished` and +`Finished::offset`, forward to `moq-quic`'s public `send::Stream::poll_acked`. +They fail with the peer's stop code (`send::Error::Stopped`) or the +connection's loss (`send::Error::Connection`); a reset consumes the handle, so +no handle ever waits past one. qmux and the browser transport stay on the +trait's default `Acked::Unsupported` (decided 2026-10-22 and 2026-10-26, +maintainer): writing into TCP is not delivery, and the browser's +`WebTransportSendStream.getStats()` is unimplemented in shipping Chrome. + +What is left is making them public, in the drivers' caller-owned waiter shape with an async wrapper: ```rust @@ -56,72 +31,40 @@ impl send::Stream { } ``` -The same pair goes on `send::Finished`, the handle `finish(self)` returns -([moq-dev/moq#6950](https://github.com/moq-dev/moq/pull/6950)), and the methods take its opaque `send::Offset`, which only -`offset()` mints, instead of a `u64`. The `send::Error` says why the bytes will -never be acknowledged: a reset, the peer's STOP_SENDING, or the connection's -loss. Both drivers forward to `moq-quic`'s own `send::Stream::poll_acked` -wait, which replaced `StreamEvent::Acked`. That wait is `#[cfg(test)]` and -`pub(crate)` today (`rs/moq-quic/src/connection/streams/send.rs`), so the -first step makes it public in a normal build. Four traps, each settled in moq-quic where the wait -lives: +The same pair, and `offset()`, go on `send::Finished`. + +Traps to test through each driver: -- A finished stream whose every byte was acknowledged must not look like a - reset one. moq-quic answers from the queryable send-stream end - it keeps until the id is released: - finished, with no reset or STOP_SENDING, means delivered. -- An offset past the data written cannot be built, and a foreign one panics - before moq-tokio takes the connection lock, since a panic under the lock - poisons it for every handle. +- A finished stream whose every byte was acknowledged resolves as delivered. + moq-quic answers from the send-stream end it keeps until the id is + released: finished, with no STOP_SENDING, means delivered. +- An offset past the data written cannot be built, since only `offset()` + mints one, so it can only come from another stream: build it from a longer + stream and check it panics before the connection lock (moq-tokio's + `Half::poll_acked` checks it first), leaving other handles on the + connection usable, before and after finish. - `reset_at` below the acknowledged prefix, or STOP_SENDING after a reset - (which truncates to 0), shrinks the acknowledged prefix. The waiters fail - anyway; keep the prefix a `poll_acked` reports monotonic. -- The offset counts bytes on the QUIC stream, but nobody computes one: the - trait's `Offset` is the driver's minted `send::Offset`, and the lag - histogram's writer records `offset()` after each frame end instead of - counting the bytes it writes. A layer that writes its own prefix mints - offsets that already include it, so `quic::web` forwards the driver's - `Offset` and its WebTransport header needs no adjustment. A backend that - cannot see acknowledgments uses `type Offset = ()` and keeps the default - `poll_acked`. + (which truncates to 0), shrinks moq-quic's acknowledged prefix; keep the + prefix a wait reports monotonic. -The moq-tokio and moq-uring adapters implement the trait method over the -driver's. Leave the browser transport on the default; the browser's `WebTransportSendStream.getStats()` is -unimplemented in shipping Chrome and its `bytesAcknowledged` is at risk in the -W3C draft. Decided 2026-10-22 (maintainer): qmux's `poll_acked` reports -unsupported too, since writing into TCP is not delivery. Decided 2026-10-26 -(maintainer, on [moq-dev/moq#6791](https://github.com/moq-dev/moq/pull/6791)): -over qmux and the browser transport, the lag histogram, `dropped`, and the -delivery-delay histogram are absent, never zero; group granularity is -rejected as a fallback. +Also cover an offset acknowledged before the first poll, an offset in the +middle of an in-flight write, several waiters on one stream in offset order, +STOP_SENDING by the receiver, and the connection's loss. -Acceptance includes the first two traps, through each driver: a finished -stream whose bytes were all acknowledged resolves `poll_acked` as delivered, -while a reset one resolves it with the error. An offset past the data -written can only come from another stream, since only `offset()` mints one, -so that case is the foreign-offset trap: build it from a longer stream and -check it panics before the connection lock, leaving other handles on the -connection usable, before and after finish. +The wait carries no instant: a caller records one when woken, which includes +the peer's delayed-ACK timer (up to `max_ack_delay`) as well as the return +trip (decided 2026-10-17 on #5817). -Tests also cover: offset already acknowledged before the first poll, an -offset in the middle of an in-flight frame, several waiters on one stream in -offset order, reset by sender, STOP_SENDING by the receiver, and session -close. +## Waiting -Decided in the 2026-09-30 audit: moved to m2 with its consumers, the -[viewer lag histogram](/quest/m3/qos/lag-histogram.md) and a -delivery-delay histogram, whose plan was deleted on 2026-11-09. +- Maintainer: whether the drivers' wait goes public at all. Nothing in the + tree needs it public since moq-net reaches it through the adapters, and the + rules keep an API private until a consumer needs it. Options: (1) keep the + quest, if an out-of-tree driver user is expected to await + acknowledgments; (2) recommended: drop the public half and keep only the + trap tests, on the crate-private methods, resizing this quest to XS. -Split 2026-11-12 (maintainer, /quest-audit before the cut): the trait shape -(`Offset`, `offset()`, `Acked`, and a defaulted `poll_acked`) landed in m2, -because `poll::SendStream` is public and unsealed and the cut would freeze it. -As landed, `Offset` has no `Clone` or `Copy` bound and `poll_acked` takes it -by reference, since a caller retries the poll with the same offset anyway and -moq-net's boxed stream erases it behind a `Box` it only borrows from -(decided 2026-11-14, maintainer); a backend without acknowledgments uses -`type Offset = ()` rather than a byte count. Every in-tree backend, including -moq-tokio's and moq-uring's `quic::web`, is on `()` with the default. This -quest keeps the driver half: moq-quic's `poll_acked` leaves `#[cfg(test)]`, -and the moq-tokio and moq-uring adapters switch `Offset` to the driver's -`send::Offset` (which is `Copy`, so they pass `*offset`) and implement the hook. +## Related +- [Deadline-aware delivery](/quest/m4/quic-deadline.md) - the same pattern + for a moq-net method backed by `moq-quic` diff --git a/rs/moq-net/src/coding/writer.rs b/rs/moq-net/src/coding/writer.rs index f802591d0ab..9236294e349 100644 --- a/rs/moq-net/src/coding/writer.rs +++ b/rs/moq-net/src/coding/writer.rs @@ -22,7 +22,7 @@ pub struct Writer { /// Bytes the stream took through this writer. written: u64, /// The payload this stream carries, billed as the transport delivers it. See [`Self::bill`]. - delivery: Option>>, + billing: Option>>, } impl Writer { @@ -35,7 +35,7 @@ impl Writer { version, stats: Default::default(), written: 0, - delivery: None, + billing: None, } } @@ -44,8 +44,8 @@ impl Writer { /// A stream carrying several groups bills all of them to the first meter: a stream serves one /// track, so they count alike. pub(crate) fn bill(&mut self, meter: crate::stats::Meter) { - if self.delivery.is_none() && meter.is_tracked() { - self.delivery = Some(Box::new(Billing::new(meter))); + if self.billing.is_none() && meter.is_tracked() { + self.billing = Some(Box::new(Billing::new(meter))); } } @@ -55,16 +55,16 @@ impl Writer { /// serve loop's next park, close or drop bills what was delivered by then. pub(crate) fn frame(&mut self, size: u64) { let start = self.written + (self.buffer.len() - self.flushed) as u64; - if let Some(delivery) = &mut self.delivery { - delivery.delivery.frame(start, size); + if let Some(billing) = &mut self.billing { + billing.delivery.frame(start, size); } } /// Mint an offset to ask the transport about once a write ends a frame, so a reset still /// bills each frame acknowledged before it. fn ask(&mut self) { - if let (Some(delivery), Some(stream)) = (&mut self.delivery, &self.stream) { - delivery.ask(stream, self.written, false); + if let (Some(billing), Some(stream)) = (&mut self.billing, &self.stream) { + billing.ask(stream, self.written, false); } } @@ -77,8 +77,8 @@ impl Writer { /// a stream idle after its last frame still bills that frame as it lands. A serve loop /// calls this whenever it parks, since a write it just made may be waiting on delivery. pub(crate) fn poll_settle(&mut self, waiter: &kio::Waiter) { - if let (Some(delivery), Some(stream)) = (&mut self.delivery, &self.stream) { - delivery.poll(stream, self.written, waiter); + if let (Some(billing), Some(stream)) = (&mut self.billing, &self.stream) { + billing.poll(stream, self.written, waiter); } } @@ -286,7 +286,7 @@ impl Writer { stream, version, written: self.written, - delivery: self.delivery.take(), + billing: self.billing.take(), }) } @@ -334,14 +334,14 @@ impl Writer { version, stats: self.stats.clone(), written: self.written, - delivery: self.delivery.take(), + billing: self.billing.take(), } } } /// A stream's payload billed as the transport acknowledges it, through offsets the writer asks /// [`poll_acked`](crate::transport::poll::SendStream::poll_acked) about. -pub(crate) struct Billing { +struct Billing { delivery: crate::stats::Delivery, ack: Ack, } @@ -392,7 +392,12 @@ impl Billing { /// oldest offset still waiting. /// /// The transport is asked nothing while no frame waits, since it may lock to answer. - fn poll>(&mut self, stream: &S, written: u64, waiter: &kio::Waiter) { + fn poll>( + &mut self, + stream: &S, + written: u64, + waiter: &kio::Waiter, + ) { use crate::transport::poll::Acked; loop { @@ -438,7 +443,7 @@ pub struct Closing { stream: Option, version: V, written: u64, - delivery: Option>>, + billing: Option>>, } impl Closing { @@ -447,8 +452,8 @@ impl Closing { let Some(stream) = &self.stream else { return Poll::Ready(Ok(())); }; - if let Some(delivery) = &mut self.delivery { - delivery.poll(stream, self.written, waiter); + if let Some(billing) = &mut self.billing { + billing.poll(stream, self.written, waiter); } let closed = ready!(stream.poll_closed(waiter)); self.settle(); @@ -458,8 +463,8 @@ impl Closing { impl Closing { fn settle(&mut self) { - if let (Some(delivery), Some(stream)) = (&mut self.delivery, &self.stream) { - delivery.poll(stream, self.written, &kio::Waiter::noop()); + if let (Some(billing), Some(stream)) = (&mut self.billing, &self.stream) { + billing.poll(stream, self.written, &kio::Waiter::noop()); } } } @@ -498,8 +503,8 @@ impl Writer { impl Drop for Writer { fn drop(&mut self) { - if let (Some(delivery), Some(stream)) = (&mut self.delivery, &self.stream) { - delivery.poll(stream, self.written, &kio::Waiter::noop()); + if let (Some(billing), Some(stream)) = (&mut self.billing, &self.stream) { + billing.poll(stream, self.written, &kio::Waiter::noop()); } if let Some(mut stream) = self.stream.take() { // Unlike the Quinn default, we abort the stream on drop. @@ -744,7 +749,11 @@ mod tests { write_frame(&mut writer, 100, 100); write_frame(&mut writer, 100, 100); assert!(writer.poll_closed(waiter).is_pending()); - assert_eq!(billed(®istry), (0, 0), "the stream took it all, the transport acknowledged none"); + assert_eq!( + billed(®istry), + (0, 0), + "the stream took it all, the transport acknowledged none" + ); assert_eq!(stream.waits(), 1, "the wait for the peer waits on acknowledgment too"); // Into the second frame: the first bills, though both went out before the park. @@ -764,7 +773,11 @@ mod tests { assert!(writer.poll_closed(waiter).is_pending()); stream.ack(1 + 3 * 102); assert!(writer.poll_closed(waiter).is_pending()); - assert_eq!(billed(®istry), (250, 2), "the acknowledged half bills, not the frame"); + assert_eq!( + billed(®istry), + (250, 2), + "the acknowledged half bills, not the frame" + ); // A reset bills what was acknowledged by then, and nothing after. writer.buffer_raw(&[b'x'; 50]); diff --git a/rs/moq-net/src/stats.rs b/rs/moq-net/src/stats.rs index 78da46c4467..650c71ab839 100644 --- a/rs/moq-net/src/stats.rs +++ b/rs/moq-net/src/stats.rs @@ -52,10 +52,12 @@ //! `frames` / `groups`. //! * `bytes` / `frames` / `groups`: cumulative payload counters bumped as //! groups/frames are read (egress) or written (ingress) in the model. A -//! session's egress `bytes` / `frames` count only payload the transport -//! delivered (see [`SendStream::delivered`](crate::transport::poll::SendStream::delivered)), -//! never what a reset or a lost session discarded: a frame's bytes as they -//! land, and the frame with its last byte. An in-process reader counts on read, +//! session's egress `bytes` / `frames` count only payload the peer +//! acknowledged (see [`SendStream::poll_acked`](crate::transport::poll::SendStream::poll_acked)), +//! never what a reset or a lost session discarded: a frame's bytes once an +//! offset past them is acknowledged, and the frame with its last byte. A +//! transport that cannot see acknowledgments counts the bytes the stream +//! took instead. An in-process reader counts on read, //! unless it takes a [`Bill`] to count only what it delivers onward. //! * `datagrams`: cumulative datagrams of datagram tracks. A datagram belongs to //! no group, so it bumps `bytes` but not `groups` or `frames`. A session counts diff --git a/rs/moq-net/src/transport/memory.rs b/rs/moq-net/src/transport/memory.rs index b19bc5fbace..fd9e9959668 100644 --- a/rs/moq-net/src/transport/memory.rs +++ b/rs/moq-net/src/transport/memory.rs @@ -1187,7 +1187,10 @@ mod tests { let acked = |send: &SendStream, offset: u64| send.poll_acked(&noop(), &offset); let (a, b) = pair(Config::default()); let (mut send, mut recv) = uni(&a, &b); - assert!(matches!(acked(&send, send.offset()), Poll::Ready(Ok(poll::Acked::Delivered)))); + assert!(matches!( + acked(&send, send.offset()), + Poll::Ready(Ok(poll::Acked::Delivered)) + )); ready(write(&mut send, &Bytes::from_static(b"one"))).unwrap(); let one = send.offset(); @@ -1212,7 +1215,10 @@ mod tests { let (mut send, mut recv) = uni(&a, &b); ready(write(&mut send, &Bytes::from_static(b"one"))).unwrap(); recv.stop(3); - assert!(matches!(acked(&send, send.offset()), Poll::Ready(Err(Error::Stopped(3))))); + assert!(matches!( + acked(&send, send.offset()), + Poll::Ready(Err(Error::Stopped(3))) + )); } #[test] diff --git a/rs/moq-uring/tests/integration/web.rs b/rs/moq-uring/tests/integration/web.rs index 15f9329942f..4c017fd2c33 100644 --- a/rs/moq-uring/tests/integration/web.rs +++ b/rs/moq-uring/tests/integration/web.rs @@ -321,7 +321,12 @@ fn an_offset_stays_acknowledged_through_a_reset() { .expect("open uni"); send.write_all(PAYLOAD).await.expect("write"); let payload = SendStream::offset(&send); - let acked = within(&handle, "the ACK", kio::wait(|waiter| send.poll_acked(waiter, &payload))).await; + let acked = within( + &handle, + "the ACK", + kio::wait(|waiter| send.poll_acked(waiter, &payload)), + ) + .await; assert!(matches!(acked, Ok(Acked::Delivered)), "{acked:?}"); // The connection is driven on this thread, so nothing acknowledges this before the reset. @@ -330,7 +335,10 @@ fn an_offset_stays_acknowledged_through_a_reset() { let cut = SendStream::offset(&send); SendStream::reset(&mut send, 1); let acked = |offset| SendStream::poll_acked(&send, &kio::Waiter::noop(), offset); - assert!(matches!(acked(&payload), Poll::Ready(Ok(Acked::Delivered))), "the reset forgot it"); + assert!( + matches!(acked(&payload), Poll::Ready(Ok(Acked::Delivered))), + "the reset forgot it" + ); assert!(matches!(acked(&cut), Poll::Ready(Err(_))), "the reset cut it"); assert_eq!(SendStream::offset(&send), cut); From 663c204e33c96b979a67ad309b29e695276087f5 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 15 Nov 2026 07:46:49 -0800 Subject: [PATCH 4/4] fix(moq-tokio,moq-uring): a stop keeps the acknowledged prefix acknowledged Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/transport.rs | 7 +++--- rs/moq-tokio/src/quic/driver/send.rs | 6 +++-- rs/moq-tokio/src/quic/web/session.rs | 37 ++++++++++++++++++++++++++++ rs/moq-uring/src/quic/driver/send.rs | 6 +++-- 4 files changed, 49 insertions(+), 7 deletions(-) diff --git a/rs/moq-net/src/transport.rs b/rs/moq-net/src/transport.rs index b1e05f2edba..f5840be552d 100644 --- a/rs/moq-net/src/transport.rs +++ b/rs/moq-net/src/transport.rs @@ -726,9 +726,10 @@ pub mod poll { /// Poll until the peer acknowledged every byte below `offset`. /// /// Errors once those bytes can never be acknowledged: the stream was reset by either - /// side or the session closed. A transport that cannot see acknowledgments is ready - /// with [`Acked::Unsupported`] immediately, the default, on every stream, so a caller - /// can decide once per session. An offset minted by another stream may panic. + /// side or the session closed. Bytes already acknowledged stay so after a reset or stop. + /// A transport that cannot see acknowledgments is ready with [`Acked::Unsupported`] + /// immediately, the default, on every stream, so a caller can decide once per session. An + /// offset minted by another stream may panic. fn poll_acked(&self, waiter: &kio::Waiter, offset: &Self::Offset) -> Poll> { let _ = (waiter, offset); Poll::Ready(Ok(Acked::Unsupported)) diff --git a/rs/moq-tokio/src/quic/driver/send.rs b/rs/moq-tokio/src/quic/driver/send.rs index 07ad5cdf14d..c22f7a1b88b 100644 --- a/rs/moq-tokio/src/quic/driver/send.rs +++ b/rs/moq-tokio/src/quic/driver/send.rs @@ -197,7 +197,8 @@ impl Stream { /// Wait for the peer to acknowledge every byte before `offset` /// - /// Fails with the peer's stop code once it stopped the stream, or the connection's loss. + /// Fails with the peer's stop code once it stopped the stream before acknowledging them, or the + /// connection's loss. /// /// # Panics /// - when `offset` came from another stream @@ -411,7 +412,8 @@ impl Half { self.own(&offset); let mut conn = self.stream.conn.state.lock(); let mut stream = conn.inner.send_stream(self.stream.id); - if ready!(stream.poll_acked(waiter, offset.inner)).is_ok() { + // A stop fails the wait even for bytes the peer already acknowledged, which still count. + if ready!(stream.poll_acked(waiter, offset.inner)).is_ok() || stream.acked_len() >= u64::from(offset) { return Poll::Ready(Ok(())); } // A held stream is never released, and a reset consumes its handle, so only the peer's diff --git a/rs/moq-tokio/src/quic/web/session.rs b/rs/moq-tokio/src/quic/web/session.rs index 87d1de1ba38..84cdead3531 100644 --- a/rs/moq-tokio/src/quic/web/session.rs +++ b/rs/moq-tokio/src/quic/web/session.rs @@ -1385,6 +1385,43 @@ mod tests { } } + /// A peer that stops the stream after acknowledging its payload leaves that payload + /// acknowledged: the stop fails only the bytes it had not. + #[tokio::test] + async fn an_offset_stays_acknowledged_through_a_stop() { + use moq_net::transport::poll::{Acked, SendStream}; + + for framed in [false, true] { + let (client, server, _endpoints) = pair().await; + let (client, server) = sessions(framed, client, server).await; + let mut send = client.open_uni(Default::default()).await.unwrap(); + send.write_all(&b"payload"[..]).await.unwrap(); + let payload = SendStream::offset(&send); + let recv = async { + let mut recv = server.accept_uni().await.unwrap(); + let mut read = Vec::new(); + while read.len() < 7 { + read.extend_from_slice(&recv.read_chunk(usize::MAX).await.unwrap().unwrap()); + } + recv + }; + let (acked, recv) = tokio::join!(kio::wait(|waiter| send.poll_acked(waiter, &payload)), recv); + assert!(matches!(acked, Ok(Acked::Delivered)), "framed: {framed}: {acked:?}"); + + recv.stop(3); + let stopped = kio::wait(|waiter| SendStream::poll_closed(&send, waiter)).await; + assert!( + matches!(stopped, Err(crate::quic::web::send::Error::Stopped(3))), + "framed: {framed}: {stopped:?}" + ); + let acked = SendStream::poll_acked(&send, &Waiter::noop(), &payload); + assert!( + matches!(acked, Poll::Ready(Ok(Acked::Delivered))), + "framed: {framed}: the stop forgot it: {acked:?}" + ); + } + } + /// Both ends of a session export the same keying material as soon as it starts. A /// WebTransport session derives its own from the connection's, so it differs from what /// raw QUIC on the same connection would export. diff --git a/rs/moq-uring/src/quic/driver/send.rs b/rs/moq-uring/src/quic/driver/send.rs index 5b1056aef11..b7746d2690a 100644 --- a/rs/moq-uring/src/quic/driver/send.rs +++ b/rs/moq-uring/src/quic/driver/send.rs @@ -154,7 +154,8 @@ impl Stream { /// Wait for the peer to acknowledge every byte before `offset`. /// - /// Fails with the peer's stop code once it stopped the stream, or the connection's loss. + /// Fails with the peer's stop code once it stopped the stream before acknowledging them, or the + /// connection's loss. /// /// # Panics /// - when `offset` came from another stream @@ -308,7 +309,8 @@ impl Half { fn poll_acked(&self, waiter: &kio::Waiter, offset: Offset) -> Poll> { let mut conn = self.shared.conn.borrow_mut(); let mut stream = conn.send_stream(self.id); - if ready!(stream.poll_acked(waiter, offset)).is_ok() { + // A stop fails the wait even for bytes the peer already acknowledged, which still count. + if ready!(stream.poll_acked(waiter, offset)).is_ok() || stream.acked_len() >= u64::from(offset) { return Poll::Ready(Ok(())); } // A held stream is never released, and a reset consumes its handle, so only the peer's