Skip to main content

cripsy_binary_api/transport/
retry.rs

1//! Reintentos con backoff exponencial y jitter.
2
3use std::future::Future;
4use std::time::Duration;
5
6use super::error::TransportError;
7use crate::broker::config::TransportConfig;
8
9/// Ejecuta `op` con reintentos según la configuración.
10///
11/// El jitter se deriva del reloj del sistema para evitar dependencias extra.
12/// Ante error de transporte reintenta; el último error se devuelve tal cual.
13pub async fn with_retry<F, Fut, T>(
14    cfg: &TransportConfig,
15    nombre: &str,
16    mut op: F,
17) -> Result<T, TransportError>
18where
19    F: FnMut() -> Fut,
20    Fut: Future<Output = Result<T, TransportError>>,
21{
22    let mut intento: u32 = 0;
23    loop {
24        match op().await {
25            Ok(v) => return Ok(v),
26            Err(e) => {
27                if intento >= cfg.max_retries {
28                    return Err(e);
29                }
30                let espera = backoff(cfg, intento);
31                tracing::warn!(
32                    error = %e,
33                    intento = intento + 1,
34                    max = cfg.max_retries,
35                    espera_ms = espera.as_millis() as u64,
36                    "reintentando {nombre}"
37                );
38                tokio::time::sleep(espera).await;
39                intento += 1;
40            }
41        }
42    }
43}
44
45/// Backoff exponencial con tope y jitter.
46fn backoff(cfg: &TransportConfig, intento: u32) -> Duration {
47    let base = cfg
48        .backoff_base_ms
49        .saturating_mul(2u64.saturating_pow(intento));
50    let tope = cfg.backoff_max_ms;
51    let jitter = nanos_jitter();
52    Duration::from_millis(base.min(tope) + jitter % (tope / 4 + 1))
53}
54
55/// Jitter simple derivado del reloj (0..tope/4 ms).
56fn nanos_jitter() -> u64 {
57    use std::time::{SystemTime, UNIX_EPOCH};
58    SystemTime::now()
59        .duration_since(UNIX_EPOCH)
60        .map(|d| u64::from(d.subsec_nanos()))
61        .unwrap_or(0)
62        % 64
63}
64
65#[cfg(test)]
66mod tests {
67    use super::*;
68    use std::sync::atomic::{AtomicU32, Ordering};
69
70    fn cfg(max: u32) -> TransportConfig {
71        TransportConfig {
72            connect_timeout_secs: 2,
73            request_timeout_secs: 2,
74            max_retries: max,
75            backoff_base_ms: 1,
76            backoff_max_ms: 4,
77            cola_salida: 64,
78            verify_tls: true,
79            proxy: None,
80            user_agent: None,
81        }
82    }
83
84    #[tokio::test]
85    async fn reintenta_hasta_lograr() {
86        let n = AtomicU32::new(0);
87        let out = with_retry(&cfg(3), "prueba", || {
88            let n = n.fetch_add(1, Ordering::SeqCst) + 1;
89            async move {
90                if n < 3 {
91                    Err(TransportError::Closed)
92                } else {
93                    Ok(n)
94                }
95            }
96        })
97        .await
98        .expect("debe lograrse al tercer intento");
99        assert_eq!(out, 3);
100        assert_eq!(n.load(Ordering::SeqCst), 3);
101    }
102
103    #[tokio::test]
104    async fn agota_reintentos_y_devuelve_error() {
105        let n = AtomicU32::new(0);
106        let err = with_retry(&cfg(2), "prueba", || {
107            n.fetch_add(1, Ordering::SeqCst);
108            async { Err::<(), _>(TransportError::Closed) }
109        })
110        .await
111        .expect_err("debe fallar");
112        assert!(matches!(err, TransportError::Closed));
113        assert_eq!(n.load(Ordering::SeqCst), 3); // 1 inicial + 2 reintentos
114    }
115
116    #[tokio::test]
117    async fn sin_error_no_reintenta() {
118        let n = AtomicU32::new(0);
119        let out = with_retry(&cfg(5), "prueba", || {
120            n.fetch_add(1, Ordering::SeqCst);
121            async { Ok::<_, TransportError>(7u32) }
122        })
123        .await
124        .unwrap();
125        assert_eq!(out, 7);
126        assert_eq!(n.load(Ordering::SeqCst), 1);
127    }
128
129    #[test]
130    fn backoff_crece_hasta_el_tope() {
131        let c = cfg(9);
132        let b0 = backoff(&c, 0);
133        let b5 = backoff(&c, 5);
134        assert!(b0 <= Duration::from_millis(c.backoff_base_ms + 64));
135        assert!(b5 <= Duration::from_millis(c.backoff_max_ms + 64));
136    }
137}