Support creating a builder based on existing policy config

- Adds builder factory methods that accept an existing policy config
- Relaxes some of the illegal state assertions inside RetryPolicyBuilder, so that retry policies can be reconfigured with different durations, replacing previous configuration
- Relaxes the requirement that a jitter duration be configured after a delay. If a jitter duration is specified without a delay, the jitter will be ignored.

Author: jhalterman

CHANGELOG.md

@@ -1,3 +1,10 @@
+# 3.0.1
+
+### Improvements
+
+- Issue #310 - Added `.builder(PolicyConfig)` methods to each of the policy interfaces, to allow new policies to be built from existing config.
+- Issue #251 - Relaxed the illegal state validation in `RetryPolicyBuilder` to allow different types of delays to be configured, replacing previous configuration. Also removed the requirement that a jitter duration be configured after a delay.
+
 # 3.0
 
 

src/main/java/dev/failsafe/CircuitBreaker.java

@@ -65,6 +65,13 @@ static <R> CircuitBreakerBuilder<R> builder() {
     return new CircuitBreakerBuilder<>();
   }
 
+  /**
+   * Creates a new CircuitBreakerBuilder that will be based on the {@code config}.
+   */
+  static <R> CircuitBreakerBuilder<R> builder(CircuitBreakerConfig<R> config) {
+    return new CircuitBreakerBuilder<>(config);
+  }
+
   /**
    * Creates a count based CircuitBreaker that opens after a {@link CircuitBreakerBuilder#withFailureThreshold(int)
    * single failure}, closes after a {@link CircuitBreakerBuilder#withSuccessThreshold(int) single success}, and has a 1

src/main/java/dev/failsafe/CircuitBreakerBuilder.java

@@ -60,6 +60,10 @@ public class CircuitBreakerBuilder<R>
     config.failureThresholdingCapacity = 1;
   }
 
+  CircuitBreakerBuilder(CircuitBreakerConfig<R> config) {
+    super(new CircuitBreakerConfig<>(config));
+  }
+
   /**
    * Builds a new {@link CircuitBreaker} using the builder's configuration.
    */
@@ -108,7 +112,7 @@ public CircuitBreakerBuilder<R> onOpen(EventListener<CircuitBreakerStateChangedE
    */
   public CircuitBreakerBuilder<R> withDelay(Duration delay) {
     Assert.notNull(delay, "delay");
-    Assert.isTrue(delay.toNanos() >= 0, "delay must be positive");
+    Assert.isTrue(delay.toNanos() >= 0, "delay must be >= 0");
     config.delay = delay;
     return this;
   }

src/main/java/dev/failsafe/Fallback.java

@@ -39,6 +39,13 @@
  * @see FallbackBuilder
  */
 public interface Fallback<R> extends Policy<R> {
+  /**
+   * Creates a new FallbackBuilder that will be based on the {@code config}.
+   */
+  static <R> FallbackBuilder<R> builder(FallbackConfig<R> config) {
+    return new FallbackBuilder<>(config);
+  }
+
   /**
    * Returns the {@code fallback} to be executed if execution fails.
    *

src/main/java/dev/failsafe/FallbackBuilder.java

@@ -58,6 +58,10 @@ public class FallbackBuilder<R> extends FailurePolicyBuilder<FallbackBuilder<R>,
     config.fallbackStage = fallbackStage;
   }
 
+  FallbackBuilder(FallbackConfig<R> config) {
+    super(new FallbackConfig<>(config));
+  }
+
   /**
    * Builds a new {@link Fallback} using the builder's configuration.
    */
@@ -69,6 +73,8 @@ public Fallback<R> build() {
    * Registers the {@code listener} to be called when the last execution attempt prior to the fallback failed. You can
    * also use {@link #onFailure(EventListener) onFailure} to determine when the fallback attempt also fails.
    * <p>Note: Any exceptions that are thrown from within the {@code listener} are ignored.</p>
+   *
+   * @throws NullPointerException if {@code listener} is null
    */
   public FallbackBuilder<R> onFailedAttempt(EventListener<ExecutionAttemptedEvent<R>> listener) {
     config.failedAttemptListener = Assert.notNull(listener, "listener");

src/main/java/dev/failsafe/RetryPolicy.java

@@ -35,6 +35,13 @@ static <R> RetryPolicyBuilder<R> builder() {
     return new RetryPolicyBuilder<>();
   }
 
+  /**
+   * Creates a new RetryPolicyBuilder that will be based on the {@code config}.
+   */
+  static <R> RetryPolicyBuilder<R> builder(RetryPolicyConfig<R> config) {
+    return new RetryPolicyBuilder<>(config);
+  }
+
   /**
    * Creates a RetryPolicy that allows 3 execution attempts max with no delay.
    */

src/main/java/dev/failsafe/RetryPolicyBuilder.java

@@ -61,6 +61,13 @@ static <R> TimeoutBuilder<R> builder(Duration timeout) {
     return new TimeoutBuilder<>(timeout);
   }
 
+  /**
+   * Creates a new TimeoutBuilder that will be based on the {@code config}.
+   */
+  static <R> TimeoutBuilder<R> builder(TimeoutConfig<R> config) {
+    return new TimeoutBuilder<>(config);
+  }
+
   /**
    * Returns a {@link Timeout} that fails an execution with {@link TimeoutExceededException TimeoutExceededException} if
    * it exceeds the {@code timeout}. Alias for {@code Timeout.builder(timeout).build()}. To configure other options on a

src/main/java/dev/failsafe/Timeout.java

@@ -36,6 +36,10 @@ public class TimeoutBuilder<R> extends PolicyBuilder<TimeoutBuilder<R>, TimeoutC
     super(new TimeoutConfig<>(timeout, false));
   }
 
+  TimeoutBuilder(TimeoutConfig<R> config) {
+    super(new TimeoutConfig<>(config));
+  }
+
   /**
    * Builds a new {@link Timeout} using the builder's configuration.
    */

src/main/java/dev/failsafe/TimeoutBuilder.java

@@ -226,7 +226,8 @@ public ExecutionResult<R> onFailure(ExecutionContext<R> context, ExecutionResult
       lastDelayNanos = delayNanos;
     }
 
-    delayNanos = adjustForJitter(delayNanos);
+    if (delayNanos != 0)
+      delayNanos = adjustForJitter(delayNanos);
     long elapsedNanos = context.getElapsedTime().toNanos();
     delayNanos = adjustForMaxDuration(delayNanos, elapsedNanos);