* added circuitbreaker configs to ratpack module

* added ratelimiter configs to ratpack module
* added retry configs to ratpack module

closes ReactiveX#123

Author: drmaas

resilience4j-circuitbreaker/src/main/java/io/github/resilience4j/circuitbreaker/CircuitBreaker.java

@@ -39,7 +39,7 @@
  *
  * A {@link CircuitBreaker} manages the state of a backend system.
  * The CircuitBreaker is implemented via a finite state machine with three states: CLOSED, OPEN and HALF_OPEN.
- * The CircuitBreaker does not know anything about the backend’s state by itself, but uses the information provided by the decorators via
+ * The CircuitBreaker does not know anything about the backend's state by itself, but uses the information provided by the decorators via
  * {@link CircuitBreaker#onSuccess} and {@link CircuitBreaker#onError} events.
  * Before communicating with the backend, the the permission to do so must be obtained via the method {@link CircuitBreaker#isCallPermitted()}.
  *

resilience4j-documentation/src/docs/asciidoc/addon_guides/ratpack.adoc

@@ -18,6 +18,31 @@ dependencies {
 }
 ```
 
+==== Basic Usage
+
+Installing the `Resilience4jModule` module provides a `CircuitBreakerRegistry`, `RateLimiterRegistry`,
+and `RetryRegistry` with the default configurations. It also install the Guice method interceptors
+for CircuitBreakers, RateLimiters, and Retries. Finally, it allows configuration of metrics
+and even the building of CircuitBreakers, RateLimiters, and Retries. See below for configuration details.
+
+Note: If you don't register a `CircuitBreakerRegistry` or `RateLimiterRegistry` or `RetryRegistry`, the defaults
+will be used.
+
+For example
+
+[source,java]
+----
+public class MyModule extends AbstractModule {
+
+    @Override
+    protected void configure() {
+        CircuitBreakerConfig config = CircuitBreakerConfig.custom();
+        bind(CircuitBreakerRegistry.class).toInstance(CircuitBreakerRegistry.of(config);
+        install(Resilience4jModule.class);
+    }
+}
+----
+
 ==== Handlers
 
 You can rate limit an endpoint by defining a `RateLimiterHandler` for the endpoint.
@@ -187,6 +212,92 @@ public class BusinessBService implements BusinessService  {
 }
 ----
 
+==== Adding CircuitBreakers, RateLimiters, and Retries
+These can be defined in the module configuration or in an external configuration.
+Note that the module only provide default registries, which you can replace by
+binding your own.
+
+Module configuration example:
+
+[source,java]
+----
+public class MyModule extends AbstractModule {
+
+    @Override
+    protected void configure() {
+        Resilience4jModule module = new Resilience4jModule();
+        module.configure(c -> c
+            .circuitBreaker("test1", cb -> cb
+                .defaults(true)
+            ).circuitBreaker("test2", cb -> cb
+                .failureRateThreshold(50)
+                .waitIntervalInMillis(5000)
+                .ringBufferSizeInClosedState(200)
+                .ringBufferSizeInHalfOpenState(20)
+            ).rateLimiter("test1", cb -> cb
+                .defaults(true)
+            ).rateLimiter("test2", cb -> cb
+                .limitForPeriod(100)
+                .limitRefreshPeriodInNanos(500)
+                .timeoutInMillis(10)
+            ).retry("test1", cb -> cb
+                .defaults(true)
+            ).retry("test2", cb -> cb
+                .maxAttempts(3)
+                .waitDurationInMillis(1000)
+            )
+        );
+        install(module);
+    }
+}
+----
+
+External configuration example:
+
+[source,groovy]
+----
+ratpack {
+    serverConfig {
+        yaml(getClass().classLoader.getResource('application.yml'))
+        require("/resilience4j", Resilience4jConfig)
+    }
+    bindings {
+        module(Resilience4jModule)
+    }
+    handlers {
+        get {
+            render 'ok'
+        }
+    }
+}
+----
+
+[source,yaml]
+----
+resilience4j:
+    circuitBreakers:
+        test1:
+            defaults: true
+        test2:
+            ringBufferSizeInClosedState: 200
+            ringBufferSizeInHalfOpenState: 20
+            waitInterval: 5000
+            failureRateThreshold: 50
+    rateLimiters:
+        test1:
+            defaults: true
+        test2:
+            limitForPeriod: 100
+            limitRefreshPeriodInNanos: 500
+            timeoutInMillis: 10
+    retries:
+        test1:
+            defaults: true
+        test2:
+            maxAttempts: 3
+            waitDurationInMillis: 1000
+----
+
 ==== Metrics
 Both dropwizard and prometheus metrics can be auto configured and enabled for all registered
 circuitbreaker instances, ratelimiter instances, and retry instances.
@@ -237,29 +348,6 @@ Ratpack provides the concept of a health check. See https://ratpack.io/manual/cu
 CircuitBreaker, RateLimiter, and Retry health checks have not been implemented yet.
 When implemented they should function similarly to the spring boot health checks.
 
-==== Configuration
-
-You must install the `Resilience4jModule` Guice Module if you want to use AOP so that the method interceptors work.
-You can optionally configure your CircuitBreakers, RateLimiters, and Retries in your Guice Module as well.
-
-Note: If you don't register a `CircuitBreakerRegistry` or `RateLimiterRegistry`, the defaults
-will be used when using AOP.
-
-For example
-
-[source,java]
-----
-public class MyModule extends AbstractModule {
-
-    @Override
-    protected void configure() {
-        CircuitBreakerConfig config = CircuitBreakerConfig.custom();
-        bind(CircuitBreakerRegistry.class).toInstance(CircuitBreakerRegistry.of(config);
-        install(Resilience4jModule.class);
-    }
-}
-----
-
 ==== CircuitBreaker Event Monitoring
 TODO
 Handlers for displaying the last X CircuitBreaker, Ratelimiter, or Retry events are not yet implemented.

resilience4j-ratpack/src/main/java/io/github/resilience4j/ratpack/Resilience4jConfig.java

@@ -16,10 +16,53 @@
 
 package io.github.resilience4j.ratpack;
 
+import io.github.resilience4j.ratpack.circuitbreaker.CircuitBreakerConfig;
+import io.github.resilience4j.ratpack.ratelimiter.RateLimiterConfig;
+import io.github.resilience4j.ratpack.retry.RetryConfig;
+import ratpack.func.Function;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static ratpack.util.Exceptions.uncheck;
+
 public class Resilience4jConfig {
+    private Map<String, CircuitBreakerConfig> circuitBreakers = new HashMap<>();
+    private Map<String, RateLimiterConfig> rateLimiters = new HashMap<>();
+    private Map<String, RetryConfig> retries = new HashMap<>();
     private boolean metrics = false;
     private boolean prometheus = false;
 
+    public Resilience4jConfig circuitBreaker(String name, Function<? super CircuitBreakerConfig, ? extends CircuitBreakerConfig> configure) {
+        try {
+            CircuitBreakerConfig finalConfig = configure.apply(new CircuitBreakerConfig());
+            circuitBreakers.put(name, finalConfig);
+            return this;
+        } catch (Exception e) {
+            throw uncheck(e);
+        }
+    }
+
+    public Resilience4jConfig rateLimiter(String name, Function<? super RateLimiterConfig, ? extends RateLimiterConfig> configure) {
+        try {
+            RateLimiterConfig finalConfig = configure.apply(new RateLimiterConfig());
+            rateLimiters.put(name, finalConfig);
+            return this;
+        } catch (Exception e) {
+            throw uncheck(e);
+        }
+    }
+
+    public Resilience4jConfig retry(String name, Function<? super RetryConfig, ? extends RetryConfig> configure) {
+        try {
+            RetryConfig finalConfig = configure.apply(new RetryConfig());
+            retries.put(name, finalConfig);
+            return this;
+        } catch (Exception e) {
+            throw uncheck(e);
+        }
+    }
+
     public Resilience4jConfig metrics(boolean metrics) {
         this.metrics = metrics;
         return this;
@@ -30,6 +73,18 @@ public Resilience4jConfig prometheus(boolean prometheus) {
         return this;
     }
 
+    public Map<String, CircuitBreakerConfig> getCircuitBreakers() {
+        return circuitBreakers;
+    }
+
+    public Map<String, RateLimiterConfig> getRateLimiters() {
+        return rateLimiters;
+    }
+
+    public Map<String, RetryConfig> getRetries() {
+        return retries;
+    }
+
     public boolean isMetrics() {
         return metrics;
     }

resilience4j-ratpack/src/main/java/io/github/resilience4j/ratpack/Resilience4jModule.java

@@ -21,19 +21,22 @@
 import com.google.inject.Provides;
 import com.google.inject.matcher.Matchers;
 import com.google.inject.multibindings.OptionalBinder;
+import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
 import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
 import io.github.resilience4j.metrics.CircuitBreakerMetrics;
 import io.github.resilience4j.metrics.RateLimiterMetrics;
 import io.github.resilience4j.metrics.RetryMetrics;
 import io.github.resilience4j.prometheus.CircuitBreakerExports;
 import io.github.resilience4j.prometheus.RateLimiterExports;
+import io.github.resilience4j.ratelimiter.RateLimiterConfig;
 import io.github.resilience4j.ratelimiter.RateLimiterRegistry;
 import io.github.resilience4j.ratpack.circuitbreaker.CircuitBreaker;
 import io.github.resilience4j.ratpack.circuitbreaker.CircuitBreakerMethodInterceptor;
 import io.github.resilience4j.ratpack.ratelimiter.RateLimiter;
 import io.github.resilience4j.ratpack.ratelimiter.RateLimiterMethodInterceptor;
 import io.github.resilience4j.ratpack.retry.Retry;
 import io.github.resilience4j.ratpack.retry.RetryMethodInterceptor;
+import io.github.resilience4j.retry.RetryConfig;
 import io.github.resilience4j.retry.RetryRegistry;
 import io.prometheus.client.CollectorRegistry;
 import ratpack.api.Nullable;
@@ -44,6 +47,7 @@
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
+import java.time.Duration;
 
 /**
  * This module registers class and method interceptors for circuit breakers, rate limiters, and retries.
@@ -152,17 +156,64 @@ public Resilience4jService(Injector injector, Resilience4jConfig config) {
 
         @Override
         public void onStart(StartEvent event) throws Exception {
+
+            // build circuit breakers
+            CircuitBreakerRegistry circuitBreakerRegistry = injector.getInstance(CircuitBreakerRegistry.class);
+            config.getCircuitBreakers().forEach((name, circuitBreakerConfig) -> {
+                if (circuitBreakerConfig.getDefaults()) {
+                    circuitBreakerRegistry.circuitBreaker(name);
+                } else {
+                    circuitBreakerRegistry.circuitBreaker(name, CircuitBreakerConfig.custom()
+                            .failureRateThreshold(circuitBreakerConfig.getFailureRateThreshold())
+                            .ringBufferSizeInClosedState(circuitBreakerConfig.getRingBufferSizeInClosedState())
+                            .ringBufferSizeInHalfOpenState(circuitBreakerConfig.getRingBufferSizeInHalfOpenState())
+                            .waitDurationInOpenState(Duration.ofMillis(circuitBreakerConfig.getWaitIntervalInMillis()))
+                            .build());
+                }
+            });
+
+            // build rate limiters
+            RateLimiterRegistry rateLimiterRegistry = injector.getInstance(RateLimiterRegistry.class);
+            config.getRateLimiters().forEach((name, rateLimiterConfig) -> {
+                if (rateLimiterConfig.getDefaults()) {
+                    rateLimiterRegistry.rateLimiter(name);
+                } else {
+                    rateLimiterRegistry.rateLimiter(name, RateLimiterConfig.custom()
+                            .limitForPeriod(rateLimiterConfig.getLimitForPeriod())
+                            .limitRefreshPeriod(Duration.ofNanos(rateLimiterConfig.getLimitRefreshPeriodInNanos()))
+                            .timeoutDuration(Duration.ofMillis(rateLimiterConfig.getTimeoutInMillis()))
+                            .build());
+                }
+            });
+
+            // build retries
+            RetryRegistry retryRegistry = injector.getInstance(RetryRegistry.class);
+            config.getRetries().forEach((name, retryConfig) -> {
+                if (retryConfig.getDefaults()) {
+                    retryRegistry.retry(name);
+                } else {
+                    retryRegistry.retry(name, RetryConfig.custom()
+                            .maxAttempts(retryConfig.getMaxAttempts())
+                            .waitDuration(Duration.ofMillis(retryConfig.getWaitDurationInMillis()))
+                            .build());
+                }
+            });
+
+            // dropwizard metrics
             if (config.isMetrics() && injector.getExistingBinding(Key.get(MetricRegistry.class)) != null) {
                 MetricRegistry metricRegistry = injector.getInstance(MetricRegistry.class);
                 metricRegistry.registerAll(injector.getInstance(CircuitBreakerMetrics.class));
                 metricRegistry.registerAll(injector.getInstance(RateLimiterMetrics.class));
                 metricRegistry.registerAll(injector.getInstance(RetryMetrics.class));
             }
+
+            // prometheus
             if (config.isPrometheus() && injector.getExistingBinding(Key.get(CollectorRegistry.class)) != null) {
                 CollectorRegistry collectorRegistry = injector.getInstance(CollectorRegistry.class);
                 injector.getInstance(CircuitBreakerExports.class).register(collectorRegistry);
                 injector.getInstance(RateLimiterExports.class).register(collectorRegistry);
             }
+
         }
 
     }