ratelimit_meter 5.0.0

A leaky-bucket-as-a-meter rate-limiting implementation in 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
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use crate::algorithms::Algorithm;
use crate::clock;
use crate::state::DirectRateLimiter;

#[derive(Debug)]
pub enum Variant {
    GCRA,
    LeakyBucket,
}

impl Variant {
    pub const ALL: &'static [Variant; 2] = &[Variant::GCRA, Variant::LeakyBucket];
}

pub struct DirectBucket<A: Algorithm<C::Instant>, C: clock::Clock>(DirectRateLimiter<A, C>);
impl<A, C> Default for DirectBucket<A, C>
where
    C: clock::Clock,
    A: Algorithm<C::Instant>,
{
    fn default() -> Self {
        DirectBucket(DirectRateLimiter::per_second(nonzero!(50u32)))
    }
}
impl<A, C> DirectBucket<A, C>
where
    C: clock::Clock,
    A: Algorithm<C::Instant>,
{
    pub fn limiter(self) -> DirectRateLimiter<A, C> {
        self.0
    }
}

#[cfg(feature = "std")]
mod std {
    use super::*;
    use crate::{algorithms::KeyableRateLimitState, clock, KeyedRateLimiter};

    pub struct KeyedBucket<A: Algorithm<C::Instant>, C: clock::Clock>(KeyedRateLimiter<u32, A, C>)
    where
        A::BucketState: KeyableRateLimitState<A, C::Instant>;

    impl<A, C> Default for KeyedBucket<A, C>
    where
        A: Algorithm<C::Instant>,
        A::BucketState: KeyableRateLimitState<A, C::Instant>,
        C: clock::Clock,
    {
        fn default() -> Self {
            KeyedBucket(KeyedRateLimiter::per_second(nonzero!(50u32)))
        }
    }
    impl<A, C> KeyedBucket<A, C>
    where
        A: Algorithm<C::Instant>,
        A::BucketState: KeyableRateLimitState<A, C::Instant>,
        C: clock::Clock,
    {
        pub fn limiter(self) -> KeyedRateLimiter<u32, A, C> {
            self.0
        }
    }
}
#[cfg(feature = "std")]
pub use self::std::*;

// I really wish I could just have a function that returns an impl
// Trait that was usable in all the benchmarks, but alas it should not
// be so.
#[doc(hidden)]
#[macro_export]
macro_rules! bench_with_variants {
    ($variant:expr, $var:ident : $bucket:tt, $code:block) => {
        match $variant {
            $crate::test_utilities::variants::Variant::GCRA => {
                let mut $var = $bucket::<
                    ::ratelimit_meter::GCRA<<clock::DefaultClock as clock::Clock>::Instant>,
                    clock::DefaultClock,
                >::default()
                .limiter();
                $code
            }
            $crate::test_utilities::variants::Variant::LeakyBucket => {
                let mut $var = $bucket::<
                    ::ratelimit_meter::LeakyBucket<<clock::DefaultClock as clock::Clock>::Instant>,
                    clock::DefaultClock,
                >::default()
                .limiter();
                $code
            }
        }
    };
}