use std::future::Future;
use std::time::Duration;
use super::error::TransportError;
use crate::broker::config::TransportConfig;
pub async fn with_retry<F, Fut, T>(
cfg: &TransportConfig,
nombre: &str,
mut op: F,
) -> Result<T, TransportError>
where
F: FnMut() -> Fut,
Fut: Future<Output = Result<T, TransportError>>,
{
let mut intento: u32 = 0;
loop {
match op().await {
Ok(v) => return Ok(v),
Err(e) => {
if intento >= cfg.max_retries {
return Err(e);
}
let espera = backoff(cfg, intento);
tracing::warn!(
error = %e,
intento = intento + 1,
max = cfg.max_retries,
espera_ms = espera.as_millis() as u64,
"reintentando {nombre}"
);
tokio::time::sleep(espera).await;
intento += 1;
}
}
}
}
fn backoff(cfg: &TransportConfig, intento: u32) -> Duration {
let base = cfg
.backoff_base_ms
.saturating_mul(2u64.saturating_pow(intento));
let tope = cfg.backoff_max_ms;
let jitter = nanos_jitter();
Duration::from_millis(base.min(tope) + jitter % (tope / 4 + 1))
}
fn nanos_jitter() -> u64 {
use std::time::{SystemTime, UNIX_EPOCH};
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| u64::from(d.subsec_nanos()))
.unwrap_or(0)
% 64
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicU32, Ordering};
fn cfg(max: u32) -> TransportConfig {
TransportConfig {
connect_timeout_secs: 2,
request_timeout_secs: 2,
max_retries: max,
backoff_base_ms: 1,
backoff_max_ms: 4,
cola_salida: 64,
verify_tls: true,
proxy: None,
user_agent: None,
}
}
#[tokio::test]
async fn reintenta_hasta_lograr() {
let n = AtomicU32::new(0);
let out = with_retry(&cfg(3), "prueba", || {
let n = n.fetch_add(1, Ordering::SeqCst) + 1;
async move {
if n < 3 {
Err(TransportError::Closed)
} else {
Ok(n)
}
}
})
.await
.expect("debe lograrse al tercer intento");
assert_eq!(out, 3);
assert_eq!(n.load(Ordering::SeqCst), 3);
}
#[tokio::test]
async fn agota_reintentos_y_devuelve_error() {
let n = AtomicU32::new(0);
let err = with_retry(&cfg(2), "prueba", || {
n.fetch_add(1, Ordering::SeqCst);
async { Err::<(), _>(TransportError::Closed) }
})
.await
.expect_err("debe fallar");
assert!(matches!(err, TransportError::Closed));
assert_eq!(n.load(Ordering::SeqCst), 3); }
#[tokio::test]
async fn sin_error_no_reintenta() {
let n = AtomicU32::new(0);
let out = with_retry(&cfg(5), "prueba", || {
n.fetch_add(1, Ordering::SeqCst);
async { Ok::<_, TransportError>(7u32) }
})
.await
.unwrap();
assert_eq!(out, 7);
assert_eq!(n.load(Ordering::SeqCst), 1);
}
#[test]
fn backoff_crece_hasta_el_tope() {
let c = cfg(9);
let b0 = backoff(&c, 0);
let b5 = backoff(&c, 5);
assert!(b0 <= Duration::from_millis(c.backoff_base_ms + 64));
assert!(b5 <= Duration::from_millis(c.backoff_max_ms + 64));
}
}