Struct GlobalRateLimitedSink 

pub struct GlobalRateLimitedSink<S> {
    inner: S,
    acquirer: BandwidthAcquirer,
    tokens: u64,
    permit: Option<Permit>,
}

A Sink wrapper that acquires bandwidth before forwarding each item.

Every item costs the same fixed number of tokens given to Self::new, so this is intended for sinks whose items are of roughly the same size, such as Tor cells :).

Fields

inner: S

The underlying sink items are forwarded to.

acquirer: BandwidthAcquirer

Acquirer used to get a Permit from the pool for each item.

tokens: u64

The number of tokens each item costs, requested from the pool per item.

permit: Option<Permit>

The permit for the next item acquired by Sink::poll_ready.

It is kept here across poll_ready calls so we never request a grant twice for the same item. It is consumed by Sink::start_send. If the sink is dropped a permit, it is refunded to the pool.

Implementations

impl<S> GlobalRateLimitedSink<S>

pub(crate) fn project<'pin>( self: Pin<&'pin mut Self>, ) -> __GlobalRateLimitedSinkProjection<'pin, S>

pub(crate) fn project_ref<'pin>( self: Pin<&'pin Self>, ) -> __GlobalRateLimitedSinkProjectionRef<'pin, S>

impl<S> GlobalRateLimitedSink<S>

pub fn new(inner: S, acquirer: BandwidthAcquirer, tokens: u64) -> Self

Construct a sink that spends tokens tokens from the acquirer’s pool for every item it forwards.

Trait Implementations

impl<S: Debug> Debug for GlobalRateLimitedSink<S>

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

Formats the value using the given formatter.

impl<S, Item> Sink<Item> for GlobalRateLimitedSink<S>

where S: Sink<Item>,

type Error = GlobalRateLimitedError<<S as Sink<Item>>::Error>

The type of value produced by the sink when an error occurs.

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

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

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

Flush any remaining output from this sink.

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

Flush any remaining output and close this sink, if necessary.

impl<'pin, S> Unpin for GlobalRateLimitedSink<S>

where PinnedFieldsOf<__GlobalRateLimitedSink<'pin, S>>: Unpin,