netapp/src/stream.rs

203 lines
5.9 KiB
Rust
Raw Normal View History

2022-07-22 10:45:38 +00:00
use std::pin::Pin;
use std::task::{Context, Poll};
use bytes::Bytes;
use futures::Future;
2022-09-01 09:21:24 +00:00
use futures::{Stream, StreamExt};
use tokio::io::AsyncRead;
2022-07-22 10:45:38 +00:00
use crate::bytes_buf::BytesBuf;
2022-09-12 15:43:10 +00:00
/// A stream of bytes (click to read more).
2022-07-22 10:45:38 +00:00
///
/// When sent through Netapp, the Vec may be split in smaller chunk in such a way
/// consecutive Vec may get merged, but Vec and error code may not be reordered
///
2022-09-12 15:43:10 +00:00
/// Items sent in the ByteStream may be errors of type `std::io::Error`.
/// An error indicates the end of the ByteStream: a reader should no longer read
/// after recieving an error, and a writer should stop writing after sending an error.
2022-07-22 10:45:38 +00:00
pub type ByteStream = Pin<Box<dyn Stream<Item = Packet> + Send + Sync>>;
2022-09-12 15:43:10 +00:00
/// A packet sent in a ByteStream, which may contain either
/// a Bytes object or an error
2022-09-01 09:21:24 +00:00
pub type Packet = Result<Bytes, std::io::Error>;
2022-07-22 10:45:38 +00:00
// ----
2022-09-12 15:43:10 +00:00
/// A helper struct to read defined lengths of data from a BytesStream
2022-07-22 10:45:38 +00:00
pub struct ByteStreamReader {
stream: ByteStream,
buf: BytesBuf,
2022-07-22 10:45:38 +00:00
eos: bool,
2022-09-01 09:21:24 +00:00
err: Option<std::io::Error>,
2022-07-22 10:45:38 +00:00
}
impl ByteStreamReader {
2022-09-12 15:43:10 +00:00
/// Creates a new `ByteStreamReader` from a `ByteStream`
2022-07-22 10:45:38 +00:00
pub fn new(stream: ByteStream) -> Self {
ByteStreamReader {
stream,
buf: BytesBuf::new(),
2022-07-22 10:45:38 +00:00
eos: false,
err: None,
}
}
2022-09-12 15:43:10 +00:00
/// Read exactly `read_len` bytes from the underlying stream
/// (returns a future)
2022-07-22 10:45:38 +00:00
pub fn read_exact(&mut self, read_len: usize) -> ByteStreamReadExact<'_> {
ByteStreamReadExact {
reader: self,
read_len,
fail_on_eos: true,
}
}
2022-09-12 15:43:10 +00:00
/// Read at most `read_len` bytes from the underlying stream, or less
/// if the end of the stream is reached (returns a future)
2022-07-22 10:45:38 +00:00
pub fn read_exact_or_eos(&mut self, read_len: usize) -> ByteStreamReadExact<'_> {
ByteStreamReadExact {
reader: self,
read_len,
fail_on_eos: false,
}
}
2022-09-12 15:43:10 +00:00
/// Read exactly one byte from the underlying stream and returns it
/// as an u8
2022-07-22 10:45:38 +00:00
pub async fn read_u8(&mut self) -> Result<u8, ReadExactError> {
Ok(self.read_exact(1).await?[0])
}
2022-09-12 15:43:10 +00:00
/// Read exactly two bytes from the underlying stream and returns them as an u16 (using
/// big-endian decoding)
2022-07-22 10:45:38 +00:00
pub async fn read_u16(&mut self) -> Result<u16, ReadExactError> {
let bytes = self.read_exact(2).await?;
let mut b = [0u8; 2];
b.copy_from_slice(&bytes[..]);
Ok(u16::from_be_bytes(b))
}
2022-09-12 15:43:10 +00:00
/// Read exactly four bytes from the underlying stream and returns them as an u32 (using
/// big-endian decoding)
2022-07-22 10:45:38 +00:00
pub async fn read_u32(&mut self) -> Result<u32, ReadExactError> {
let bytes = self.read_exact(4).await?;
let mut b = [0u8; 4];
b.copy_from_slice(&bytes[..]);
Ok(u32::from_be_bytes(b))
}
2022-09-12 15:43:10 +00:00
/// Transforms the stream reader back into the underlying stream (starting
/// after everything that the reader has read)
2022-07-22 10:45:38 +00:00
pub fn into_stream(self) -> ByteStream {
let buf_stream = futures::stream::iter(self.buf.into_slices().into_iter().map(Ok));
2022-07-22 10:45:38 +00:00
if let Some(err) = self.err {
Box::pin(buf_stream.chain(futures::stream::once(async move { Err(err) })))
} else if self.eos {
Box::pin(buf_stream)
} else {
Box::pin(buf_stream.chain(self.stream))
}
}
/// Tries to fill the internal read buffer from the underlying stream if it is empty.
2022-09-12 15:43:10 +00:00
/// Calling this might be necessary to ensure that `.eos()` returns a correct
/// result, otherwise the reader might not be aware that the underlying
/// stream has nothing left to return.
pub async fn fill_buffer(&mut self) {
if self.buf.is_empty() {
let packet = self.stream.next().await;
self.add_stream_next(packet);
}
2022-09-12 15:43:10 +00:00
}
/// Clears the internal read buffer and returns its content
2022-07-22 11:23:42 +00:00
pub fn take_buffer(&mut self) -> Bytes {
self.buf.take_all()
2022-07-22 11:23:42 +00:00
}
2022-09-12 15:43:10 +00:00
/// Returns true if the end of the underlying stream has been reached
2022-07-22 11:23:42 +00:00
pub fn eos(&self) -> bool {
self.buf.is_empty() && self.eos
2022-07-22 11:23:42 +00:00
}
2022-07-22 10:45:38 +00:00
fn try_get(&mut self, read_len: usize) -> Option<Bytes> {
self.buf.take_exact(read_len)
2022-07-22 10:45:38 +00:00
}
fn add_stream_next(&mut self, packet: Option<Packet>) {
match packet {
Some(Ok(slice)) => {
self.buf.extend(slice);
}
Some(Err(e)) => {
self.err = Some(e);
self.eos = true;
}
None => {
self.eos = true;
}
}
}
2022-07-22 10:45:38 +00:00
}
2022-09-12 15:43:10 +00:00
/// The error kind that can be returned by `ByteStreamReader::read_exact` and
/// `ByteStreamReader::read_exact_or_eos`
2022-07-22 10:45:38 +00:00
pub enum ReadExactError {
2022-09-12 15:43:10 +00:00
/// The end of the stream was reached before the requested number of bytes could be read
2022-07-22 10:45:38 +00:00
UnexpectedEos,
2022-09-12 15:43:10 +00:00
/// The underlying data stream returned an IO error when trying to read
2022-09-01 09:21:24 +00:00
Stream(std::io::Error),
2022-07-22 10:45:38 +00:00
}
2022-09-12 15:43:10 +00:00
/// The future returned by `ByteStreamReader::read_exact` and
/// `ByteStreamReader::read_exact_or_eos`
2022-07-22 10:45:38 +00:00
#[pin_project::pin_project]
pub struct ByteStreamReadExact<'a> {
#[pin]
reader: &'a mut ByteStreamReader,
read_len: usize,
fail_on_eos: bool,
}
impl<'a> Future for ByteStreamReadExact<'a> {
type Output = Result<Bytes, ReadExactError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<Bytes, ReadExactError>> {
let mut this = self.project();
loop {
if let Some(bytes) = this.reader.try_get(*this.read_len) {
return Poll::Ready(Ok(bytes));
}
2022-09-01 09:21:24 +00:00
if let Some(err) = &this.reader.err {
let err = std::io::Error::new(err.kind(), format!("{}", err));
2022-07-22 10:45:38 +00:00
return Poll::Ready(Err(ReadExactError::Stream(err)));
}
if this.reader.eos {
if *this.fail_on_eos {
return Poll::Ready(Err(ReadExactError::UnexpectedEos));
} else {
2022-07-22 11:23:42 +00:00
return Poll::Ready(Ok(this.reader.take_buffer()));
2022-07-22 10:45:38 +00:00
}
}
let next_packet = futures::ready!(this.reader.stream.as_mut().poll_next(cx));
this.reader.add_stream_next(next_packet);
2022-07-22 10:45:38 +00:00
}
}
}
// ----
2022-09-12 15:43:10 +00:00
/// Turns a `tokio::io::AsyncRead` asynchronous reader into a `ByteStream`
pub fn asyncread_stream<R: AsyncRead + Send + Sync + 'static>(reader: R) -> ByteStream {
2022-09-01 09:21:24 +00:00
Box::pin(tokio_util::io::ReaderStream::new(reader))
}
2022-09-12 15:43:10 +00:00
/// Turns a `ByteStream` into a `tokio::io::AsyncRead` asynchronous reader
pub fn stream_asyncread(stream: ByteStream) -> impl AsyncRead + Send + Sync + 'static {
2022-09-01 09:21:24 +00:00
tokio_util::io::StreamReader::new(stream)
}