Struct hrpc::server::layer::ratelimit::RateLimitLayer

pub struct RateLimitLayer<ExtractKey, BypassForKey> { /* private fields */ }

Enforces a rate limit on the number of requests the underlying service can handle over a period of time.

Read module documentation for more information.

Implementations

impl RateLimitLayer<fn(_: &mut BoxRequest) -> Option<()>, fn(_: &()) -> bool>

pub fn new(num: u64, per: Duration) -> Self

Create new rate limit layer.

impl<ExtractKey, BypassForKey> RateLimitLayer<ExtractKey, BypassForKey>

pub fn set_key_fns<NewBypassForKey, NewExtractKeyFn, NewKey>(
    self,
    extract: NewExtractKeyFn,
    bypass: NewBypassForKey
) -> RateLimitLayer<NewExtractKeyFn, NewBypassForKey> where
    NewBypassForKey: Fn(&NewKey) -> bool + Clone,
    NewExtractKeyFn: Fn(&mut BoxRequest) -> Option<NewKey> + Clone,
    NewKey: Eq + Hash, 

Set the key extraction and bypass functions.

// create a rate limit layer that uses SocketAddr as keys
// to distinguish connections and use seperate state for them
let layer = RateLimitLayer::new(5, Duration::from_secs(10))
    .set_key_fns(
        // extract ip addr from request
        |req| req.extensions().get::<SocketAddr>().map(|addr| addr.ip()),
        // bypass ratelimit for loopback ips
        |key| key.is_loopback(),
    );

Trait Implementations

impl<ExtractKey: Clone, BypassForKey: Clone> Clone for RateLimitLayer<ExtractKey, BypassForKey>

fn clone(&self) -> RateLimitLayer<ExtractKey, BypassForKey>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<BypassForKey, ExtractKey, Key, S> Layer<S> for RateLimitLayer<ExtractKey, BypassForKey> where
    ExtractKey: Fn(&mut BoxRequest) -> Option<Key> + Clone,
    BypassForKey: Fn(&Key) -> bool + Clone,
    Key: Eq + Hash, 

type Service = RateLimit<S, ExtractKey, BypassForKey, Key>

The wrapped service

fn layer(&self, service: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.