touch_ratelimit 0.1.0

A composable, extensible rate limiting crate for Rust
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
43
44
45
46
47
48
49
50

use std::collections::HashMap;

use parking_lot::Mutex;

use crate::{bucket::RateLimiter, storage::RateLimitStore};

/// In-memory rate limit storage.
///
/// This store keeps all rate-limiting state in the application's memory.
/// Each unique key is associated with a separate rate limiter instance.
///
/// ## Characteristics
///
/// - Fast
/// - No external dependencies
/// - State is lost on restart
/// - Not shared across multiple processes
pub struct InMemoryStore<L: RateLimiter> {
    buckets: Mutex<HashMap<String, L>>,
    factory: Box<dyn Fn() -> L + Send + Sync>,
}

impl<L> InMemoryStore<L>
where
    L: RateLimiter,
{
    /// Create a new in-memory store using the provided limiter factory.
    ///
    /// The factory is called whenever a new key is encountered.
    pub fn new(factory: impl Fn() -> L + Send + Sync + 'static) -> Self {
        Self {
            buckets: Mutex::new(HashMap::new()),
            factory: Box::new(factory),
        }
    }
}

impl<L> RateLimitStore for InMemoryStore<L>
where
    L: RateLimiter,
{
    fn allow(&self, key: &str) -> bool {
        let mut map = self.buckets.lock();
        let limiter = map
            .entry(key.to_string())
            .or_insert_with(|| (self.factory)());

        limiter.allow()
    }
}