twitchchat 0.14.8

interface to the irc-side of twitch's chat system
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

use crate::rate_limit::{RateClass, RateLimit};
use futures_lite::{AsyncWrite, AsyncWriteExt};
use std::{collections::VecDeque, time::Duration};

pub struct RateLimitedEncoder {
    pub(crate) rate_limit: RateLimit,
    pub(crate) queue: VecDeque<Box<[u8]>>,
}

impl RateLimitedEncoder {
    pub async fn drain_until_blocked<W>(
        &mut self,
        name: &str,
        limit: &mut u64,
        sink: &mut W,
    ) -> std::io::Result<()>
    where
        W: AsyncWrite + Send + Sync + Unpin + ?Sized,
    {
        while let Some(data) = self.queue.pop_front() {
            match self.rate_limit.consume(1) {
                Ok(..) => {
                    *limit = limit.saturating_sub(1);
                    log::trace!(
                        target: "twitchchat::encoder",
                        "> {}",
                        std::str::from_utf8(&*data).unwrap().escape_debug()
                    );
                    sink.write_all(&*data).await?;
                }
                Err(..) => {
                    log::warn!(
                        target: "twitchchat::rate_limit",
                        "local rate limit for '{}' hit",
                        name
                    );
                    break;
                }
            }
            if *limit == 0 {
                break;
            }
        }

        Ok(())
    }

    pub fn enqueue(&mut self, msg: Box<[u8]>) {
        self.queue.push_back(msg);
    }
}

pub struct PreviousRate {
    pub cap: u64,
    pub period: Duration,
}

impl Default for PreviousRate {
    fn default() -> Self {
        Self {
            cap: RateClass::Regular.tickets(),
            period: RateClass::period(),
        }
    }
}