use std::time::{Duration, Instant};
#[derive(Debug)]
pub struct RateLimiter {
bytes_per_sec: f64,
burst_bytes: f64,
tokens: f64,
last: Instant,
}
impl RateLimiter {
pub fn new(kbps: u64) -> Self {
let bytes_per_sec = (kbps as f64) * 1000.0 / 8.0;
Self {
bytes_per_sec,
burst_bytes: bytes_per_sec.max(1.0),
tokens: bytes_per_sec.max(1.0),
last: Instant::now(),
}
}
pub fn set_kbps(&mut self, kbps: u64) {
self.bytes_per_sec = (kbps as f64) * 1000.0 / 8.0;
self.burst_bytes = self.bytes_per_sec.max(1.0);
}
pub fn acquire(&mut self, n: usize) {
let n = n as f64;
loop {
self.refill();
if self.tokens >= n {
self.tokens -= n;
return;
}
let needed = n - self.tokens;
let secs = needed / self.bytes_per_sec.max(1.0);
std::thread::sleep(Duration::from_secs_f64(secs));
}
}
fn refill(&mut self) {
let now = Instant::now();
let elapsed = now.duration_since(self.last).as_secs_f64();
self.last = now;
self.tokens = (self.tokens + elapsed * self.bytes_per_sec).min(self.burst_bytes);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pacing_holds_average() {
let mut rl = RateLimiter::new(80);
rl.acquire(10_000);
let start = Instant::now();
for _ in 0..5 {
rl.acquire(2_000);
}
let elapsed = start.elapsed();
assert!(
elapsed >= Duration::from_millis(900),
"expected ~1s, got {:?}",
elapsed
);
}
}