use crate::shared::errors::Error;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct RetryRequestInfo {
pub method: String,
pub url: String,
}
pub type RetryableFn = Arc<dyn Fn(&Error) -> bool + Send + Sync>;
pub type SafeToRetryFn = Arc<dyn Fn(&RetryRequestInfo) -> bool + Send + Sync>;
#[derive(Clone, Default)]
pub struct RetryPolicy {
pub max_attempts: Option<u32>,
pub backoff_ms: Option<u64>,
pub backoff_max_ms: Option<u64>,
pub backoff_mul: Option<f64>,
pub on_retryable: Option<RetryableFn>,
pub safe_to_retry: Option<SafeToRetryFn>,
}
#[derive(Clone)]
pub struct EffectiveRetryPolicy {
pub max_attempts: u32,
pub backoff_ms: u64,
pub backoff_max_ms: u64,
pub backoff_mul: f64,
pub on_retryable: RetryableFn,
pub safe_to_retry: SafeToRetryFn,
}
pub const DEFAULT_MAX_ATTEMPTS: u32 = 2;
pub const DEFAULT_BACKOFF_MS: u64 = 200;
pub const DEFAULT_BACKOFF_MAX_MS: u64 = 2000;
pub const DEFAULT_BACKOFF_MUL: f64 = 2.0;
const RETRY_AFTER_UPPER_BOUND_MS: u64 = 60_000;
pub fn default_safe_to_retry(req: &RetryRequestInfo) -> bool {
matches!(
req.method.to_uppercase().as_str(),
"GET" | "HEAD" | "OPTIONS"
)
}
pub fn default_retryable(err: &Error) -> bool {
match err {
Error::Stream(_) => false,
Error::Http(h) => h.status_code >= 500 || h.status_code == 429,
Error::Network(n) => n.is_timeout() || n.is_eof(),
_ => false,
}
}
pub fn effective_policy(p: Option<&RetryPolicy>) -> Option<EffectiveRetryPolicy> {
let p = p?;
Some(EffectiveRetryPolicy {
max_attempts: p
.max_attempts
.filter(|&v| v > 0)
.unwrap_or(DEFAULT_MAX_ATTEMPTS),
backoff_ms: p
.backoff_ms
.filter(|&v| v > 0)
.unwrap_or(DEFAULT_BACKOFF_MS),
backoff_max_ms: p
.backoff_max_ms
.filter(|&v| v > 0)
.unwrap_or(DEFAULT_BACKOFF_MAX_MS),
backoff_mul: p
.backoff_mul
.filter(|&v| v > 0.0)
.unwrap_or(DEFAULT_BACKOFF_MUL),
on_retryable: p
.on_retryable
.clone()
.unwrap_or_else(|| Arc::new(default_retryable)),
safe_to_retry: p
.safe_to_retry
.clone()
.unwrap_or_else(|| Arc::new(default_safe_to_retry)),
})
}
pub fn compute_backoff(p: &EffectiveRetryPolicy, attempt: u32, err: &Error) -> u64 {
if let Error::Http(h) = err {
if h.retry_after > 0 {
let ms = (h.retry_after as u64).saturating_mul(1000);
return ms.min(RETRY_AFTER_UPPER_BOUND_MS);
}
}
let mut d = p.backoff_ms as f64;
for _ in 0..attempt {
d *= p.backoff_mul;
if d > p.backoff_max_ms as f64 {
return p.backoff_max_ms;
}
}
d as u64
}