use std::{ io, pin::Pin, task::{Context, Poll},}; use futures_io::AsyncWrite;use futures_lite::AsyncWriteExt; use super::u16_to_hex;use crate::{encode::Error, Channel, DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN, RESPONSE_END_LINE}; #[allow(missing_docs)]pin_project_lite::pin_project! { /// A way of writing packet lines asynchronously. pub struct LineWriter<'a, W> { #[pin] pub(crate) writer: W, pub(crate) prefix: &'a [u8], pub(crate) suffix: &'a [u8], state: State<'a>, }} enum State<'a> { Idle, WriteHexLen([u8; 4], usize), WritePrefix(&'a [u8]), WriteData(usize), WriteSuffix(&'a [u8]),} impl<'a, W: AsyncWrite + Unpin> LineWriter<'a, W> { /// Create a new line writer writing data with a `prefix` and `suffix`. /// /// Keep the additional `prefix` or `suffix` buffers empty if no prefix or suffix should be written. pub fn new(writer: W, prefix: &'a [u8], suffix: &'a [u8]) -> Self { LineWriter { writer, prefix, suffix, state: State::Idle, } } /// Consume self and reveal the inner writer. pub fn into_inner(self) -> W { self.writer }} fn into_io_err(err: Error) -> io::Error { io::Error::new(io::ErrorKind::Other, err)} impl<W: AsyncWrite + Unpin> AsyncWrite for LineWriter<'_, W> { fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, data: &[u8]) -> Poll<io::Result<usize>> { use futures_lite::ready; let mut this = self.project(); loop { match &mut this.state { State::Idle => { let data_len = this.prefix.len() + data.len() + this.suffix.len(); if data_len > MAX_DATA_LEN { return Poll::Ready(Err(into_io_err(Error::DataLengthLimitExceeded(data_len)))); } if data.is_empty() { return Poll::Ready(Err(into_io_err(Error::DataIsEmpty))); } let data_len = data_len + 4; let len_buf = u16_to_hex(data_len as u16); *this.state = State::WriteHexLen(len_buf, 0) } State::WriteHexLen(hex_len, written) => { while *written != hex_len.len() { let n = ready!(this.writer.as_mut().poll_write(cx, &hex_len[*written..]))?; if n == 0 { return Poll::Ready(Err(io::ErrorKind::WriteZero.into())); } *written += n; } if this.prefix.is_empty() { *this.state = State::WriteData(0) } else { *this.state = State::WritePrefix(this.prefix) } } State::WritePrefix(buf) => { while !buf.is_empty() { let n = ready!(this.writer.as_mut().poll_write(cx, buf))?; if n == 0 { return Poll::Ready(Err(io::ErrorKind::WriteZero.into())); } let (_, rest) = std::mem::replace(buf, &[]).split_at(n); *buf = rest; } *this.state = State::WriteData(0) } State::WriteData(written) => { while *written != data.len() { let n = ready!(this.writer.as_mut().poll_write(cx, &data[*written..]))?; if n == 0 { return Poll::Ready(Err(io::ErrorKind::WriteZero.into())); } *written += n; } if this.suffix.is_empty() { let written = 4 + this.prefix.len() + *written; *this.state = State::Idle; return Poll::Ready(Ok(written)); } else { *this.state = State::WriteSuffix(this.suffix) } } State::WriteSuffix(buf) => { while !buf.is_empty() { let n = ready!(this.writer.as_mut().poll_write(cx, buf))?; if n == 0 { return Poll::Ready(Err(io::ErrorKind::WriteZero.into())); } let (_, rest) = std::mem::replace(buf, &[]).split_at(n); *buf = rest; } *this.state = State::Idle; return Poll::Ready(Ok(4 + this.prefix.len() + data.len() + this.suffix.len())); } } } } fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> { let this = self.project(); this.writer.poll_flush(cx) } fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> { let this = self.project(); this.writer.poll_close(cx) }} async fn prefixed_and_suffixed_data_to_write( prefix: &[u8], data: &[u8], suffix: &[u8], mut out: impl AsyncWrite + Unpin,) -> io::Result<usize> { let data_len = prefix.len() + data.len() + suffix.len(); if data_len > MAX_DATA_LEN { return Err(into_io_err(Error::DataLengthLimitExceeded(data_len))); } if data.is_empty() { return Err(into_io_err(Error::DataIsEmpty)); } let data_len = data_len + 4; let buf = u16_to_hex(data_len as u16); out.write_all(&buf).await?; if !prefix.is_empty() { out.write_all(prefix).await?; } out.write_all(data).await?; if !suffix.is_empty() { out.write_all(suffix).await?; } Ok(data_len)} async fn prefixed_data_to_write(prefix: &[u8], data: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> { prefixed_and_suffixed_data_to_write(prefix, data, &[], out).await} /// Write a `text` message to `out`, which is assured to end in a newline.pub async fn text_to_write(text: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> { prefixed_and_suffixed_data_to_write(&[], text, &[b'\n'], out).await} /// Write a `data` message to `out`.pub async fn data_to_write(data: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> { prefixed_data_to_write(&[], data, out).await} /// Write an error `message` to `out`.pub async fn error_to_write(message: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> { prefixed_data_to_write(ERR_PREFIX, message, out).await} /// Write a response-end message to `out`.pub async fn response_end_to_write(mut out: impl AsyncWrite + Unpin) -> io::Result<usize> { out.write_all(RESPONSE_END_LINE).await?; Ok(4)} /// Write a delim message to `out`.pub async fn delim_to_write(mut out: impl AsyncWrite + Unpin) -> io::Result<usize> { out.write_all(DELIMITER_LINE).await?; Ok(4)} /// Write a flush message to `out`.pub async fn flush_to_write(mut out: impl AsyncWrite + Unpin) -> io::Result<usize> { out.write_all(FLUSH_LINE).await?; Ok(4)} /// Write `data` of `kind` to `out` using side-band encoding.pub async fn band_to_write(kind: Channel, data: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> { prefixed_data_to_write(&[kind as u8], data, out).await}
use std::{
io,
pin::Pin,
task::{Context, Poll},
};
use futures_io::AsyncWrite;
use futures_lite::AsyncWriteExt;
use super::u16_to_hex;
use crate::{encode::Error, Channel, DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN, RESPONSE_END_LINE};
#[allow(missing_docs)]
pin_project_lite::pin_project! {
/// A way of writing packet lines asynchronously.
pub struct LineWriter<'a, W> {
#[pin]
pub(crate) writer: W,
pub(crate) prefix: &'a [u8],
pub(crate) suffix: &'a [u8],
state: State<'a>,
}
}
enum State<'a> {
Idle,
WriteHexLen([u8; 4], usize),
WritePrefix(&'a [u8]),
WriteData(usize),
WriteSuffix(&'a [u8]),
}
impl<'a, W: AsyncWrite + Unpin> LineWriter<'a, W> {
/// Create a new line writer writing data with a `prefix` and `suffix`.
///
/// Keep the additional `prefix` or `suffix` buffers empty if no prefix or suffix should be written.
pub fn new(writer: W, prefix: &'a [u8], suffix: &'a [u8]) -> Self {
LineWriter {
writer,
prefix,
suffix,
state: State::Idle,
}
}
/// Consume self and reveal the inner writer.
pub fn into_inner(self) -> W {
self.writer
}
}
fn into_io_err(err: Error) -> io::Error {
io::Error::new(io::ErrorKind::Other, err)
}
impl<W: AsyncWrite + Unpin> AsyncWrite for LineWriter<'_, W> {
fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, data: &[u8]) -> Poll<io::Result<usize>> {
use futures_lite::ready;
let mut this = self.project();
loop {
match &mut this.state {
State::Idle => {
let data_len = this.prefix.len() + data.len() + this.suffix.len();
if data_len > MAX_DATA_LEN {
return Poll::Ready(Err(into_io_err(Error::DataLengthLimitExceeded(data_len))));
}
if data.is_empty() {
return Poll::Ready(Err(into_io_err(Error::DataIsEmpty)));
}
let data_len = data_len + 4;
let len_buf = u16_to_hex(data_len as u16);
*this.state = State::WriteHexLen(len_buf, 0)
}
State::WriteHexLen(hex_len, written) => {
while *written != hex_len.len() {
let n = ready!(this.writer.as_mut().poll_write(cx, &hex_len[*written..]))?;
if n == 0 {
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
}
*written += n;
}
if this.prefix.is_empty() {
*this.state = State::WriteData(0)
} else {
*this.state = State::WritePrefix(this.prefix)
}
}
State::WritePrefix(buf) => {
while !buf.is_empty() {
let n = ready!(this.writer.as_mut().poll_write(cx, buf))?;
if n == 0 {
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
}
let (_, rest) = std::mem::replace(buf, &[]).split_at(n);
*buf = rest;
}
*this.state = State::WriteData(0)
}
State::WriteData(written) => {
while *written != data.len() {
let n = ready!(this.writer.as_mut().poll_write(cx, &data[*written..]))?;
if n == 0 {
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
}
*written += n;
}
if this.suffix.is_empty() {
let written = 4 + this.prefix.len() + *written;
*this.state = State::Idle;
return Poll::Ready(Ok(written));
} else {
*this.state = State::WriteSuffix(this.suffix)
}
}
State::WriteSuffix(buf) => {
while !buf.is_empty() {
let n = ready!(this.writer.as_mut().poll_write(cx, buf))?;
if n == 0 {
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
}
let (_, rest) = std::mem::replace(buf, &[]).split_at(n);
*buf = rest;
}
*this.state = State::Idle;
return Poll::Ready(Ok(4 + this.prefix.len() + data.len() + this.suffix.len()));
}
}
}
}
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
let this = self.project();
this.writer.poll_flush(cx)
}
fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
let this = self.project();
this.writer.poll_close(cx)
}
}
async fn prefixed_and_suffixed_data_to_write(
prefix: &[u8],
data: &[u8],
suffix: &[u8],
mut out: impl AsyncWrite + Unpin,
) -> io::Result<usize> {
let data_len = prefix.len() + data.len() + suffix.len();
if data_len > MAX_DATA_LEN {
return Err(into_io_err(Error::DataLengthLimitExceeded(data_len)));
}
if data.is_empty() {
return Err(into_io_err(Error::DataIsEmpty));
}
let data_len = data_len + 4;
let buf = u16_to_hex(data_len as u16);
out.write_all(&buf).await?;
if !prefix.is_empty() {
out.write_all(prefix).await?;
}
out.write_all(data).await?;
if !suffix.is_empty() {
out.write_all(suffix).await?;
}
Ok(data_len)
}
async fn prefixed_data_to_write(prefix: &[u8], data: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> {
prefixed_and_suffixed_data_to_write(prefix, data, &[], out).await
}
/// Write a `text` message to `out`, which is assured to end in a newline.
pub async fn text_to_write(text: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> {
prefixed_and_suffixed_data_to_write(&[], text, &[b'\n'], out).await
}
/// Write a `data` message to `out`.
pub async fn data_to_write(data: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> {
prefixed_data_to_write(&[], data, out).await
}
/// Write an error `message` to `out`.
pub async fn error_to_write(message: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> {
prefixed_data_to_write(ERR_PREFIX, message, out).await
}
/// Write a response-end message to `out`.
pub async fn response_end_to_write(mut out: impl AsyncWrite + Unpin) -> io::Result<usize> {
out.write_all(RESPONSE_END_LINE).await?;
Ok(4)
}
/// Write a delim message to `out`.
pub async fn delim_to_write(mut out: impl AsyncWrite + Unpin) -> io::Result<usize> {
out.write_all(DELIMITER_LINE).await?;
Ok(4)
}
/// Write a flush message to `out`.
pub async fn flush_to_write(mut out: impl AsyncWrite + Unpin) -> io::Result<usize> {
out.write_all(FLUSH_LINE).await?;
Ok(4)
}
/// Write `data` of `kind` to `out` using side-band encoding.
pub async fn band_to_write(kind: Channel, data: &[u8], out: impl AsyncWrite + Unpin) -> io::Result<usize> {
prefixed_data_to_write(&[kind as u8], data, out).await
}