use std::{
collections::VecDeque,
io,
pin::Pin,
sync::Arc,
task::{Context, Poll, Waker},
};
use bytes::{Buf, Bytes};
use parking_lot::Mutex;
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
use crate::{Frame, StreamId, frame::MAX_FRAME_PAYLOAD, mplex::MultiplexerInner};
#[derive(Default)]
pub(crate) struct IncomingState {
pub(crate) data: VecDeque<Bytes>,
pub(crate) closed: bool,
pub(crate) read_waker: Option<Waker>,
}
pub(crate) type IncomingStateHandle = Arc<Mutex<IncomingState>>;
pub struct Stream {
pub(crate) inner: Arc<MultiplexerInner>,
pub(crate) id: StreamId,
pub(crate) incoming: IncomingStateHandle,
pub(crate) outgoing_closed: bool,
}
impl Stream {
#[inline]
pub fn id(&self) -> StreamId {
self.id
}
}
impl std::fmt::Debug for Stream {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Stream")
.field("id", &self.id)
.field("outgoing_closed", &self.outgoing_closed)
.finish_non_exhaustive()
}
}
impl AsyncRead for Stream {
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<io::Result<()>> {
let mut incoming = self.incoming.lock();
if let Some(mut data) = incoming.data.pop_front() {
let n = std::cmp::min(buf.remaining(), data.len());
buf.put_slice(&data[..n]);
if n < data.len() {
data.advance(n);
incoming.data.push_front(data);
}
return Poll::Ready(Ok(()));
}
if incoming.closed {
return Poll::Ready(Ok(()));
}
incoming.read_waker = Some(cx.waker().clone());
Poll::Pending
}
}
impl AsyncWrite for Stream {
fn poll_write(
self: Pin<&mut Self>,
_cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<io::Result<usize>> {
if self.outgoing_closed {
return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()));
}
if buf.len() > MAX_FRAME_PAYLOAD as usize {
return Poll::Ready(Err(io::Error::new(
io::ErrorKind::InvalidInput,
"write buffer exceeds peaplex max frame size",
)));
}
let frame = Frame::data(self.id, Bytes::copy_from_slice(buf));
match self.inner.send_frame(frame) {
Ok(()) => Poll::Ready(Ok(buf.len())),
Err(e) => Poll::Ready(Err(e)),
}
}
fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
Poll::Ready(Ok(()))
}
fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
self.get_mut().send_close();
Poll::Ready(Ok(()))
}
}
impl Drop for Stream {
fn drop(&mut self) {
self.send_close();
let _ = self.inner.close_local_stream(self.id);
}
}
impl Stream {
fn send_close(&mut self) {
if !self.outgoing_closed {
let _ = self.inner.send_frame(Frame::close(self.id));
self.outgoing_closed = true;
}
}
}