use std::time::Duration;
use reqwest::StatusCode;
#[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 calculated = self.initial_delay.saturating_mul(factor as u32);
calculated.min(self.max_delay)
}
}
#[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_eq!(delay_1, Duration::from_millis(200));
assert_eq!(delay_2, Duration::from_millis(400));
assert_eq!(delay_3, Duration::from_millis(800));
let capped = policy.calculate_backoff(10);
assert_eq!(capped, Duration::from_secs(3));
}
}