Struct quinn::RecvStream
source · pub struct RecvStream { /* private fields */ }
Expand description
A stream that can only be used to receive data
stop(0)
is implicitly called on drop unless:
Closing a stream
When a stream is expected to be closed gracefully the sender should call
SendStream::finish
. However there is no guarantee the connected RecvStream
will
receive the “finished” notification in the same QUIC frame as the last frame which
carried data.
Even if the application layer logic already knows it read all the data because it does
its own framing, it should still read until it reaches the end of the RecvStream
.
Otherwise it risks inadvertently calling RecvStream::stop
if it drops the stream.
And calling RecvStream::stop
could result in the connected SendStream::finish
call failing with a WriteError::Stopped
error.
For example if exactly 10 bytes are to be read, you still need to explicitly read the end of the stream:
// In the sending task
send_stream.write(&b"0123456789"[..]).await?;
send_stream.finish().await?;
// In the receiving task
let mut buf = [0u8; 10];
let data = recv_stream.read_exact(&mut buf).await?;
if recv_stream.read_to_end(0).await.is_err() {
// Discard unexpected data and notify the peer to stop sending it
let _ = recv_stream.stop(0u8.into());
}
An alternative approach, used in HTTP/3, is to specify a particular error code used with stop
that indicates graceful receiver-initiated stream shutdown, rather than a true error condition.
RecvStream::read_chunk
could be used instead which does not take ownership and
allows using an explit call to RecvStream::stop
with a custom error code.
Implementations§
source§impl RecvStream
impl RecvStream
sourcepub async fn read(&mut self, buf: &mut [u8]) -> Result<Option<usize>, ReadError>
pub async fn read(&mut self, buf: &mut [u8]) -> Result<Option<usize>, ReadError>
Read data contiguously from the stream.
Yields the number of bytes read into buf
on success, or None
if the stream was finished.
sourcepub async fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), ReadExactError>
pub async fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), ReadExactError>
Read an exact number of bytes contiguously from the stream.
See read()
for details.
sourcepub async fn read_chunk(
&mut self,
max_length: usize,
ordered: bool
) -> Result<Option<Chunk>, ReadError>
pub async fn read_chunk( &mut self, max_length: usize, ordered: bool ) -> Result<Option<Chunk>, ReadError>
Read the next segment of data
Yields None
if the stream was finished. Otherwise, yields a segment of data and its
offset in the stream. If ordered
is true
, the chunk’s offset will be immediately after
the last data yielded by read()
or read_chunk()
. If ordered
is false
, segments may
be received in any order, and the Chunk
’s offset
field can be used to determine
ordering in the caller. Unordered reads are less prone to head-of-line blocking within a
stream, but require the application to manage reassembling the original data.
Slightly more efficient than read
due to not copying. Chunk boundaries do not correspond
to peer writes, and hence cannot be used as framing.
sourcepub async fn read_chunks(
&mut self,
bufs: &mut [Bytes]
) -> Result<Option<usize>, ReadError>
pub async fn read_chunks( &mut self, bufs: &mut [Bytes] ) -> Result<Option<usize>, ReadError>
Read the next segments of data
Fills bufs
with the segments of data beginning immediately after the
last data yielded by read
or read_chunk
, or None
if the stream was
finished.
Slightly more efficient than read
due to not copying. Chunk boundaries
do not correspond to peer writes, and hence cannot be used as framing.
sourcepub async fn read_to_end(
&mut self,
size_limit: usize
) -> Result<Vec<u8>, ReadToEndError>
pub async fn read_to_end( &mut self, size_limit: usize ) -> Result<Vec<u8>, ReadToEndError>
Convenience method to read all remaining data into a buffer
Fails with ReadToEndError::TooLong
on reading more than size_limit
bytes, discarding
all data read. Uses unordered reads to be more efficient than using AsyncRead
would
allow. size_limit
should be set to limit worst-case memory use.
If unordered reads have already been made, the resulting buffer may have gaps containing arbitrary data.
sourcepub fn stop(&mut self, error_code: VarInt) -> Result<(), UnknownStream>
pub fn stop(&mut self, error_code: VarInt) -> Result<(), UnknownStream>
Stop accepting data
Discards unread data and notifies the peer to stop transmitting. Once stopped, further
attempts to operate on a stream will yield UnknownStream
errors.
Trait Implementations§
source§impl AsyncRead for RecvStream
impl AsyncRead for RecvStream
source§impl AsyncRead for RecvStream
impl AsyncRead for RecvStream
source§impl Debug for RecvStream
impl Debug for RecvStream
Auto Trait Implementations§
impl RefUnwindSafe for RecvStream
impl Send for RecvStream
impl Sync for RecvStream
impl Unpin for RecvStream
impl UnwindSafe for RecvStream
Blanket Implementations§
§impl<R> AsyncReadExt for Rwhere
R: AsyncRead + ?Sized,
impl<R> AsyncReadExt for Rwhere R: AsyncRead + ?Sized,
§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self>where
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self>where Self: Unpin,
§fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self>where
Self: Unpin,
fn read_vectored<'a>( &'a mut self, bufs: &'a mut [IoSliceMut<'a>] ) -> ReadVectoredFuture<'a, Self>where Self: Unpin,
§fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self>where
Self: Unpin,
fn read_to_end<'a>( &'a mut self, buf: &'a mut Vec<u8, Global> ) -> ReadToEndFuture<'a, Self>where Self: Unpin,
§fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self>where
Self: Unpin,
fn read_to_string<'a>( &'a mut self, buf: &'a mut String ) -> ReadToStringFuture<'a, Self>where Self: Unpin,
§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self>where
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self>where Self: Unpin,
buf
. Read more§fn take(self, limit: u64) -> Take<Self>where
Self: Sized,
fn take(self, limit: u64) -> Take<Self>where Self: Sized,
limit
bytes from it. Read moresource§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> ReadExt for Twhere
T: AsyncRead + ?Sized,
impl<T> ReadExt for Twhere T: AsyncRead + ?Sized,
source§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self>where
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self>where Self: Unpin,
source§fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self>where
Self: Unpin,
fn read_vectored<'a>( &'a mut self, bufs: &'a mut [IoSliceMut<'a>] ) -> ReadVectoredFuture<'a, Self>where Self: Unpin,
source§fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self>where
Self: Unpin,
fn read_to_end<'a>( &'a mut self, buf: &'a mut Vec<u8, Global> ) -> ReadToEndFuture<'a, Self>where Self: Unpin,
source§fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self>where
Self: Unpin,
fn read_to_string<'a>( &'a mut self, buf: &'a mut String ) -> ReadToStringFuture<'a, Self>where Self: Unpin,
source§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self>where
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self>where Self: Unpin,
buf
. Read moresource§fn take(self, limit: u64) -> Take<Self>where
Self: Sized,
fn take(self, limit: u64) -> Take<Self>where Self: Sized,
limit
bytes from it. Read moresource§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,
Read
. Read more