First implementation of issue ReactiveX#3

Author: Robert Winkler

src/main/java/io/github/robwin/circuitbreaker/CircuitBreakerConfig.java

@@ -20,6 +20,8 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
+
 
 public class CircuitBreakerConfig {
 
@@ -30,13 +32,19 @@ public class CircuitBreakerConfig {
     private final int maxFailures;
     // The wait interval which specifies how long the CircuitBreaker should stay OPEN
     private final int waitInterval;
+    // The CircuitBreakerEventListener which should handle CircuitBreaker events.
+    private Optional<CircuitBreakerEventListener> circuitBreakerEventListener;
     // Exceptions which do not count as failures and thus not trigger the circuit breaker.
     private final List<Class<? extends Throwable>> ignoredExceptions;
 
-    private CircuitBreakerConfig(int maxFailures, int waitInterval, List<Class<? extends Throwable>> ignoredExceptions){
+    private CircuitBreakerConfig(int maxFailures,
+                                 int waitInterval,
+                                 List<Class<? extends Throwable>> ignoredExceptions,
+                                 Optional<CircuitBreakerEventListener> circuitBreakerEventListener){
         this.maxFailures = maxFailures;
         this.waitInterval = waitInterval;
         this.ignoredExceptions = ignoredExceptions;
+        this.circuitBreakerEventListener = circuitBreakerEventListener;
     }
 
     public Integer getMaxFailures() {
@@ -51,6 +59,10 @@ public List<Class<? extends Throwable>> getIgnoredExceptions() {
         return ignoredExceptions;
     }
 
+    public Optional<CircuitBreakerEventListener> getCircuitBreakerEventListener() {
+        return circuitBreakerEventListener;
+    }
+
     /**
      * Returns a builder to create a custom CircuitBreakerConfig.
      *
@@ -63,8 +75,15 @@ public static CircuitBreakerConfig.Builder custom(){
     public static class Builder {
         private int maxFailures = DEFAULT_MAX_FAILURES;
         private int waitInterval = DEFAULT_WAIT_INTERVAL;
+        private Optional<CircuitBreakerEventListener> circuitBreakerEventListener = Optional.empty();
         private List<Class<? extends Throwable>> ignoredExceptions = new ArrayList<>();
 
+        /**
+         * Configures the maximum number of allowed failures.
+         *
+         * @param maxFailures the maximum number of allowed failures
+         * @return the CircuitBreakerConfig.Builder
+         */
         public Builder maxFailures(int maxFailures) {
             if (maxFailures < 1) {
                 throw new IllegalArgumentException("maxFailures must be greater than or equal to 1");
@@ -73,6 +92,12 @@ public Builder maxFailures(int maxFailures) {
             return this;
         }
 
+        /**
+         * Configures the wait interval in milliseconds which specifies how long the CircuitBreaker should stay OPEN
+         *
+         * @param waitInterval the wait interval in milliseconds which specifies how long the CircuitBreaker should stay OPEN
+         * @return the CircuitBreakerConfig.Builder
+         */
         public Builder waitInterval(int waitInterval) {
             if (waitInterval < 100) {
                 throw new IllegalArgumentException("waitInterval must be at least 100[ms]");
@@ -81,6 +106,12 @@ public Builder waitInterval(int waitInterval) {
             return this;
         }
 
+        /**
+         * Configures an Exception which does not count as a failure and thus does not trigger the circuit breaker.
+         *
+         * @param ignoredException an Exception which should not count as a failure
+         * @return the CircuitBreakerConfig.Builder
+         */
         public Builder ignoredException(Class<? extends Throwable> ignoredException) {
             if (ignoredException == null) {
                 throw new IllegalArgumentException("ignoredException must not be null");
@@ -89,6 +120,12 @@ public Builder ignoredException(Class<? extends Throwable> ignoredException) {
             return this;
         }
 
+        /**
+         * Configures Exceptions which do not count as failures and thus does not trigger the circuit breaker.
+         *
+         * @param ignoredExceptions Exceptions which should not count as failures
+         * @return the CircuitBreakerConfig.Builder
+         */
         public Builder ignoredExceptions(List<Class<? extends Throwable>> ignoredExceptions) {
             if (ignoredExceptions == null) {
                 throw new IllegalArgumentException("ignoredExceptions must not be null");
@@ -97,8 +134,29 @@ public Builder ignoredExceptions(List<Class<? extends Throwable>> ignoredExcepti
             return this;
         }
 
+        /**
+         *  Configures the CircuitBreakerEventListener which should handle CircuitBreaker events.
+         *
+         * @param circuitBreakerEventListener the CircuitBreakerEventListener which should handle CircuitBreaker events.
+         * @return the CircuitBreakerConfig.Builder
+         */
+        public Builder onCircuitBreakerEvent(CircuitBreakerEventListener circuitBreakerEventListener) {
+            if (circuitBreakerEventListener == null) {
+                throw new IllegalArgumentException("circuitBreakerEventListener must not be null");
+            }
+            this.circuitBreakerEventListener = Optional.of(circuitBreakerEventListener);
+            return this;
+        }
+
+        /**
+         * Builds a CircuitBreakerConfig
+         *
+         * @return the CircuitBreakerConfig
+         */
         public CircuitBreakerConfig build() {
-            return new CircuitBreakerConfig(maxFailures, waitInterval, ignoredExceptions);
+            return new CircuitBreakerConfig(maxFailures, waitInterval, ignoredExceptions, circuitBreakerEventListener);
         }
+
+
     }
 }

src/main/java/io/github/robwin/circuitbreaker/CircuitBreakerEvent.java

@@ -0,0 +1,22 @@
+/*
+ *
+ *  Copyright 2015 Robert Winkler
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *
+ */
+package io.github.robwin.circuitbreaker;
+
+public interface CircuitBreakerEvent {
+}

src/main/java/io/github/robwin/circuitbreaker/CircuitBreakerEventListener.java

@@ -0,0 +1,25 @@
+/*
+ *
+ *  Copyright 2015 Robert Winkler
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *
+ */
+package io.github.robwin.circuitbreaker;
+
+@FunctionalInterface
+public interface CircuitBreakerEventListener {
+
+    void onCircuitBreakerEvent(CircuitBreakerEvent circuitBreakerEvent);
+}

src/main/java/io/github/robwin/circuitbreaker/CircuitBreakerStateChangeEvent.java

@@ -0,0 +1,37 @@
+/*
+ *
+ *  Copyright 2015 Robert Winkler
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *
+ */
+package io.github.robwin.circuitbreaker;
+
+public class CircuitBreakerStateChangeEvent implements CircuitBreakerEvent{
+
+    private CircuitBreaker.State previousState, newState;
+
+    public CircuitBreakerStateChangeEvent(CircuitBreaker.State previousState, CircuitBreaker.State newState) {
+        this.previousState = previousState;
+        this.newState = newState;
+    }
+
+    public CircuitBreaker.State getPreviousState() {
+        return previousState;
+    }
+
+    public CircuitBreaker.State getNewState() {
+        return newState;
+    }
+}

src/main/java/io/github/robwin/circuitbreaker/CircuitBreakerStateMachine.java

@@ -105,15 +105,24 @@ public String toString() {
         return String.format("CircuitBreaker '%s'", this.name);
     }
 
-    void resetState() {
+    void resetState(CircuitBreakerState currentState) {
         stateReference.set(new ClosedState(this));
+        circuitBreakerConfig.getCircuitBreakerEventListener()
+                .ifPresent(listener ->
+                        listener.onCircuitBreakerEvent(new CircuitBreakerStateChangeEvent(currentState.getState(), State.CLOSED)));
     }
 
     void transitionToOpenState(CircuitBreakerState currentState) {
         stateReference.set(new OpenState(this, currentState));
+        circuitBreakerConfig.getCircuitBreakerEventListener()
+                .ifPresent(listener ->
+                        listener.onCircuitBreakerEvent(new CircuitBreakerStateChangeEvent(currentState.getState(), State.OPEN)));
     }
 
     void transitionToHalfClosedState(CircuitBreakerState currentState) {
         stateReference.set(new HalfClosedState(this, currentState));
+        circuitBreakerConfig.getCircuitBreakerEventListener()
+                .ifPresent(listener ->
+                        listener.onCircuitBreakerEvent(new CircuitBreakerStateChangeEvent(currentState.getState(), State.HALF_CLOSED)));
     }
 }

src/main/java/io/github/robwin/circuitbreaker/ClosedState.java

@@ -55,7 +55,7 @@ public void recordFailure() {
      */
     @Override
     public void recordSuccess() {
-        stateMachine.resetState();
+        stateMachine.resetState(this);
     }
 
     /**

src/main/java/io/github/robwin/circuitbreaker/HalfClosedState.java

@@ -51,7 +51,7 @@ public void recordFailure() {
      */
     @Override
     public void recordSuccess() {
-        stateMachine.resetState();
+        stateMachine.resetState(this);
     }
 
     /**

src/main/java/io/github/robwin/circuitbreaker/OpenState.java

@@ -53,7 +53,7 @@ public void recordFailure() {
      */
     @Override
     public void recordSuccess() {
-        stateMachine.resetState();
+        stateMachine.resetState(this);
     }
 
     /**

src/test/java/io/github/robwin/circuitbreaker/CircuitBreakerConfigTest.java

@@ -18,10 +18,17 @@
  */
 package io.github.robwin.circuitbreaker;
 
+import javaslang.control.Match;
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.assertj.core.api.BDDAssertions.then;
 
 public class CircuitBreakerConfigTest {
 
+    private static Logger LOG = LoggerFactory.getLogger(CircuitBreakerConfigTest.class);
+
     @Test(expected = IllegalArgumentException.class)
     public void zeroMaxFailuresShouldFail() {
         CircuitBreakerConfig.custom().maxFailures(0).build();
@@ -31,4 +38,34 @@ public void zeroMaxFailuresShouldFail() {
     public void zeroWaitIntervalShouldFail() {
         CircuitBreakerConfig.custom().waitInterval(0).build();
     }
+
+    @Test()
+    public void shouldSetMaxFailures() {
+        CircuitBreakerConfig circuitBreakerConfig = CircuitBreakerConfig.custom().maxFailures(5).build();
+        then(circuitBreakerConfig.getMaxFailures()).isEqualTo(5);
+    }
+
+    @Test()
+    public void shouldSetWaitInterval() {
+        CircuitBreakerConfig circuitBreakerConfig = CircuitBreakerConfig.custom().waitInterval(1000).build();
+        then(circuitBreakerConfig.getWaitInterval()).isEqualTo(1000);
+    }
+
+    @Test
+    public void shouldAddACircuitBreakerEventListener() {
+        CircuitBreakerConfig circuitBreakerConfig = CircuitBreakerConfig.custom()
+                .onCircuitBreakerEvent((CircuitBreakerEvent circuitBreakerEvent)
+                        -> Match.of(circuitBreakerEvent)
+                        .whenType(CircuitBreakerStateChangeEvent.class)
+                        .then((event) -> event.getNewState().toString()))
+                .build();
+        then(circuitBreakerConfig.getCircuitBreakerEventListener().isPresent()).isTrue();
+    }
+
+    @Test
+    public void circuitBreakerEventListenerShouldBeEmpty() {
+        CircuitBreakerConfig circuitBreakerConfig = CircuitBreakerConfig.custom()
+                .build();
+        then(circuitBreakerConfig.getCircuitBreakerEventListener().isPresent()).isFalse();
+    }
 }

…/circuitbreaker/MonitorRegistryTest.java …tbreaker/CircuitBreakerRegistryTest.javasrc/test/java/io/github/robwin/circuitbreaker/MonitorRegistryTest.java renamed to src/test/java/io/github/robwin/circuitbreaker/CircuitBreakerRegistryTest.java src/test/java/io/github/robwin/circuitbreaker/MonitorRegistryTest.java renamed to src/test/java/io/github/robwin/circuitbreaker/CircuitBreakerRegistryTest.java

@@ -24,7 +24,7 @@
 import static org.assertj.core.api.BDDAssertions.assertThat;
 
 
-public class MonitorRegistryTest {
+public class CircuitBreakerRegistryTest {
 
     private CircuitBreakerRegistry circuitBreakerRegistry;