anzar-shared 0.9.21

Anzar is a lightweight authentication and authorization framework that runs as a separate microservice
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use std::sync::Arc;

use crate::{config::RateLimitConfig, error::CoreError};
use dashmap::DashMap;

#[derive(Clone, Default)]
pub struct RateLimiter {
    buckets: Arc<DashMap<String, TokenBucket>>,
}
impl RateLimiter {
    pub fn check(&self, key: &str, config: &RateLimitConfig) -> Result<(), CoreError> {
        let bucket = TokenBucket::default()
            .with_bucket_size(config.capacity)
            .with_refill_rate(config.capacity)
            .with_duration(config.duration_minutes);

        let mut bucket = self.buckets.entry(key.to_string()).or_insert(bucket);
        bucket.run()
    }
}

#[derive(Clone, Debug)]
pub struct TokenBucket {
    capacity: u32,
    bucket_size: u32,
    refill_rate: u32,
    duration: chrono::Duration,
    last_refill: chrono::DateTime<chrono::Utc>,
}

impl Default for TokenBucket {
    fn default() -> Self {
        Self {
            capacity: 20,
            bucket_size: 20,
            refill_rate: 20,
            duration: chrono::Duration::minutes(15),
            last_refill: chrono::Utc::now(),
        }
    }
}

impl TokenBucket {
    pub fn with_bucket_size(mut self, bucket_size: u32) -> Self {
        self.bucket_size = bucket_size;
        self.capacity = bucket_size;
        self
    }
    pub fn with_refill_rate(mut self, refill_rate: u32) -> Self {
        self.refill_rate = refill_rate;
        self
    }
    pub fn with_duration(mut self, minutes: u32) -> Self {
        self.duration = chrono::Duration::minutes(minutes as i64);
        self
    }
}
impl TokenBucket {
    pub fn run(&mut self) -> Result<(), CoreError> {
        let time_since_refill = chrono::Utc::now() - self.last_refill;
        if time_since_refill >= self.duration {
            self.bucket_size = self.refill_rate;
            self.last_refill = chrono::Utc::now();
        }

        if self.bucket_size == 0 {
            return Err(CoreError::RateLimitExceeded {
                limit: self.capacity,
                window: self.duration,
            });
        }

        self.bucket_size -= 1;
        Ok(())
    }
}