tower-rate-limiter 0.1.0

Keyed fixed-window rate limiting middleware for Tower
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

//! Tower layer implementation.

use std::sync::Arc;

use tower::Layer;

use super::builder::RateLimitConfig;
use super::charge::DefaultResponseFactory;
use super::key_extractor::KeyExtractor;
use super::service::RateLimitService;

/// Layer that applies the [`RateLimitService`].
#[derive(Clone)]
#[must_use]
pub struct RateLimitLayer<K, S = (), P = u64, F = DefaultResponseFactory> {
    pub(crate) key_extractor: K,
    pub(crate) store: S,
    pub(crate) limit_provider: P,
    pub(crate) response_factory: F,
    pub(crate) config: Arc<RateLimitConfig>,
}

impl<K, S, P, F, Inner> Layer<Inner> for RateLimitLayer<K, S, P, F>
where
    K: KeyExtractor,
    S: Clone,
    P: Clone,
    F: Clone,
{
    type Service = RateLimitService<Inner, K, S, P, F>;

    fn layer(&self, inner: Inner) -> Self::Service {
        RateLimitService {
            inner,
            key_extractor: self.key_extractor.clone(),
            store: self.store.clone(),
            limit_provider: self.limit_provider.clone(),
            response_factory: self.response_factory.clone(),
            config: Arc::clone(&self.config),
        }
    }
}