Struct Wrapper

pub struct Wrapper<'a, R: Runtime, T> { /* private fields */ }

A wrapper that wraps a future, a stream or an async reader/writer and resets the timeout upon a new event.

WARNING: THIS WILL NOT TIME OUT AUTOMATICALLY. THE TIMEOUT MUST BE AWAITED SOMEWHERE ELSE. See example below.

• In case of a future, timeout will be reset upon future completion
• In case of an AsyncRead object, timeout will be reset upon a successful read or seek.
• In case of an AsyncWrite object, timeout will be reset upon a successful write. It will not be reset upon a shutdown or a flush, please notify me if you think this should be changed!
• In case of a Stream object, timeout will be reset upon stream advancement.

Since Wrapper::new accepts a shared reference to Timeout, you can make multiple objects use a single timeout. This means the timeout will only expire when all objects stopped having new events.

Example

// Proxy with timeout
use std::{io, time::Duration};
use async_shared_timeout::{runtime, Timeout, Wrapper};

let runtime = runtime::Tokio::new();
let timeout_dur = Duration::from_secs(10);
let timeout = Timeout::new(runtime, timeout_dur);
let mut remote_stream = Wrapper::new(remote_stream, &timeout);
let mut local_stream = Wrapper::new(local_stream, &timeout);
let (copied_a_to_b, copied_b_to_a) = tokio::select! {
    _ = timeout.wait() => {
        return Err(io::Error::new(io::ErrorKind::TimedOut, "stream timeout"))
    }
    x = tokio::io::copy_bidirectional(&mut remote_stream, &mut local_stream) => {
        x?
    }
};

Implementations

impl<'a, R: Runtime, T> Wrapper<'a, R, T>

pub fn new(inner: T, timeout: &'a Timeout<R>) -> Self

Create a wrapper around an object that will update the given timeout upon successful operations

Arguments

• inner - the object to be wrapped
• timeout - a reference to the timeout to be used for operations on inner
• default_timeout - on a successful operation, timeout will be reset to this value

pub fn timeout(&self) -> &Timeout<R>

The timeout reference

pub fn inner(&self) -> &T

A reference to the underlying object

pub fn inner_mut(&mut self) -> &mut T

A mutable reference to the underlying object

impl<R: Runtime, T> Wrapper<'static, R, T>

pub fn new_arc(inner: T, timeout: Arc<Timeout<R>>) -> Self

Available on crate feature std only.

Create a wrapper using a timeout behind an Arc pointer rather than a shared reference. See Wrapper::new for more info.

Trait Implementations

impl<T, R: Runtime> AsMut<T> for Wrapper<'_, R, T>

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<R: Runtime, T: AsRawFd> AsRawFd for Wrapper<'_, R, T>

Available on crate feature std and Unix only.

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<T, R: Runtime> AsRef<T> for Wrapper<'_, R, T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<R: Runtime, T: AsyncBufRead> AsyncBufRead for Wrapper<'_, R, T>

Available on crate features futures-io and read-write only.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

fn poll_fill_buf( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<&[u8]>>

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

impl<R: Runtime, T: AsyncBufRead> AsyncBufRead for Wrapper<'_, R, T>

Available on crate features tokio and read-write only.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

fn poll_fill_buf( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<&[u8]>>

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

impl<R: Runtime, T: AsyncRead> AsyncRead for Wrapper<'_, R, T>

Available on crate features futures-io and read-write only.

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8], ) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>], ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<R: Runtime, T: AsyncRead> AsyncRead for Wrapper<'_, R, T>

Available on crate features tokio and read-write only.

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<R: Runtime, T: AsyncSeek> AsyncSeek for Wrapper<'_, R, T>

Available on crate features futures-io and read-write only.

fn poll_seek( self: Pin<&mut Self>, cx: &mut Context<'_>, pos: SeekFrom, ) -> Poll<Result<u64>>

Attempt to seek to an offset, in bytes, in a stream.

impl<R: Runtime, T: AsyncSeek> AsyncSeek for Wrapper<'_, R, T>

Available on crate features tokio and read-write only.

fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> Result<()>

Attempts to seek to an offset, in bytes, in a stream.

fn poll_complete( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<u64>>

Waits for a seek operation to complete.

impl<R: Runtime, T: AsyncWrite> AsyncWrite for Wrapper<'_, R, T>

Available on crate features futures-io and read-write only.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to close the object.

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<R: Runtime, T: AsyncWrite> AsyncWrite for Wrapper<'_, R, T>

Available on crate features tokio and read-write only.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

impl<R: Runtime, T: Future> Future for Wrapper<'_, R, T>

type Output = <T as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<R: Runtime, T: Stream> Stream for Wrapper<'_, R, T>

Available on crate feature stream only.

type Item = <T as Stream>::Item

Values yielded by the stream.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

impl<'__pin, 'a, R: Runtime, T> Unpin for Wrapper<'a, R, T>

where PinnedFieldsOf<__Origin<'__pin, 'a, R, T>>: Unpin,