use std::sync::atomic::{AtomicU64, Ordering};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use reqwest::StatusCode;
static JITTER_SEED: AtomicU64 = AtomicU64::new(0);
fn next_random_u64() -> u64 {
let mut state = JITTER_SEED.load(Ordering::Relaxed);
if state == 0 {
state = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_nanos() as u64)
.unwrap_or(0x9E37_79B9_7F4A_7C15);
}
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
JITTER_SEED.store(state, Ordering::Relaxed);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RetryPolicy {
pub max_retries: u32,
pub initial_delay: Duration,
pub max_delay: Duration,
}
impl Default for RetryPolicy {
fn default() -> Self {
Self {
max_retries: 3,
initial_delay: Duration::from_millis(200),
max_delay: Duration::from_secs(3),
}
}
}
impl RetryPolicy {
#[must_use]
pub fn none() -> Self {
Self {
max_retries: 0,
initial_delay: Duration::ZERO,
max_delay: Duration::ZERO,
}
}
#[must_use]
pub fn new(max_retries: u32, initial_delay: Duration, max_delay: Duration) -> Self {
Self {
max_retries,
initial_delay,
max_delay,
}
}
#[must_use]
pub fn is_retryable_status(status: StatusCode) -> bool {
matches!(
status,
StatusCode::TOO_MANY_REQUESTS
| StatusCode::INTERNAL_SERVER_ERROR
| StatusCode::BAD_GATEWAY
| StatusCode::SERVICE_UNAVAILABLE
| StatusCode::GATEWAY_TIMEOUT
)
}
#[must_use]
pub fn calculate_backoff(&self, attempt: u32) -> Duration {
if attempt == 0 || self.max_retries == 0 {
return Duration::ZERO;
}
let factor = 2u64.saturating_pow(attempt.saturating_sub(1));
let max_calculated = self
.initial_delay
.saturating_mul(factor as u32)
.min(self.max_delay);
let max_millis = max_calculated.as_millis() as u64;
if max_millis == 0 {
return Duration::ZERO;
}
let half = max_millis / 2;
let random_part = next_random_u64() % (half.max(1) + 1);
Duration::from_millis(half + random_part)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn retryable_status_codes() {
assert!(RetryPolicy::is_retryable_status(
StatusCode::TOO_MANY_REQUESTS
));
assert!(RetryPolicy::is_retryable_status(StatusCode::BAD_GATEWAY));
assert!(RetryPolicy::is_retryable_status(
StatusCode::SERVICE_UNAVAILABLE
));
assert!(!RetryPolicy::is_retryable_status(StatusCode::UNAUTHORIZED));
assert!(!RetryPolicy::is_retryable_status(StatusCode::BAD_REQUEST));
assert!(!RetryPolicy::is_retryable_status(StatusCode::NOT_FOUND));
}
#[test]
fn backoff_calculation_progression() {
let policy = RetryPolicy::default();
let delay_1 = policy.calculate_backoff(1);
let delay_2 = policy.calculate_backoff(2);
let delay_3 = policy.calculate_backoff(3);
assert!(delay_1 >= Duration::from_millis(100) && delay_1 <= Duration::from_millis(200));
assert!(delay_2 >= Duration::from_millis(200) && delay_2 <= Duration::from_millis(400));
assert!(delay_3 >= Duration::from_millis(400) && delay_3 <= Duration::from_millis(800));
let capped = policy.calculate_backoff(10);
assert!(capped >= Duration::from_millis(1500) && capped <= Duration::from_secs(3));
}
}