use reqwest::header::HeaderMap;
use std::sync::{Mutex, MutexGuard, PoisonError};
use std::time::Duration;
use tokio::time::Instant;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RateLimit {
pub limit: u32,
pub interval: Duration,
}
impl RateLimit {
pub const CONSERVATIVE: Self = Self {
limit: 5,
interval: Duration::from_secs(1),
};
pub fn spacing(&self) -> Duration {
self.interval / self.limit.max(1)
}
pub fn from_headers(headers: &HeaderMap) -> Option<Self> {
let limit = header(headers, "x-rate-limit-limit")?.trim().parse().ok()?;
let interval = parse_interval(header(headers, "x-rate-limit-interval")?)?;
Some(Self { limit, interval })
}
}
impl Default for RateLimit {
fn default() -> Self {
Self::CONSERVATIVE
}
}
fn header<'a>(headers: &'a HeaderMap, name: &str) -> Option<&'a str> {
headers.get(name)?.to_str().ok()
}
fn parse_interval(raw: &str) -> Option<Duration> {
let raw = raw.trim();
let unit_at = raw.find(|c: char| !c.is_ascii_digit())?;
let (amount, unit) = raw.split_at(unit_at);
let amount: u64 = amount.parse().ok()?;
match unit {
"ms" => Some(Duration::from_millis(amount)),
"s" => Some(Duration::from_secs(amount)),
"m" => Some(Duration::from_secs(amount.checked_mul(60)?)),
"h" => Some(Duration::from_secs(amount.checked_mul(3_600)?)),
_ => None,
}
}
pub(crate) fn retry_after(headers: &HeaderMap) -> Option<Duration> {
let seconds = header(headers, "retry-after")?.trim().parse().ok()?;
Some(Duration::from_secs(seconds))
}
#[derive(Debug)]
pub(crate) struct Limiter {
state: Mutex<State>,
}
#[derive(Debug)]
struct State {
rate: RateLimit,
next_slot: Option<Instant>,
pool: Option<String>,
}
impl Limiter {
pub(crate) fn new(rate: RateLimit) -> Self {
Self {
state: Mutex::new(State {
rate,
next_slot: None,
pool: None,
}),
}
}
pub(crate) async fn acquire(&self) {
let slot = {
let mut state = self.lock();
let now = Instant::now();
let slot = state.next_slot.map_or(now, |slot| slot.max(now));
state.next_slot = Some(slot + state.rate.spacing());
slot
};
tokio::time::sleep_until(slot).await;
}
pub(crate) fn observe(&self, headers: &HeaderMap) {
let rate = RateLimit::from_headers(headers);
let pool = header(headers, "x-api-pool").map(str::to_owned);
let mut state = self.lock();
if let Some(rate) = rate {
state.rate = rate;
}
if pool.is_some() {
state.pool = pool;
}
}
pub(crate) fn back_off(&self, delay: Duration) {
let mut state = self.lock();
let resume = Instant::now() + delay;
state.next_slot = Some(state.next_slot.map_or(resume, |slot| slot.max(resume)));
}
pub(crate) fn rate(&self) -> RateLimit {
self.lock().rate
}
pub(crate) fn pool(&self) -> Option<String> {
self.lock().pool.clone()
}
fn lock(&self) -> MutexGuard<'_, State> {
self.state.lock().unwrap_or_else(PoisonError::into_inner)
}
}
#[cfg(test)]
mod tests {
use super::*;
use reqwest::header::{HeaderMap, HeaderValue};
fn headers(pairs: &[(&'static str, &str)]) -> HeaderMap {
let mut headers = HeaderMap::new();
for (name, value) in pairs {
headers.insert(*name, HeaderValue::from_str(value).unwrap());
}
headers
}
#[test]
fn the_budget_is_read_from_the_headers_crossref_sends() {
let rate = RateLimit::from_headers(&headers(&[
("x-rate-limit-limit", "50"),
("x-rate-limit-interval", "1s"),
]));
assert_eq!(
Some(RateLimit {
limit: 50,
interval: Duration::from_secs(1)
}),
rate
);
}
#[test]
fn a_half_reported_budget_is_no_budget() {
assert_eq!(
None,
RateLimit::from_headers(&headers(&[("x-rate-limit-limit", "50")]))
);
assert_eq!(
None,
RateLimit::from_headers(&headers(&[
("x-rate-limit-limit", "50"),
("x-rate-limit-interval", "1 fortnight"),
]))
);
}
#[test]
fn every_interval_unit_crossref_might_use_parses() {
assert_eq!(Some(Duration::from_millis(500)), parse_interval("500ms"));
assert_eq!(Some(Duration::from_secs(1)), parse_interval("1s"));
assert_eq!(Some(Duration::from_secs(120)), parse_interval("2m"));
assert_eq!(Some(Duration::from_secs(3_600)), parse_interval("1h"));
assert_eq!(None, parse_interval("s"));
assert_eq!(None, parse_interval("12"));
}
#[test]
fn spacing_divides_the_interval_across_the_budget() {
let rate = RateLimit {
limit: 50,
interval: Duration::from_secs(1),
};
assert_eq!(Duration::from_millis(20), rate.spacing());
}
#[test]
fn a_zero_budget_does_not_divide_by_zero() {
let rate = RateLimit {
limit: 0,
interval: Duration::from_secs(1),
};
assert_eq!(Duration::from_secs(1), rate.spacing());
}
#[test]
fn retry_after_seconds_are_understood_and_dates_are_not() {
assert_eq!(
Some(Duration::from_secs(30)),
retry_after(&headers(&[("retry-after", "30")]))
);
assert_eq!(
None,
retry_after(&headers(&[(
"retry-after",
"Wed, 21 Oct 2015 07:28:00 GMT"
)]))
);
}
#[tokio::test(start_paused = true)]
async fn requests_are_spaced_across_the_interval() {
let limiter = Limiter::new(RateLimit {
limit: 4,
interval: Duration::from_secs(1),
});
let start = Instant::now();
for _ in 0..4 {
limiter.acquire().await;
}
assert_eq!(Duration::from_millis(750), start.elapsed());
}
#[tokio::test(start_paused = true)]
async fn a_backoff_holds_back_the_next_request() {
let limiter = Limiter::new(RateLimit::CONSERVATIVE);
limiter.acquire().await;
let start = Instant::now();
limiter.back_off(Duration::from_secs(5));
limiter.acquire().await;
assert_eq!(Duration::from_secs(5), start.elapsed());
}
#[test]
fn observing_a_response_replaces_the_assumed_budget() {
let limiter = Limiter::new(RateLimit::CONSERVATIVE);
limiter.observe(&headers(&[
("x-rate-limit-limit", "50"),
("x-rate-limit-interval", "1s"),
("x-api-pool", "polite"),
]));
assert_eq!(50, limiter.rate().limit);
assert_eq!(Some("polite".to_string()), limiter.pool());
limiter.observe(&HeaderMap::new());
assert_eq!(50, limiter.rate().limit);
assert_eq!(Some("polite".to_string()), limiter.pool());
}
}