mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-04 05:17:39 +03:00
Code Issues Projects Releases Packages Wiki Activity

change recv/poll_recv api

Browse source
This commit is contained in:
Nikolay Kim 2021-12-22 02:13:02 +06:00
parent 2e7547948e
commit fd97208a01
17 changed files with 119 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

8
ntex-io/src/dispatcher.rs
View file

@ -221,21 +221,21 @@ where
Poll::Ready(()) => {
// decode incoming bytes if buffer is ready
match io.poll_recv(&slf.shared.codec, cx) {
Poll::Ready(Some(Ok(el))) => {
Poll::Ready(Ok(Some(el))) => {
slf.update_keepalive();
DispatchItem::Item(el)
}
Poll::Ready(Some(Err(Either::Left(err)))) => {
Poll::Ready(Err(Either::Left(err))) => {
slf.st.set(DispatcherState::Stop);
slf.unregister_keepalive();
DispatchItem::DecoderError(err)
}
Poll::Ready(Some(Err(Either::Right(err)))) => {
Poll::Ready(Err(Either::Right(err))) => {
slf.st.set(DispatcherState::Stop);
slf.unregister_keepalive();
DispatchItem::Disconnect(Some(err))
}
Poll::Ready(None) => {
Poll::Ready(Ok(None)) => {
DispatchItem::Disconnect(None)
}
Poll::Pending => {

104
ntex-io/src/io.rs
View file

@ -410,7 +410,7 @@ impl<F> Io<F> {
pub async fn recv<U>(
&self,
codec: &U,
) -> Option<Result<U::Item, Either<U::Error, io::Error>>>
) -> Result<Option<U::Item>, Either<U::Error, io::Error>>
where
U: Decoder,
{
@ -418,8 +418,8 @@ impl<F> Io<F> {
}
#[inline]
/// Wake read task and instruct to read more data
pub async fn read_ready(&self) -> Option<io::Result<()>> {
/// Wait until read becomes ready.
pub async fn read_ready(&self) -> io::Result<Option<()>> {
poll_fn(|cx| self.poll_read_ready(cx)).await
}
@ -442,8 +442,8 @@ impl<F> Io<F> {
/// Encode item, send to a peer
pub async fn send<U>(
&self,
item: U::Item,
codec: &U,
item: U::Item,
) -> Result<(), Either<U::Error, io::Error>>
where
U: Encoder,
@ -470,22 +470,31 @@ impl<F> Io<F> {
}
#[inline]
/// Shut down connection
/// Shut down io stream
pub async fn shutdown(&self) -> Result<(), io::Error> {
poll_fn(|cx| self.poll_shutdown(cx)).await
}
#[inline]
/// Wake read task and instruct to read more data
/// Polls for read readiness.
///
/// Read task is awake only if back-pressure is enabled
/// otherwise it is already awake. Buffer read status gets clean up.
pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<Option<io::Result<()>>> {
/// If the io stream is not currently ready for reading,
/// this method will store a clone of the Waker from the provided Context.
/// When the io stream becomes ready for reading, Waker::wake will be called on the waker.
///
/// Return value
/// The function returns:
///
/// `Poll::Pending` if the io stream is not ready for reading.
/// `Poll::Ready(Ok(Some(()))))` if the io stream is ready for reading.
/// `Poll::Ready(Ok(None))` if io stream is disconnected
/// `Some(Poll::Ready(Err(e)))` if an error is encountered.
pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result<Option<()>>> {
if !self.0 .0.is_io_open() {
if let Some(err) = self.0 .0.error.take() {
Poll::Ready(Some(Err(err)))
Poll::Ready(Err(err))
} else {
Poll::Ready(None)
Poll::Ready(Ok(None))
}
} else {
self.0 .0.dispatch_task.register(cx.waker());
@ -498,7 +507,7 @@ impl<F> Io<F> {
self.0 .0.read_task.wake();
self.0 .0.flags.set(flags);
if ready {
Poll::Ready(Some(Ok(())))
Poll::Ready(Ok(Some(())))
} else {
Poll::Pending
}
@ -507,7 +516,7 @@ impl<F> Io<F> {
flags.remove(Flags::RD_READY);
self.0 .0.flags.set(flags);
self.0 .0.read_task.wake();
Poll::Ready(Some(Ok(())))
Poll::Ready(Ok(Some(())))
} else {
Poll::Pending
}
@ -523,18 +532,18 @@ impl<F> Io<F> {
&self,
codec: &U,
cx: &mut Context<'_>,
) -> Poll<Option<Result<U::Item, Either<U::Error, io::Error>>>>
) -> Poll<Result<Option<U::Item>, Either<U::Error, io::Error>>>
where
U: Decoder,
{
match self.decode(codec) {
Ok(Some(el)) => Poll::Ready(Some(Ok(el))),
Ok(Some(el)) => Poll::Ready(Ok(Some(el))),
Ok(None) => match self.poll_read_ready(cx) {
Poll::Pending | Poll::Ready(Some(Ok(()))) => Poll::Pending,
Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(Either::Right(e)))),
Poll::Ready(None) => Poll::Ready(None),
Poll::Pending | Poll::Ready(Ok(Some(()))) => Poll::Pending,
Poll::Ready(Err(e)) => Poll::Ready(Err(Either::Right(e))),
Poll::Ready(Ok(None)) => Poll::Ready(Ok(None)),
},
Err(err) => Poll::Ready(Some(Err(Either::Left(err)))),
Err(err) => Poll::Ready(Err(Either::Left(err))),
}
}
@ -602,7 +611,7 @@ impl<F> Io<F> {
}
#[inline]
/// Shut down connection
/// Shut down io stream
pub fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
let flags = self.flags();
@ -621,61 +630,6 @@ impl<F> Io<F> {
}
}
}
#[doc(hidden)]
#[deprecated]
#[inline]
pub async fn next<U>(
&self,
codec: &U,
) -> Option<Result<U::Item, Either<U::Error, io::Error>>>
where
U: Decoder,
{
self.recv(codec).await
}
#[doc(hidden)]
#[deprecated]
#[inline]
pub async fn write_ready(&self, full: bool) -> Result<(), io::Error> {
poll_fn(|cx| self.poll_flush(cx, full)).await
}
#[doc(hidden)]
#[deprecated]
#[inline]
pub fn poll_write_ready(
&self,
cx: &mut Context<'_>,
full: bool,
) -> Poll<io::Result<()>> {
self.poll_flush(cx, full)
}
#[doc(hidden)]
#[deprecated]
#[inline]
#[allow(clippy::type_complexity)]
pub fn poll_read_next<U>(
&self,
codec: &U,
cx: &mut Context<'_>,
) -> Poll<Option<Result<U::Item, Either<U::Error, io::Error>>>>
where
U: Decoder,
{
self.poll_recv(codec, cx)
}
#[doc(hidden)]
#[deprecated]
#[inline]
pub fn enable_write_backpressure(&self, cx: &mut Context<'_>) {
log::trace!("enable write back-pressure for dispatcher");
self.0 .0.insert_flags(Flags::WR_BACKPRESSURE);
self.0 .0.dispatch_task.register(cx.waker());
}
}
impl<F> Drop for Io<F> {

12
ntex-io/src/ioref.rs
View file

@ -321,7 +321,7 @@ mod tests {
client.read_error(io::Error::new(io::ErrorKind::Other, "err"));
let msg = state.recv(&BytesCodec).await;
assert!(msg.unwrap().is_err());
assert!(msg.is_err());
assert!(state.flags().contains(Flags::IO_ERR));
assert!(state.flags().contains(Flags::DSP_STOP));
@ -332,7 +332,7 @@ mod tests {
client.read_error(io::Error::new(io::ErrorKind::Other, "err"));
let res = poll_fn(|cx| Poll::Ready(state.poll_recv(&BytesCodec, cx))).await;
if let Poll::Ready(msg) = res {
assert!(msg.unwrap().is_err());
assert!(msg.is_err());
assert!(state.flags().contains(Flags::IO_ERR));
assert!(state.flags().contains(Flags::DSP_STOP));
}
@ -341,14 +341,14 @@ mod tests {
client.remote_buffer_cap(1024);
let state = Io::new(server);
state
.send(Bytes::from_static(b"test"), &BytesCodec)
.send(&BytesCodec, Bytes::from_static(b"test"))
.await
.unwrap();
let buf = client.read().await.unwrap();
assert_eq!(buf, Bytes::from_static(b"test"));
client.write_error(io::Error::new(io::ErrorKind::Other, "err"));
let res = state.send(Bytes::from_static(b"test"), &BytesCodec).await;
let res = state.send(&BytesCodec, Bytes::from_static(b"test")).await;
assert!(res.is_err());
assert!(state.flags().contains(Flags::IO_ERR));
assert!(state.flags().contains(Flags::DSP_STOP));
@ -492,7 +492,7 @@ mod tests {
assert_eq!(msg, Bytes::from_static(BIN));
state
.send(Bytes::from_static(b"test"), &BytesCodec)
.send(&BytesCodec, Bytes::from_static(b"test"))
.await
.unwrap();
let buf = client.read().await.unwrap();
@ -523,7 +523,7 @@ mod tests {
assert_eq!(msg, Bytes::from_static(BIN));
state
.send(Bytes::from_static(b"test"), &BytesCodec)
.send(&BytesCodec, Bytes::from_static(b"test"))
.await
.unwrap();
let buf = client.read().await.unwrap();

18
ntex-io/src/tokio_impl.rs
View file

@ -2,7 +2,7 @@ use std::task::{Context, Poll};
use std::{any, cell::RefCell, cmp, future::Future, io, mem, pin::Pin, rc::Rc};
use ntex_bytes::{Buf, BufMut, BytesMut};
use ntex_util::time::{sleep, Sleep};
use ntex_util::{ready, time::sleep, time::Sleep};
use tok_io::io::{AsyncRead, AsyncWrite, ReadBuf};
use tok_io::net::TcpStream;
@ -362,10 +362,10 @@ impl<F: Filter> AsyncRead for Io<F> {
});
if len == 0 {
match self.poll_read_ready(cx) {
Poll::Pending | Poll::Ready(Some(Ok(()))) => Poll::Pending,
Poll::Ready(Some(Err(e))) => Poll::Ready(Err(e)),
Poll::Ready(None) => Poll::Ready(Ok(())),
match ready!(self.poll_read_ready(cx)) {
Ok(Some(())) => Poll::Pending,
Ok(None) => Poll::Ready(Ok(())),
Err(e) => Poll::Ready(Err(e)),
}
} else {
Poll::Ready(Ok(()))
@ -407,10 +407,10 @@ impl AsyncRead for IoBoxed {
});
if len == 0 {
match self.poll_read_ready(cx) {
Poll::Pending | Poll::Ready(Some(Ok(()))) => Poll::Pending,
Poll::Ready(Some(Err(e))) => Poll::Ready(Err(e)),
Poll::Ready(None) => Poll::Ready(Ok(())),
match ready!(self.poll_read_ready(cx)) {
Ok(Some(())) => Poll::Pending,
Err(e) => Poll::Ready(Err(e)),
Ok(None) => Poll::Ready(Ok(())),
}
} else {
Poll::Ready(Ok(()))