use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::time::{Duration, Instant};
use reqwest::StatusCode;
use reqwest::header::HeaderMap;
use crate::config::Config;
pub const DEFAULT_MAX_RETRIES: u32 = 3;
pub const DEFAULT_RETRY_BASE_MS: u64 = 200;
pub const DEFAULT_RETRY_MAX_DELAY_MS: u64 = 30_000;
pub const HARD_MAX_RETRIES: u32 = 10;
pub const HARD_MAX_DELAY_MS: u64 = 60_000;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RetryConfig {
pub max_retries: u32,
pub base_ms: u64,
pub max_delay_ms: u64,
pub enabled: bool,
}
impl RetryConfig {
pub fn from_config(cfg: &Config) -> Self {
let max_retries = cfg.max_retries.min(HARD_MAX_RETRIES);
let base_ms = if cfg.retry_base_ms == 0 {
DEFAULT_RETRY_BASE_MS
} else {
cfg.retry_base_ms
};
let max_delay_ms = cfg.retry_max_delay_ms.min(HARD_MAX_DELAY_MS).max(base_ms);
let enabled = !cfg.disable_retry && max_retries > 0;
Self {
max_retries,
base_ms,
max_delay_ms,
enabled,
}
}
pub fn max_attempts(self) -> u32 {
if !self.enabled {
1
} else {
self.max_retries.saturating_add(1)
}
}
pub fn may_retry(self, attempt: u32) -> bool {
self.enabled && attempt < self.max_attempts()
}
pub fn delay_for_attempt(self, attempt: u32) -> Duration {
backoff_full_jitter(self.base_ms, attempt, self.max_delay_ms)
}
}
impl Default for RetryConfig {
fn default() -> Self {
Self {
max_retries: DEFAULT_MAX_RETRIES,
base_ms: DEFAULT_RETRY_BASE_MS,
max_delay_ms: DEFAULT_RETRY_MAX_DELAY_MS,
enabled: true,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RetryClass {
Permanent,
Transient,
RateLimited {
retry_after: Option<Duration>,
},
}
pub fn classify_http_status(status: StatusCode, retry_after: Option<Duration>) -> RetryClass {
match status.as_u16() {
429 => RetryClass::RateLimited { retry_after },
500 | 502 | 504 => RetryClass::Transient,
503 => {
if retry_after.is_some() {
RetryClass::RateLimited { retry_after }
} else {
RetryClass::Transient
}
}
_ => RetryClass::Permanent,
}
}
pub fn parse_retry_after(headers: &HeaderMap) -> Option<Duration> {
let raw = headers
.get(reqwest::header::RETRY_AFTER)
.and_then(|v| v.to_str().ok())?
.trim();
if raw.is_empty() || !raw.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
let secs: u64 = raw.parse().ok()?;
Some(Duration::from_secs(secs.min(HARD_MAX_DELAY_MS / 1000)))
}
pub fn backoff_full_jitter(base_ms: u64, attempt: u32, max_delay_ms: u64) -> Duration {
let base = base_ms.max(1);
let max_delay = max_delay_ms.max(base);
let exp = base.saturating_mul(1u64 << attempt.min(16));
let cap = exp.min(max_delay);
let pick = mix_u64(attempt) % (cap.saturating_add(1));
Duration::from_millis(pick)
}
pub fn politeness_delay(base: Duration) -> Duration {
let base_ms = base.as_millis() as u64;
if base_ms == 0 {
return Duration::ZERO;
}
let span = (base_ms / 5).max(1);
let extra = mix_u64(base_ms as u32) % (span.saturating_add(1));
Duration::from_millis(base_ms.saturating_add(extra))
}
pub fn wait_for_retry(
policy: RetryConfig,
attempt: u32,
retry_after: Option<Duration>,
) -> Duration {
if let Some(d) = retry_after {
return d.min(Duration::from_millis(policy.max_delay_ms));
}
policy.delay_for_attempt(attempt)
}
fn mix_u64(attempt: u32) -> u64 {
let mut h = DefaultHasher::new();
Instant::now().hash(&mut h);
attempt.hash(&mut h);
std::thread::current().id().hash(&mut h);
let marker = &h as *const DefaultHasher as usize;
marker.hash(&mut h);
h.finish()
}
#[cfg(test)]
mod tests {
use super::*;
use reqwest::header::{HeaderValue, RETRY_AFTER};
#[test]
fn max_attempts_respects_kill_switch() {
let mut p = RetryConfig::default();
assert_eq!(p.max_attempts(), 4);
p.enabled = false;
assert_eq!(p.max_attempts(), 1);
assert!(!p.may_retry(1));
}
#[test]
fn from_config_disable_and_clamp() {
let cfg = Config {
disable_retry: true,
max_retries: 99,
retry_max_delay_ms: 999_999,
..Config::default()
};
let p = RetryConfig::from_config(&cfg);
assert!(!p.enabled);
assert_eq!(p.max_retries, HARD_MAX_RETRIES);
assert_eq!(p.max_delay_ms, HARD_MAX_DELAY_MS);
assert_eq!(p.max_attempts(), 1);
}
#[test]
fn backoff_respects_cap() {
let d = backoff_full_jitter(200, 20, 1_000);
assert!(d.as_millis() <= 1_000);
}
#[test]
fn politeness_delay_zero_stays_zero() {
assert_eq!(politeness_delay(Duration::ZERO), Duration::ZERO);
}
#[test]
fn politeness_delay_never_below_floor() {
let base = Duration::from_millis(1000);
for _ in 0..32 {
let d = politeness_delay(base);
assert!(d >= base, "delay {d:?} below floor {base:?}");
assert!(
d <= base + Duration::from_millis(200),
"delay {d:?} above floor+20%"
);
}
}
#[test]
fn classify_matrix() {
assert_eq!(
classify_http_status(StatusCode::OK, None),
RetryClass::Permanent
);
assert_eq!(
classify_http_status(StatusCode::NOT_FOUND, None),
RetryClass::Permanent
);
assert_eq!(
classify_http_status(StatusCode::BAD_REQUEST, None),
RetryClass::Permanent
);
assert_eq!(
classify_http_status(StatusCode::INTERNAL_SERVER_ERROR, None),
RetryClass::Transient
);
assert_eq!(
classify_http_status(StatusCode::TOO_MANY_REQUESTS, Some(Duration::from_secs(2))),
RetryClass::RateLimited {
retry_after: Some(Duration::from_secs(2))
}
);
assert_eq!(
classify_http_status(
StatusCode::SERVICE_UNAVAILABLE,
Some(Duration::from_secs(1))
),
RetryClass::RateLimited {
retry_after: Some(Duration::from_secs(1))
}
);
assert_eq!(
classify_http_status(StatusCode::SERVICE_UNAVAILABLE, None),
RetryClass::Transient
);
}
#[test]
fn parse_retry_after_seconds_only() {
let mut h = HeaderMap::new();
h.insert(RETRY_AFTER, HeaderValue::from_static("7"));
assert_eq!(parse_retry_after(&h), Some(Duration::from_secs(7)));
h.insert(
RETRY_AFTER,
HeaderValue::from_static("Wed, 21 Oct 2015 07:28:00 GMT"),
);
assert_eq!(parse_retry_after(&h), None);
h.insert(RETRY_AFTER, HeaderValue::from_static(""));
assert_eq!(parse_retry_after(&h), None);
}
#[test]
fn wait_prefers_retry_after() {
let p = RetryConfig::default();
let w = wait_for_retry(p, 1, Some(Duration::from_secs(3)));
assert_eq!(w, Duration::from_secs(3));
}
}