breaker_machines 0.5.0 → 0.6.0

data/ext/breaker_machines_native/target/package/breaker-machines-0.5.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.5.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()
+    }
+}