Struct actix_ratelimit::middleware::RateLimiter

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

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);
}

Methods

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 = AWError> + '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::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<Self::Transform, Self::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
    F: Fn(Self::InitError) -> E + Clone, 

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