cripsy_binary_api/transport/
retry.rs1use std::future::Future;
4use std::time::Duration;
5
6use super::error::TransportError;
7use crate::broker::config::TransportConfig;
8
9pub 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
45fn 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
55fn 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); }
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}