robinpath_modules/modules/

retry_mod.rs

use robinpath::{RobinPath, Value};
use std::sync::{LazyLock, Mutex};
use std::collections::HashMap;

struct CircuitBreaker {
    failures: u32,
    threshold: u32,
    reset_timeout: u64,
    state: String,
    last_failure: u64,
    successes_in_half_open: u32,
    half_open_threshold: u32,
}

static BREAKERS: LazyLock<Mutex<HashMap<String, CircuitBreaker>>> =
    LazyLock::new(|| Mutex::new(HashMap::new()));

fn now_ms() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_millis() as u64
}

pub fn register(rp: &mut RobinPath) {
    // retry.withBackoff attempt initialDelay? factor? maxDelay? jitter? → delay ms
    rp.register_builtin("retry.withBackoff", |args, _| {
        let attempt = args.first().map(|v| v.to_number() as u32).unwrap_or(0);
        let initial_delay = args.get(1).map(|v| v.to_number()).unwrap_or(1000.0);
        let factor = args.get(2).map(|v| v.to_number()).unwrap_or(2.0);
        let max_delay = args.get(3).map(|v| v.to_number()).unwrap_or(30000.0);
        let jitter = args.get(4).map(|v| match v {
            Value::Bool(b) => *b,
            Value::String(s) => s != "false",
            _ => true,
        }).unwrap_or(true);

        let mut delay = initial_delay * factor.powi(attempt as i32);
        delay = delay.min(max_delay);
        if jitter {
            // Deterministic "jitter" based on attempt number (no random in sync context)
            let jitter_factor = 0.75 + (attempt as f64 % 4.0) * 0.0625;
            delay *= jitter_factor;
        }
        Ok(Value::Number(delay.round()))
    });

    // retry.isRetryable statusCode → bool
    rp.register_builtin("retry.isRetryable", |args, _| {
        let status = args.first().map(|v| v.to_number() as u16).unwrap_or(0);
        let retryable = matches!(status, 408 | 429 | 500 | 502 | 503 | 504);
        Ok(Value::Bool(retryable))
    });

    // retry.delay ms → true (sync sleep)
    rp.register_builtin("retry.delay", |args, _| {
        let ms = args.first().map(|v| v.to_number() as u64).unwrap_or(1000);
        std::thread::sleep(std::time::Duration::from_millis(ms));
        Ok(Value::Bool(true))
    });

    // retry.attempts maxAttempts? initialDelay? factor? → array of {attempt, delay, totalWait}
    rp.register_builtin("retry.attempts", |args, _| {
        let max_attempts = args.first().map(|v| v.to_number() as u32).unwrap_or(3);
        let initial_delay = args.get(1).map(|v| v.to_number()).unwrap_or(1000.0);
        let factor = args.get(2).map(|v| v.to_number()).unwrap_or(2.0);
        let mut total_wait = 0.0_f64;
        let mut result = Vec::new();
        for i in 0..max_attempts {
            let d = if i == 0 { 0.0 } else { (initial_delay * factor.powi((i - 1) as i32)).round() };
            total_wait += d;
            let mut obj = indexmap::IndexMap::new();
            obj.insert("attempt".to_string(), Value::Number((i + 1) as f64));
            obj.insert("delay".to_string(), Value::Number(d));
            obj.insert("totalWait".to_string(), Value::Number(total_wait));
            result.push(Value::Object(obj));
        }
        Ok(Value::Array(result))
    });

    // retry.createBreaker name threshold? resetTimeout? → {name, state, threshold, resetTimeout}
    rp.register_builtin("retry.createBreaker", |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let threshold = args.get(1).map(|v| v.to_number() as u32).unwrap_or(5);
        let reset_timeout = args.get(2).map(|v| v.to_number() as u64).unwrap_or(60000);
        let breaker = CircuitBreaker {
            failures: 0,
            threshold,
            reset_timeout,
            state: "closed".to_string(),
            last_failure: 0,
            successes_in_half_open: 0,
            half_open_threshold: 1,
        };
        BREAKERS.lock().unwrap().insert(name.clone(), breaker);
        let mut obj = indexmap::IndexMap::new();
        obj.insert("name".to_string(), Value::String(name));
        obj.insert("state".to_string(), Value::String("closed".to_string()));
        obj.insert("threshold".to_string(), Value::Number(threshold as f64));
        obj.insert("resetTimeout".to_string(), Value::Number(reset_timeout as f64));
        Ok(Value::Object(obj))
    });

    // retry.breakerState name → {name, state, failures, threshold, resetTimeout}
    rp.register_builtin("retry.breakerState", |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let mut breakers = BREAKERS.lock().unwrap();
        if let Some(b) = breakers.get_mut(&name) {
            let now = now_ms();
            if b.state == "open" && now - b.last_failure >= b.reset_timeout {
                b.state = "half-open".to_string();
                b.successes_in_half_open = 0;
            }
            let mut obj = indexmap::IndexMap::new();
            obj.insert("name".to_string(), Value::String(name));
            obj.insert("state".to_string(), Value::String(b.state.clone()));
            obj.insert("failures".to_string(), Value::Number(b.failures as f64));
            obj.insert("threshold".to_string(), Value::Number(b.threshold as f64));
            obj.insert("resetTimeout".to_string(), Value::Number(b.reset_timeout as f64));
            Ok(Value::Object(obj))
        } else {
            let mut obj = indexmap::IndexMap::new();
            obj.insert("name".to_string(), Value::String(name));
            obj.insert("state".to_string(), Value::String("unknown".to_string()));
            Ok(Value::Object(obj))
        }
    });

    // retry.breakerRecord name success → {name, state, failures}
    rp.register_builtin("retry.breakerRecord", |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let success = args.get(1).map(|v| match v {
            Value::Bool(b) => *b,
            Value::String(s) => s != "false" && s != "failure",
            _ => true,
        }).unwrap_or(true);
        let mut breakers = BREAKERS.lock().unwrap();
        let b = breakers.get_mut(&name)
            .ok_or_else(|| format!("Circuit breaker \"{}\" not found. Create it first.", name))?;
        let now = now_ms();
        if b.state == "open" && now - b.last_failure >= b.reset_timeout {
            b.state = "half-open".to_string();
            b.successes_in_half_open = 0;
        }
        if success {
            if b.state == "half-open" {
                b.successes_in_half_open += 1;
                if b.successes_in_half_open >= b.half_open_threshold {
                    b.state = "closed".to_string();
                    b.failures = 0;
                }
            } else {
                b.failures = 0;
            }
        } else {
            b.failures += 1;
            b.last_failure = now;
            if b.failures >= b.threshold {
                b.state = "open".to_string();
            }
        }
        let mut obj = indexmap::IndexMap::new();
        obj.insert("name".to_string(), Value::String(name));
        obj.insert("state".to_string(), Value::String(b.state.clone()));
        obj.insert("failures".to_string(), Value::Number(b.failures as f64));
        Ok(Value::Object(obj))
    });

    // retry.breakerAllow name → bool
    rp.register_builtin("retry.breakerAllow", |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let mut breakers = BREAKERS.lock().unwrap();
        if let Some(b) = breakers.get_mut(&name) {
            if b.state == "open" {
                let now = now_ms();
                if now - b.last_failure >= b.reset_timeout {
                    b.state = "half-open".to_string();
                    b.successes_in_half_open = 0;
                    Ok(Value::Bool(true))
                } else {
                    Ok(Value::Bool(false))
                }
            } else {
                Ok(Value::Bool(true))
            }
        } else {
            Ok(Value::Bool(true))
        }
    });

    // retry.breakerReset name → bool
    rp.register_builtin("retry.breakerReset", |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let mut breakers = BREAKERS.lock().unwrap();
        if let Some(b) = breakers.get_mut(&name) {
            b.failures = 0;
            b.state = "closed".to_string();
            b.last_failure = 0;
            b.successes_in_half_open = 0;
            Ok(Value::Bool(true))
        } else {
            Ok(Value::Bool(false))
        }
    });
}