use std::time::Duration;
use super::stats::ProcessingStats;
use super::types::ErrorType;
struct ExponentialBackoff {
current_ms: u64,
factor: u64,
max_delay: Duration,
remaining: usize,
}
impl Iterator for ExponentialBackoff {
type Item = Duration;
fn next(&mut self) -> Option<Duration> {
if self.remaining == 0 {
return None;
}
self.remaining -= 1;
let delay = Duration::from_millis(self.current_ms).min(self.max_delay);
self.current_ms = self.current_ms.saturating_mul(self.factor);
Some(delay)
}
}
pub fn get_retry_strategy() -> impl Iterator<Item = Duration> {
ExponentialBackoff {
current_ms: crate::config::RETRY_INITIAL_DELAY_MS,
factor: crate::config::RETRY_FACTOR,
max_delay: Duration::from_secs(crate::config::RETRY_MAX_DELAY_SECS),
remaining: crate::config::RETRY_MAX_ATTEMPTS,
}
}
pub fn categorize_reqwest_error(error: &reqwest::Error) -> ErrorType {
if let Some(status) = error.status() {
match status.as_u16() {
400 => return ErrorType::HttpRequestBadRequest,
401 => return ErrorType::HttpRequestUnauthorized,
403 => return ErrorType::HttpRequestBotDetectionError,
404 => return ErrorType::HttpRequestNotFound,
429 => return ErrorType::HttpRequestTooManyRequests,
500 => return ErrorType::HttpRequestInternalServerError,
502 => return ErrorType::HttpRequestBadGateway,
503 => return ErrorType::HttpRequestServiceUnavailable,
504 => return ErrorType::HttpRequestGatewayTimeout,
_ if status.is_client_error() => {
return ErrorType::HttpRequestOtherError;
}
_ if status.is_server_error() => {
return ErrorType::HttpRequestOtherError;
}
_ => {
}
}
}
if error.is_builder() {
ErrorType::HttpRequestBuilderError
} else if error.is_redirect() {
ErrorType::HttpRequestRedirectError
} else if error.is_status() {
ErrorType::HttpRequestStatusError
} else if error.is_timeout() {
ErrorType::HttpRequestTimeoutError
} else if error.is_request() {
ErrorType::HttpRequestRequestError
} else if error.is_connect() {
ErrorType::HttpRequestConnectError
} else if error.is_body() {
ErrorType::HttpRequestBodyError
} else if error.is_decode() {
ErrorType::HttpRequestDecodeError
} else {
ErrorType::HttpRequestOtherError
}
}
pub fn update_error_stats(stats: &ProcessingStats, error: &reqwest::Error) {
use super::ReqwestErrorExt;
stats.increment_error(error.categorize());
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error_handling::ReqwestErrorExt;
use std::time::Duration;
#[test]
fn test_get_retry_strategy_initial_delay() {
let strategy = get_retry_strategy();
let first_delay = strategy
.take(1)
.next()
.expect("Retry strategy should always yield at least one delay");
let expected_ms = u128::from(crate::config::RETRY_INITIAL_DELAY_MS);
let actual_ms = first_delay.as_millis();
assert!(
actual_ms >= expected_ms,
"Expected delay >= {}ms, got {}ms",
expected_ms,
actual_ms
);
}
#[test]
fn test_get_retry_strategy_exponential_backoff() {
let strategy = get_retry_strategy();
let delays: Vec<Duration> = strategy.take(5).collect();
for i in 1..delays.len() {
let prev = delays[i - 1].as_millis();
let curr = delays[i].as_millis();
assert!(curr >= prev, "Delay should increase: {} >= {}", curr, prev);
let max_delay_ms = u128::from(crate::config::RETRY_MAX_DELAY_SECS * 1000);
if curr < max_delay_ms {
#[allow(clippy::cast_precision_loss)]
let ratio = curr as f64 / prev as f64;
assert!(
(1.0..=3.0).contains(&ratio),
"Backoff factor should be reasonable: {} / {} = {}",
curr,
prev,
ratio
);
}
}
}
#[test]
fn test_get_retry_strategy_max_delay() {
let strategy = get_retry_strategy();
let max_delay_ms = crate::config::RETRY_MAX_DELAY_SECS * 1000;
for delay in strategy {
assert!(
delay.as_millis() <= u128::from(max_delay_ms),
"Delay {}ms exceeds max {}ms",
delay.as_millis(),
max_delay_ms
);
}
}
#[test]
fn test_get_retry_strategy_max_attempts() {
let strategy = get_retry_strategy();
let count = strategy.count();
assert_eq!(count, crate::config::RETRY_MAX_ATTEMPTS);
}
#[tokio::test]
async fn test_update_error_stats() {
use httptest::{matchers::*, responders::*, Expectation, Server};
let stats = ProcessingStats::new();
let server = Server::run();
server.expect(
Expectation::matching(request::method_path("GET", "/404"))
.respond_with(status_code(404).body("Not Found")),
);
let client = reqwest::Client::new();
let url = format!("http://{}/404", server.addr());
let response = client.get(&url).send().await.unwrap();
let error = response.error_for_status().unwrap_err();
update_error_stats(&stats, &error);
assert_eq!(
stats.get_error_count(ErrorType::HttpRequestNotFound),
1,
"404 error should increment HttpRequestNotFound counter"
);
}
#[tokio::test]
async fn test_categorize_reqwest_error_400() {
test_status_code(400, ErrorType::HttpRequestBadRequest, false).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_401() {
test_status_code(401, ErrorType::HttpRequestUnauthorized, false).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_403() {
test_status_code(403, ErrorType::HttpRequestBotDetectionError, false).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_404() {
test_status_code(404, ErrorType::HttpRequestNotFound, false).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_429() {
test_status_code(429, ErrorType::HttpRequestTooManyRequests, true).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_500() {
test_status_code(500, ErrorType::HttpRequestInternalServerError, true).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_502() {
test_status_code(502, ErrorType::HttpRequestBadGateway, true).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_503() {
test_status_code(503, ErrorType::HttpRequestServiceUnavailable, true).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_504() {
test_status_code(504, ErrorType::HttpRequestGatewayTimeout, true).await;
}
#[tokio::test]
async fn test_categorize_reqwest_error_521() {
test_status_code(521, ErrorType::HttpRequestOtherError, true).await;
}
async fn test_status_code(code: u16, expected_error_type: ErrorType, expected_retriable: bool) {
use httptest::{matchers::*, responders::*, Expectation, Server};
let server = Server::run();
let client = reqwest::Client::new();
let path = match code {
400 => "/400",
401 => "/401",
403 => "/403",
404 => "/404",
429 => "/429",
500 => "/500",
502 => "/502",
503 => "/503",
504 => "/504",
521 => "/521",
_ => panic!("Unsupported status code in test"),
};
server.expect(
Expectation::matching(request::method_path("GET", path))
.respond_with(status_code(code).body("Error")),
);
let url = format!("http://{}{}", server.addr(), path);
let response = client.get(&url).send().await.unwrap();
let error = response.error_for_status().unwrap_err();
let categorized = categorize_reqwest_error(&error);
assert_eq!(
categorized, expected_error_type,
"Status code {} should be categorized as {:?}",
code, expected_error_type
);
assert_eq!(
error.is_retriable(),
expected_retriable,
"Status code {} retriability should be {}",
code,
expected_retriable
);
}
#[tokio::test]
async fn test_categorize_reqwest_error_other_client_errors() {
use httptest::{matchers::*, responders::*, Expectation, Server};
let server = Server::run();
server.expect(
Expectation::matching(request::method_path("GET", "/418"))
.respond_with(status_code(418).body("I'm a teapot")), );
let client = reqwest::Client::new();
let url = format!("http://{}/418", server.addr());
let response = client.get(&url).send().await.unwrap();
let error = response.error_for_status().unwrap_err();
let categorized = categorize_reqwest_error(&error);
assert_eq!(
categorized,
ErrorType::HttpRequestOtherError,
"Other 4xx errors should be categorized as HttpRequestOtherError"
);
assert!(
!error.is_retriable(),
"Other 4xx (418) should not be retriable"
);
}
#[tokio::test]
async fn test_categorize_reqwest_error_other_server_errors() {
use httptest::{matchers::*, responders::*, Expectation, Server};
let server = Server::run();
server.expect(
Expectation::matching(request::method_path("GET", "/507"))
.respond_with(status_code(507).body("Insufficient Storage")), );
let client = reqwest::Client::new();
let url = format!("http://{}/507", server.addr());
let response = client.get(&url).send().await.unwrap();
let error = response.error_for_status().unwrap_err();
let categorized = categorize_reqwest_error(&error);
assert_eq!(
categorized,
ErrorType::HttpRequestOtherError,
"Other 5xx errors should be categorized as HttpRequestOtherError"
);
assert!(error.is_retriable(), "Other 5xx (507) should be retriable");
}
#[tokio::test]
async fn test_categorize_reqwest_error_timeout() {
use std::time::Duration;
let client = reqwest::Client::builder()
.timeout(Duration::from_millis(50))
.connect_timeout(Duration::from_millis(10))
.build()
.unwrap();
let error = client.get("http://192.0.2.1:80").send().await.unwrap_err();
let categorized = categorize_reqwest_error(&error);
assert!(
categorized == ErrorType::HttpRequestTimeoutError
|| categorized == ErrorType::HttpRequestConnectError,
"Timeout errors should be categorized as TimeoutError or ConnectError, got {:?}",
categorized
);
assert!(
error.is_retriable(),
"Timeout/connect errors should be retriable"
);
}
#[tokio::test]
async fn test_categorize_reqwest_error_connect() {
use std::time::Duration;
let client = reqwest::Client::builder()
.timeout(Duration::from_millis(500))
.connect_timeout(Duration::from_millis(200))
.build()
.unwrap();
let error = client
.get("http://192.0.2.1:80") .send()
.await
.unwrap_err();
let categorized = categorize_reqwest_error(&error);
assert!(
categorized == ErrorType::HttpRequestConnectError
|| categorized == ErrorType::HttpRequestTimeoutError
|| categorized == ErrorType::HttpRequestRequestError,
"Connection errors should be categorized as ConnectError, TimeoutError, or RequestError, got {:?}",
categorized
);
assert!(
error.is_retriable(),
"Connection errors should be retriable"
);
}
}