use std::io;
use tokio::io::{AsyncRead, AsyncReadExt as _};
pub const MAX_RPC_FRAME_BYTES: usize = 1024 * 1024;
const READ_CHUNK_BYTES: usize = 8192;
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
pub enum RpcReadError {
#[error("RPC frame exceeds the size limit")]
Oversize,
#[error("RPC input ended inside a frame")]
Unterminated,
#[error("RPC input is unavailable")]
Io,
}
#[derive(Debug)]
pub struct RpcFrameReader<R> {
input: R,
buffered: Vec<u8>,
eof: bool,
}
impl<R: AsyncRead + Unpin> RpcFrameReader<R> {
#[must_use]
pub const fn new(input: R) -> Self {
Self {
input,
buffered: Vec::new(),
eof: false,
}
}
pub async fn read_frame(&mut self) -> Result<Option<Vec<u8>>, RpcReadError> {
loop {
if let Some(index) = self.buffered.iter().position(|byte| *byte == b'\n') {
if index > MAX_RPC_FRAME_BYTES {
return Err(RpcReadError::Oversize);
}
let mut frame = self.buffered.drain(..=index).collect::<Vec<_>>();
frame.pop();
if frame.last() == Some(&b'\r') {
frame.pop();
}
return Ok(Some(frame));
}
if self.buffered.len() > MAX_RPC_FRAME_BYTES {
return Err(RpcReadError::Oversize);
}
if self.eof {
return if self.buffered.is_empty() {
Ok(None)
} else {
Err(RpcReadError::Unterminated)
};
}
let mut chunk = [0_u8; READ_CHUNK_BYTES];
let read = self.input.read(&mut chunk).await.map_err(map_io_error)?;
if read == 0 {
self.eof = true;
} else {
self.buffered.extend_from_slice(&chunk[..read]);
}
}
}
}
fn map_io_error(_error: io::Error) -> RpcReadError {
RpcReadError::Io
}