breaker_machines 0.5.0 → 0.6.0

data/ext/breaker_machines_native/target/package/breaker-machines-0.1.0/Cargo.toml

@@ -0,0 +1,48 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2024"
+name = "breaker-machines"
+version = "0.1.0"
+authors = ["Abdelkader Boudih <terminale@gmail.com>"]
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "High-performance circuit breaker storage backend"
+readme = "README.md"
+keywords = [
+    "circuit-breaker",
+    "reliability",
+    "fault-tolerance",
+]
+categories = ["concurrency"]
+license = "MIT"
+repository = "https://github.com/seuros/breaker_machines"
+resolver = "2"
+
+[lib]
+name = "breaker_machines"
+crate-type = ["lib"]
+path = "src/lib.rs"
+
+[[example]]
+name = "basic"
+path = "examples/basic.rs"
+
+[dependencies.chrono-machines]
+version = "0.2.1"
+
+[dependencies.state-machines]
+version = "0.6"

data/ext/breaker_machines_native/target/package/breaker-machines-0.1.0/examples/basic.rs

@@ -0,0 +1,61 @@
+//! Basic circuit breaker usage example
+
+use breaker_machines::CircuitBreaker;
+
+fn main() {
+    println!("=== Circuit Breaker Basic Example ===\n");
+
+    // Create a circuit with builder API
+    let mut circuit = CircuitBreaker::builder("payment_api")
+        .failure_threshold(3)
+        .failure_window_secs(10.0)
+        .half_open_timeout_secs(5.0)
+        .success_threshold(2)
+        .on_open(|name| println!("🔴 Circuit '{}' opened!", name))
+        .on_close(|name| println!("🟢 Circuit '{}' closed!", name))
+        .on_half_open(|name| println!("🟡 Circuit '{}' half-open, testing...", name))
+        .build();
+
+    println!("Initial state: {}\n", circuit.state_name());
+
+    // Simulate successful calls
+    println!("--- Successful calls ---");
+    for i in 1..=2 {
+        match circuit.call(|| Ok::<_, String>(format!("Payment {}", i))) {
+            Ok(result) => println!("✓ {}", result),
+            Err(e) => println!("✗ Error: {}", e),
+        }
+    }
+    println!("State: {}\n", circuit.state_name());
+
+    // Simulate failures
+    println!("--- Triggering failures ---");
+    for i in 1..=3 {
+        match circuit.call(|| Err::<String, _>(format!("Payment failed {}", i))) {
+            Ok(_) => println!("✓ Success"),
+            Err(e) => println!("✗ {}", e),
+        }
+    }
+    println!("State: {} (circuit opened)\n", circuit.state_name());
+
+    // Try calling while open
+    println!("--- Attempting call while open ---");
+    match circuit.call(|| Ok::<_, String>("Should be rejected")) {
+        Ok(_) => println!("✓ Success"),
+        Err(e) => println!("✗ {}", e),
+    }
+    println!();
+
+    // Reset and demonstrate recovery
+    println!("--- Resetting circuit ---");
+    circuit.reset();
+    println!("State after reset: {}\n", circuit.state_name());
+
+    // Successful calls after reset
+    println!("--- Calls after reset ---");
+    match circuit.call(|| Ok::<_, String>("Payment successful")) {
+        Ok(result) => println!("✓ {}", result),
+        Err(e) => println!("✗ {}", e),
+    }
+    println!("State: {}", circuit.state_name());
+}

data/ext/breaker_machines_native/target/package/breaker-machines-0.1.0/src/builder.rs

