use std::{
collections::{HashMap, VecDeque},
io,
marker::PhantomData,
sync::Arc,
task::{Context, Poll, Waker},
};
use bytes::{Bytes, BytesMut};
use parking_lot::Mutex;
use tokio::{
io::{AsyncRead, AsyncReadExt as _, AsyncWrite, AsyncWriteExt as _},
sync::{mpsc, oneshot},
};
use tokio_util::codec::{Decoder, Encoder};
use crate::{
Flag, Frame, FrameCodec, Stream, StreamId,
frame::FRAME_HEADER_LEN,
stream::{IncomingState, IncomingStateHandle},
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Side {
Initiator,
Responder,
}
pub struct Multiplexer<IO> {
inner: Arc<MultiplexerInner>,
_io: PhantomData<fn() -> IO>,
}
impl<IO> Clone for Multiplexer<IO> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
_io: PhantomData,
}
}
}
impl<IO> std::fmt::Debug for Multiplexer<IO> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Multiplexer").finish_non_exhaustive()
}
}
pub(crate) struct MultiplexerInner {
side: Side,
state: Mutex<MultiplexerState>,
outgoing_tx: mpsc::UnboundedSender<Bytes>,
shutdown_tx: Mutex<Option<oneshot::Sender<()>>>,
}
struct MultiplexerState {
streams: HashMap<StreamId, IncomingStateHandle>,
next_id: u32,
new_streams: VecDeque<Stream>,
accept_waker: Option<Waker>,
closed: bool,
goaway_reason: Option<u32>,
}
impl<IO> Multiplexer<IO>
where
IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,
{
pub fn new(io: IO, side: Side) -> Self {
let (outgoing_tx, outgoing_rx) = mpsc::unbounded_channel();
let (shutdown_tx, shutdown_rx) = oneshot::channel();
let next_id = match side {
Side::Initiator => 1,
Side::Responder => 2,
};
let inner = Arc::new(MultiplexerInner {
side,
state: Mutex::new(MultiplexerState {
streams: HashMap::new(),
next_id,
new_streams: VecDeque::new(),
accept_waker: None,
closed: false,
goaway_reason: None,
}),
outgoing_tx,
shutdown_tx: Mutex::new(Some(shutdown_tx)),
});
let inner_for_task = inner.clone();
tokio::spawn(drive(io, outgoing_rx, shutdown_rx, inner_for_task));
Self {
inner,
_io: PhantomData,
}
}
pub fn open_stream(&self) -> io::Result<Stream> {
let (id, incoming) = {
let mut state = self.inner.state.lock();
if state.closed {
return Err(io::ErrorKind::Other.into());
}
let id = StreamId(state.next_id);
state.next_id = state.next_id.wrapping_add(2);
let incoming: IncomingStateHandle = Arc::new(Mutex::new(IncomingState::default()));
state.streams.insert(id, incoming.clone());
(id, incoming)
};
if let Err(e) = self.inner.send_frame(Frame::open(id)) {
self.inner.state.lock().streams.remove(&id);
return Err(e);
}
Ok(Stream {
inner: self.inner.clone(),
id,
incoming,
outgoing_closed: false,
})
}
pub fn accept(&self) -> Accept {
Accept {
inner: self.inner.clone(),
}
}
pub fn goaway_reason(&self) -> Option<u32> {
self.inner.state.lock().goaway_reason
}
pub fn goaway(&self, reason: u32) {
let _ = self.inner.send_frame(Frame::goaway(reason));
self.shutdown();
}
pub fn shutdown(&self) {
let (read_wakers, accept_waker) = self.inner.close_all();
for w in read_wakers {
w.wake();
}
if let Some(w) = accept_waker {
w.wake();
}
if let Some(tx) = self.inner.shutdown_tx.lock().take() {
let _ = tx.send(());
}
}
}
pub struct Accept {
inner: Arc<MultiplexerInner>,
}
impl Future for Accept {
type Output = io::Result<Stream>;
fn poll(self: std::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut state = self.inner.state.lock();
if let Some(stream) = state.new_streams.pop_front() {
return Poll::Ready(Ok(stream));
}
if state.closed {
return Poll::Ready(Err(io::ErrorKind::Other.into()));
}
state.accept_waker = Some(cx.waker().clone());
Poll::Pending
}
}
impl MultiplexerInner {
fn dispatch(self: &Arc<Self>, frame: Frame) -> (Vec<Waker>, Option<Waker>) {
let mut state = self.state.lock();
match frame.flag {
Flag::Open => {
if state.closed {
return (Vec::new(), None);
}
let id = frame.stream_id;
let trespasses = match self.side {
Side::Initiator => id.is_initiator(),
Side::Responder => id.is_responder(),
};
if id.get() == 0 || trespasses || state.streams.contains_key(&id) {
return (Vec::new(), None);
}
let incoming: IncomingStateHandle = Arc::new(Mutex::new(IncomingState::default()));
state.streams.insert(id, incoming.clone());
let stream = Stream {
inner: self.clone(),
id,
incoming: incoming.clone(),
outgoing_closed: false,
};
state.new_streams.push_back(stream);
(Vec::new(), state.accept_waker.take())
}
Flag::Data => {
let id = frame.stream_id;
let mut wakers = Vec::new();
if let Some(incoming) = state.streams.get(&id) {
let mut inc = incoming.lock();
inc.data.push_back(frame.payload);
if let Some(w) = inc.read_waker.take() {
wakers.push(w);
}
}
(wakers, None)
}
Flag::Close => {
let id = frame.stream_id;
let mut wakers = Vec::new();
if let Some(incoming) = state.streams.remove(&id) {
let mut inc = incoming.lock();
inc.closed = true;
if let Some(w) = inc.read_waker.take() {
wakers.push(w);
}
}
(wakers, None)
}
Flag::GoAway => {
if frame.payload.len() >= 4 {
state.goaway_reason = Some(u32::from_be_bytes([
frame.payload[0],
frame.payload[1],
frame.payload[2],
frame.payload[3],
]));
}
let mut wakers = Vec::new();
for (_, incoming) in state.streams.drain() {
let mut inc = incoming.lock();
inc.closed = true;
if let Some(w) = inc.read_waker.take() {
wakers.push(w);
}
}
(wakers, None)
}
}
}
pub(crate) fn send_frame(&self, frame: Frame) -> io::Result<()> {
if self.state.lock().closed {
return Err(io::ErrorKind::BrokenPipe.into());
}
let mut buf = BytesMut::with_capacity(FRAME_HEADER_LEN + frame.payload.len());
FrameCodec
.encode(frame, &mut buf)
.map_err(|_| io::ErrorKind::InvalidData)?;
self.outgoing_tx
.send(buf.freeze())
.map_err(|_| io::ErrorKind::BrokenPipe.into())
}
pub(crate) fn close_local_stream(&self, id: StreamId) -> Option<Waker> {
let mut state = self.state.lock();
if let Some(incoming) = state.streams.remove(&id) {
let mut inc = incoming.lock();
inc.closed = true;
return inc.read_waker.take();
}
None
}
fn close_all(&self) -> (Vec<Waker>, Option<Waker>) {
let mut state = self.state.lock();
state.closed = true;
let accept_waker = state.accept_waker.take();
let mut read_wakers = Vec::new();
for (_, incoming) in state.streams.drain() {
let mut inc = incoming.lock();
inc.closed = true;
if let Some(w) = inc.read_waker.take() {
read_wakers.push(w);
}
}
(read_wakers, accept_waker)
}
}
async fn drive<IO>(
io: IO,
mut outgoing_rx: mpsc::UnboundedReceiver<Bytes>,
shutdown_rx: oneshot::Receiver<()>,
inner: Arc<MultiplexerInner>,
) where
IO: AsyncRead + AsyncWrite + Unpin,
{
let mut shutdown_rx = shutdown_rx;
let (mut rd, mut wr) = tokio::io::split(io);
let mut read_buf = BytesMut::with_capacity(8 * 1024);
let mut write_buf = BytesMut::new();
'drive: loop {
tokio::select! {
biased;
_ = &mut shutdown_rx => {
while let Ok(bytes) = outgoing_rx.try_recv() {
write_buf.extend_from_slice(&bytes);
}
while !write_buf.is_empty() {
match wr.write(&write_buf).await {
Ok(0) | Err(_) => break,
Ok(n) => {
let _ = write_buf.split_to(n);
}
}
}
break;
}
write_result = wr.write(&write_buf), if !write_buf.is_empty() => {
match write_result {
Ok(0) | Err(_) => break,
Ok(n) => {
let _ = write_buf.split_to(n);
}
}
}
maybe_bytes = outgoing_rx.recv() => {
match maybe_bytes {
Some(bytes) => write_buf.extend_from_slice(&bytes),
None => break,
}
}
read_result = rd.read_buf(&mut read_buf) => {
match read_result {
Ok(0) | Err(_) => break,
Ok(_) => {
loop {
match FrameCodec.decode(&mut read_buf) {
Ok(Some(frame)) => {
let (read_wakers, accept_waker) = inner.dispatch(frame);
for w in read_wakers { w.wake(); }
if let Some(w) = accept_waker { w.wake(); }
}
Ok(None) => break,
Err(_) => {
break 'drive;
}
}
}
}
}
}
}
}
let (read_wakers, accept_waker) = inner.close_all();
for w in read_wakers {
w.wake();
}
if let Some(w) = accept_waker {
w.wake();
}
}