tollmeshcache 1.1.0

Rust SDK for TollMeshCache - Distributed CRDT-based caching
Documentation
use crate::TollMeshError;
use std::future::Future;
use std::time::Duration;
use tokio::time::sleep;

pub struct RetryConfig {
    pub max_retries: u32,
    pub base_delay: Duration,
    pub max_delay: Duration,
    pub jitter: bool,
    pub backoff_multiplier: f64,
}

impl Default for RetryConfig {
    fn default() -> Self {
        Self {
            max_retries: 3,
            base_delay: Duration::from_millis(1000),
            max_delay: Duration::from_secs(60),
            jitter: true,
            backoff_multiplier: 2.0,
        }
    }
}

impl RetryConfig {
    pub fn calculate_delay(&self, attempt: u32) -> Duration {
        let base = self.base_delay.as_millis() as f64;
        let mut delay = (base * self.backoff_multiplier.powi(attempt as i32))
            .min(self.max_delay.as_millis() as f64) as u64;

        if self.jitter {
            let jitter_amount = delay / 4;
            delay = (delay - jitter_amount + rand::random::<u64>() % (jitter_amount * 2))
                .max(0);
        }

        Duration::from_millis(delay)
    }
}

pub async fn with_retry<F, Fut, T>(
    mut f: F,
    config: &RetryConfig,
) -> Result<T, TollMeshError>
where
    F: FnMut() -> Fut,
    Fut: Future<Output = Result<T, TollMeshError>>,
{
    let mut last_error = None;

    for attempt in 0..=config.max_retries {
        match f().await {
            Ok(result) => return Ok(result),
            Err(err) => {
                if !err.is_retryable() {
                    return Err(err);
                }

                last_error = Some(err);

                if attempt < config.max_retries {
                    let delay = config.calculate_delay(attempt);
                    sleep(delay).await;
                }
            }
        }
    }

    Err(last_error.unwrap_or_else(|| {
        TollMeshError::new(crate::ErrorCode::Internal, "Retry failed")
    }))
}