@@ -0,0 +1,154 @@
+//! Builder API for ergonomic circuit breaker configuration
+
+use crate::{
+    callbacks::Callbacks,
+    circuit::{CircuitBreaker, CircuitContext, Config},
+    MemoryStorage, StorageBackend,
+};
+use std::sync::Arc;
+
+/// Builder for creating circuit breakers with fluent API
+pub struct CircuitBuilder {
+    name: String,
+    config: Config,
+    storage: Option<Arc<dyn StorageBackend>>,
+    callbacks: Callbacks,
+}
+
+impl CircuitBuilder {
+    /// Create a new builder for a circuit with the given name
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            config: Config::default(),
+            storage: None,
+            callbacks: Callbacks::new(),
+        }
+    }
+
+    /// Set the failure threshold (number of failures to open circuit)
+    pub fn failure_threshold(mut self, threshold: usize) -> Self {
+        self.config.failure_threshold = threshold;
+        self
+    }
+
+    /// Set the failure window in seconds
+    pub fn failure_window_secs(mut self, seconds: f64) -> Self {
+        self.config.failure_window_secs = seconds;
+        self
+    }
+
+    /// Set the half-open timeout in seconds
+    pub fn half_open_timeout_secs(mut self, seconds: f64) -> Self {
+        self.config.half_open_timeout_secs = seconds;
+        self
+    }
+
+    /// Set the success threshold (successes needed to close from half-open)
+    pub fn success_threshold(mut self, threshold: usize) -> Self {
+        self.config.success_threshold = threshold;
+        self
+    }
+
+    /// Set the jitter factor (0.0 = no jitter, 1.0 = full jitter)
+    /// Uses chrono-machines formula: timeout * (1 - jitter + rand * jitter)
+    pub fn jitter_factor(mut self, factor: f64) -> Self {
+        self.config.jitter_factor = factor;
+        self
+    }
+
+    /// Set custom storage backend
+    pub fn storage(mut self, storage: Arc<dyn StorageBackend>) -> Self {
+        self.storage = Some(storage);
+        self
+    }
+
+    /// Set callback for when circuit opens
+    pub fn on_open<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&str) + Send + Sync + 'static,
+    {
+        self.callbacks.on_open = Some(Arc::new(f));
+        self
+    }
+
+    /// Set callback for when circuit closes
+    pub fn on_close<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&str) + Send + Sync + 'static,
+    {
+        self.callbacks.on_close = Some(Arc::new(f));
+        self
+    }
+
+    /// Set callback for when circuit enters half-open
+    pub fn on_half_open<F>(mut self, f: F) -> Self
+    where
+        F: Fn(&str) + Send + Sync + 'static,
+    {
+        self.callbacks.on_half_open = Some(Arc::new(f));
+        self
+    }
+
+    /// Build the circuit breaker
+    pub fn build(self) -> CircuitBreaker {
+        let storage = self
+            .storage
+            .unwrap_or_else(|| Arc::new(MemoryStorage::new()));
+
+        let context = CircuitContext {
+            name: self.name,
+            config: self.config,
+            storage,
+        };
+
+        CircuitBreaker::with_context_and_callbacks(context, self.callbacks)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_builder_defaults() {
+        let circuit = CircuitBuilder::new("test").build();
+
+        assert_eq!(circuit.state_name(), "Closed");
+        assert!(circuit.is_closed());
+    }
+
+    #[test]
+    fn test_builder_custom_config() {
+        let circuit = CircuitBuilder::new("test")
+            .failure_threshold(10)
+            .failure_window_secs(120.0)
+            .half_open_timeout_secs(60.0)
+            .success_threshold(3)
+            .build();
+
+        assert!(circuit.is_closed());
+    }
+
+    #[test]
+    fn test_builder_with_callbacks() {
+        use std::sync::atomic::{AtomicBool, Ordering};
+
+        let opened = Arc::new(AtomicBool::new(false));
+        let opened_clone = opened.clone();
+
+        let mut circuit = CircuitBuilder::new("test")
+            .failure_threshold(2)
+            .on_open(move |_name| {
+                opened_clone.store(true, Ordering::SeqCst);
+            })
+            .build();
+
+        // Trigger failures to open circuit
+        let _ = circuit.call(|| Err::<(), _>("error 1"));
+        let _ = circuit.call(|| Err::<(), _>("error 2"));
+
+        // Callback should have been triggered
+        assert!(opened.load(Ordering::SeqCst));
+    }
+}

data/ext/breaker_machines_native/target/package/breaker-machines-0.1.0/src/callbacks.rs

@@ -0,0 +1,55 @@
+//! Callback system for circuit breaker state transitions
+
+use std::sync::Arc;
+
+/// Callbacks for circuit breaker events
+#[derive(Clone)]
+pub struct Callbacks {
+    pub on_open: Option<Arc<dyn Fn(&str) + Send + Sync>>,
+    pub on_close: Option<Arc<dyn Fn(&str) + Send + Sync>>,
+    pub on_half_open: Option<Arc<dyn Fn(&str) + Send + Sync>>,
+}
+
+impl Callbacks {
+    pub fn new() -> Self {
+        Self {
+            on_open: None,
+            on_close: None,
+            on_half_open: None,
+        }
+    }
+
+    pub fn trigger_open(&self, circuit: &str) {
+        if let Some(ref callback) = self.on_open {
+            callback(circuit);
+        }
+    }
+
+    pub fn trigger_close(&self, circuit: &str) {
+        if let Some(ref callback) = self.on_close {
+            callback(circuit);
+        }
+    }
+
+    pub fn trigger_half_open(&self, circuit: &str) {
+        if let Some(ref callback) = self.on_half_open {
+            callback(circuit);
+        }
+    }
+}
+
+impl Default for Callbacks {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl std::fmt::Debug for Callbacks {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Callbacks")
+            .field("on_open", &self.on_open.is_some())
+            .field("on_close", &self.on_close.is_some())
+            .field("on_half_open", &self.on_half_open.is_some())
+            .finish()
+    }
+}