rosu-render 0.5.1

An o!rdr wrapper to render osu! replays
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

use std::{sync::Arc, time::Duration};

use leaky_bucket::RateLimiter;

use super::builder::RatelimitBuilder;

pub(super) struct Ratelimiter {
    pub(super) general: Arc<RateLimiter>,
    pub(super) send_render: Arc<RateLimiter>,
}

#[derive(Copy, Clone)]
pub(crate) enum RatelimiterKind {
    General,
    SendRender,
}

impl Ratelimiter {
    pub fn new(builder: &RatelimitBuilder) -> Self {
        let RatelimitBuilder {
            interval,
            refill,
            max,
        } = builder;

        info!("o!rdr ratelimit: Refill {refill} every {interval}ms, up to {max}");

        Self {
            general: Arc::new(
                // 10 per minute
                RateLimiter::builder()
                    .max(10)
                    .initial(10)
                    .refill(1)
                    .interval(Duration::from_secs(6))
                    .build(),
            ),
            send_render: Arc::new(
                RateLimiter::builder()
                    .max(*max as usize)
                    .initial(*max as usize)
                    .refill(*refill as usize)
                    .interval(Duration::from_millis(*interval))
                    .build(),
            ),
        }
    }

    pub fn get(&self, kind: RatelimiterKind) -> Arc<RateLimiter> {
        match kind {
            RatelimiterKind::General => Arc::clone(&self.general),
            RatelimiterKind::SendRender => Arc::clone(&self.send_render),
        }
    }
}