Struct RateLimiter 

pub struct RateLimiter<T>
where
    T: Handler<ActorMessage> + Send + Sync + 'static,
    T::Context: ToEnvelope<T, ActorMessage>,
{ /* private fields */ }

Type that implements the ratelimit middleware.

This accepts interval which specifies the window size, max_requests which specifies the maximum number of requests in that window, and store which is essentially a data store used to store client access information. Entry is removed from the store after interval.

Example

use actix_ratelimit::{MemoryStore, MemoryStoreActor};
use actix_ratelimit::RateLimiter;

#[actix_rt::main]
async fn main() {
    let store = MemoryStore::new();
    let ratelimiter = RateLimiter::new(
                            MemoryStoreActor::from(store.clone()).start())
                        .with_interval(Duration::from_secs(60))
                        .with_max_requests(100);
}

Implementations

impl<T> RateLimiter<T>

where T: Handler<ActorMessage> + Send + Sync + 'static, <T as Actor>::Context: ToEnvelope<T, ActorMessage>,

pub fn new(store: Addr<T>) -> Self

Creates a new instance of RateLimiter with the provided address of StoreActor.

pub fn with_interval(self, interval: Duration) -> Self

Specify the interval. The counter for a client is reset after this interval

pub fn with_max_requests(self, max_requests: usize) -> Self

Specify the maximum number of requests allowed in the given interval.

pub fn with_identifier<F: Fn(&ServiceRequest) -> Result<String, ARError> + 'static>( self, identifier: F, ) -> Self

Function to get the identifier for the client request

Trait Implementations

impl<T, S, B> Transform<S> for RateLimiter<T>

where T: Handler<ActorMessage> + Send + Sync + 'static, T::Context: ToEnvelope<T, ActorMessage>, S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, S::Future: 'static, B: 'static,

type Request = ServiceRequest

Requests handled by the service.

type Response = ServiceResponse<B>

Responses given by the service.

type Error = <S as Service>::Error

Errors produced by the service.

type InitError = ()

Errors produced while building a transform service.

type Transform = RateLimitMiddleware<S, T>

The TransformService value created by this factory

type Future = Ready<Result<<RateLimiter<T> as Transform<S>>::Transform, <RateLimiter<T> as Transform<S>>::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously

fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Map this transforms’s factory error to a different error, returning a new transform service factory.