Struct RateLimitedWriter 

pub struct RateLimitedWriter<W: AsyncWrite, P: SleepProvider> {
    bucket: TokenBucket<Instant>,
    sleep_provider: P,
    wake_when_bytes_available: NonZero<u64>,
    inner: W,
    sleep_fut: Option<SyncFuture<P::SleepFuture>>,
}

A rate-limited async writer.

This can be used as a wrapper around an existing AsyncWrite writer.

Fields

bucket: TokenBucket<Instant>

The token bucket.

sleep_provider: P

The sleep provider, for getting the current time and creating new sleep futures.

While we use Instant for the time, we should always get the time from this SleepProvider. For example, use SleepProvider::now(), not Instant::now() or InstantExt::get.

wake_when_bytes_available: NonZero<u64>

See RateLimitedWriterConfig::wake_when_bytes_available.

inner: W

The inner writer.

sleep_fut: Option<SyncFuture<P::SleepFuture>>

We need to store the sleep future if AsyncWrite::poll_write() blocks.

Implementations

impl<W: AsyncWrite, P: SleepProvider> RateLimitedWriter<W, P>

pub(crate) fn project<'pin>( self: Pin<&'pin mut Self>, ) -> __RateLimitedWriterProjection<'pin, W, P>

pub(crate) fn project_ref<'pin>( self: Pin<&'pin Self>, ) -> __RateLimitedWriterProjectionRef<'pin, W, P>

impl<W, P> RateLimitedWriter<W, P>

where W: AsyncWrite, P: SleepProvider,

pub fn new( writer: W, config: &RateLimitedWriterConfig, sleep_provider: P, ) -> Self

Create a new RateLimitedWriter.

fn from_token_bucket( writer: W, bucket: TokenBucket<Instant>, wake_when_bytes_available: NonZero<u64>, sleep_provider: P, ) -> Self

Create a new RateLimitedWriter from a TokenBucket.

The token bucket must have only been used with times created by sleep_provider.

pub fn inner(&self) -> &W

Access the inner AsyncWrite writer.

pub fn adjust( self: &mut Pin<&mut Self>, now: Instant, config: &RateLimitedWriterConfig, )

Adjust the refill rate and burst.

A rate and/or burst of 0 is allowed.

pub(super) fn sleep_provider(&self) -> &P

The sleep provider.

We don’t want this to be generally accessible, only to other token bucket-related modules like DynamicRateLimitedWriter.

fn register_sleep( sleep_fut: &mut Pin<&mut Option<SyncFuture<P::SleepFuture>>>, sleep_provider: &mut P, cx: &mut Context<'_>, duration: Option<Duration>, ) -> Poll<()>

Configure this writer to sleep for duration.

A duration of None is interpreted as “forever”.

It’s considered a bug if asked to sleep for Duration::ZERO time.

Trait Implementations

impl<W, P> AsyncWrite for RateLimitedWriter<W, P>

where W: AsyncWrite, P: SleepProvider,

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_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

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<(), Error>>

Attempt to close the object.

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

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

impl<W, P> AsyncWrite for RateLimitedWriter<W, P>

where W: AsyncWrite, P: SleepProvider,

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

Attempt to write bytes from buf into the object.

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

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

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

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

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.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<W: AsyncWrite, P: SleepProvider> Debug for RateLimitedWriter<W, P>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'pin, W: AsyncWrite, P: SleepProvider> Unpin for RateLimitedWriter<W, P>

where PinnedFieldsOf<__RateLimitedWriter<'pin, W, P>>: Unpin,