Failsafe 3

MIGRATION.md

@@ -1,3 +1,20 @@
+# Riptide 4.0 Migration Guide
+
+## Failsafe
+
+**Failsafe version was upgrade from 2.4.3 to 3.3.0**
+
+There are many breaking changes between Failsafe version 2.4.3 and version 3.3.0, 
+see [Failsafe CHANGELOG](https://github.com/failsafe-lib/failsafe/blob/master/CHANGELOG.md#330) for all details.    
+Here are some of the breaking changes that can affect `riptide-failsafe` users:
+
+- The maven group id for Failsafe has changed to `dev.failsafe`
+- All files have been moved to the `dev.failsafe` package
+- `Scheduler`, `DefaultScheduledFuture` and `PolicyExecutor` were moved to the spi package
+- All policies now use a builder API instead of constructors
+- `DelayFunction` interface has been removed, `ContextualSupplier` should be used instead since it provides access to the same information
+- `CircuitBreakerBuilder` `onOpen`, `onClose`, and `onHalfOpen` methods now accept an `EventListener<CircuitBreakerStateChangedEvent>` argument
+
 # Riptide 3.0 Migration Guide
 
 ## Before You Start

cve-suppressions.xml

@@ -34,6 +34,8 @@
         <cve>CVE-2021-4277</cve>
         <cve>CVE-2022-3064</cve>
         <cve>CVE-2021-4235</cve>
+        <cve>CVE-2022-45688</cve>
+        <cve>CVE-2020-8908</cve>
     </suppress>
 
     <!-- https://github.com/jeremylong/DependencyCheck/issues/1921 -->

docs/resilience.md

@@ -34,11 +34,13 @@ riptide.clients:
 The [riptide-faults](../riptide-faults) module provides a set `TransientFaults` predicates that detects transient faults:
 
 ```java
-Http.builder()
-    .plugin(new FailsafePlugin()
-        .withPolicy(new RetryRequestPolicy(
-            new RetryPolicy().handleIf(transientSocketFaults()))
-))
+Http.builder().requestFactory(new HttpComponentsClientHttpRequestFactory())
+        .plugin(new FailsafePlugin()
+            .withPolicy(new RetryRequestPolicy(
+                    RetryPolicy.<ClientHttpResponse>builder()
+                        .handleIf(CheckedPredicateConverter.toCheckedPredicate(transientSocketFaults()))
+                        .build())
+            ));
 ```
 
 ```yaml

riptide-failsafe/README.md

@@ -11,7 +11,7 @@ and a circuit breaker to every remote call.
 ## Example
 
 ```java
-Http.builder()
+Http.builder().requestFactory(new HttpComponentsClientHttpRequestFactory())
     .plugin(new FailsafePlugin()
         .withPolicy(circuitBreaker)
         .withPolicy(new RetryRequestPolicy(retryPolicy)))
@@ -45,21 +45,23 @@ Add the following dependency to your project:
 The failsafe plugin will not perform retries nor apply circuit breakers unless they were explicitly configured:
 
 ```java
-Http.builder()
+Http.builder().requestFactory(new HttpComponentsClientHttpRequestFactory())
     .plugin(new FailsafePlugin()
         .withPolicy(
             new RetryRequestPolicy(
-                new RetryPolicy<ClientHttpResponse>()
-                   .withDelay(Duration.ofMillis(25))
-                   .withDelay(new RetryAfterDelayFunction(clock))
-                   .withMaxRetries(4))
+                RetryPolicy.<ClientHttpResponse>builder()
+                    .withDelay(Duration.ofMillis(25))
+                    .withDelayFn(new RetryAfterDelayFunction(clock))
+                    .withMaxRetries(4)
+                    .build())
                 .withListener(myRetryListener))
         .withPolicy(
-            new CircuitBreaker<ClientHttpResponse>()
+            CircuitBreaker.<ClientHttpResponse>builder()
                 .withFailureThreshold(3, 10)
                 .withSuccessThreshold(5)
-                .withDelay(Duration.ofMinutes(1)))
-    .build();
+                .withDelay(Duration.ofMinutes(1))
+                .build()))
+        .build();
 ```
 
 Please visit the [Failsafe readme](https://github.com/jhalterman/failsafe#readme) in order to see possible configurations. 
@@ -70,9 +72,10 @@ Please visit the [Failsafe readme](https://github.com/jhalterman/failsafe#readme
 You'll need to register `RetryException` in order for the `retry()` route to work:
 
 ```java
-new RetryPolicy<ClientHttpResponse>()
+RetryPolicy.<ClientHttpResponse>builder()
     .handle(SocketTimeoutException.class)
-    .handle(RetryException.class);
+    .handle(RetryException.class)
+    .build();
 ```
 
 Failsafe supports dynamically computed delays using a custom function.
@@ -82,14 +85,15 @@ Riptide: Failsafe offers implementations that understand:
 - [`X-RateLimit-Reset` (RESTful API Guidelines)](https://opensource.zalando.com/restful-api-guidelines/#153)
 
 ```java
-Http.builder()
+Http.builder().requestFactory(new HttpComponentsClientHttpRequestFactory())
     .plugin(new FailsafePlugin()
-        .withPolicy(new RetryPolicy<ClientHttpResponse>()
-            .withDelay(composite(
+        .withPolicy(RetryPolicy.<ClientHttpResponse>builder()
+            .withDelayFn(new CompositeDelayFunction<>(Arrays.asList(
                 new RetryAfterDelayFunction(clock),
                 new RateLimitResetDelayFunction(clock)
-            ))
-            .withMaxDuration(Duration.ofSeconds(5))))
+            )))
+            .withMaxDuration(Duration.ofSeconds(5))
+            .build()))
     .build();
 ```
 
@@ -104,7 +108,7 @@ Failsafe and Spring Boot.
 The `BackupRequest` policy implements the [*backup request*][abstract] pattern, also known as [*hedged requests*][article]:
 
 ```java
-Http.builder()
+Http.builder().requestFactory(new HttpComponentsClientHttpRequestFactory())
     .plugin(new FailsafePlugin()
         .withPolicy(new BackupRequest(1, SECONDS)))
     .build();
@@ -165,9 +169,10 @@ http.post("/subscriptions/{id}/cursors", subscriptionId)
 In case those options are insufficient you may specify your own method detector:
 
 ```java
-Http.builder()
-    .plugin(new FailsafePlugin(ImmutableList.of(retryPolicy))
-        .withIdempontentMethodDetector(new CustomIdempotentMethodDetector()))
+Http.builder().requestFactory(new HttpComponentsClientHttpRequestFactory())
+    .plugin(new FailsafePlugin()
+        .withPolicy(retryPolicy)
+        .withDecorator(new CustomIdempotentMethodDetector()))
     .build();
 ```
 

riptide-failsafe/pom.xml

@@ -17,7 +17,7 @@
     <description>Client side response routing</description>
 
     <properties>
-        <failsafe.version>2.4.3</failsafe.version>
+        <failsafe.version>3.3.0</failsafe.version>
     </properties>
 
     <dependencies>
@@ -31,7 +31,7 @@
             <artifactId>riptide-idempotency</artifactId>
         </dependency>
         <dependency>
-            <groupId>net.jodah</groupId>
+            <groupId>dev.failsafe</groupId>
             <artifactId>failsafe</artifactId>
             <version>${failsafe.version}</version>
         </dependency>

riptide-failsafe/src/main/java/org/zalando/riptide/failsafe/BackupRequest.java

@@ -1,34 +1,36 @@
 package org.zalando.riptide.failsafe;
 
-import lombok.AllArgsConstructor;
+import dev.failsafe.Policy;
+import dev.failsafe.PolicyConfig;
+import dev.failsafe.spi.PolicyExecutor;
 import lombok.Getter;
-import net.jodah.failsafe.AbstractExecution;
-import net.jodah.failsafe.Policy;
-import net.jodah.failsafe.PolicyExecutor;
 import org.apiguardian.api.API;
 
 import java.util.concurrent.TimeUnit;
 
 import static org.apiguardian.api.API.Status.EXPERIMENTAL;
 
 @API(status = EXPERIMENTAL)
-@AllArgsConstructor
 @Getter
 public final class BackupRequest<R> implements Policy<R> {
 
     private final long delay;
     private final TimeUnit unit;
+    private final PolicyConfig<R> config = new PolicyConfig<R>() {
+    };
+
+    public BackupRequest(long delay, TimeUnit unit) {
+        this.delay = delay;
+        this.unit = unit;
+    }
 
     @Override
-    @SuppressWarnings("unchecked")
-    public PolicyExecutor<Policy<R>> toExecutor(
-            final AbstractExecution execution) {
-        return (PolicyExecutor<Policy<R>>) create(execution);
+    public PolicyExecutor<R> toExecutor(int policyIndex) {
+        return create(policyIndex);
     }
 
-    private PolicyExecutor<? extends Policy<R>> create(
-            final AbstractExecution execution) {
-        return new BackupRequestExecutor<R>(this, execution);
+    private PolicyExecutor<R> create(int policyIndex) {
+        return new BackupRequestExecutor<>(this, policyIndex);
     }
 
 }

riptide-failsafe/src/main/java/org/zalando/riptide/failsafe/BackupRequestExecutor.java

@@ -1,38 +1,41 @@
 package org.zalando.riptide.failsafe;
 
-import net.jodah.failsafe.AbstractExecution;
-import net.jodah.failsafe.ExecutionResult;
-import net.jodah.failsafe.FailsafeFuture;
-import net.jodah.failsafe.PolicyExecutor;
-import net.jodah.failsafe.util.concurrent.Scheduler;
+import dev.failsafe.spi.AsyncExecutionInternal;
+import dev.failsafe.spi.ExecutionResult;
+import dev.failsafe.spi.FailsafeFuture;
+import dev.failsafe.spi.PolicyExecutor;
+import dev.failsafe.spi.Scheduler;
 
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiConsumer;
-import java.util.function.Supplier;
+import java.util.function.Function;
 
 import static org.zalando.riptide.CompletableFutures.forwardTo;
 
-final class BackupRequestExecutor<R> extends PolicyExecutor<BackupRequest<R>> {
+final class BackupRequestExecutor<R> extends PolicyExecutor<R> {
 
-    BackupRequestExecutor(final BackupRequest<R> policy, final AbstractExecution execution) {
-        super(policy, execution);
+    private final BackupRequest<R> policy;
+
+    BackupRequestExecutor(final BackupRequest<R> policy, int policyIndex) {
+        super(policy, policyIndex);
+        this.policy = policy;
     }
 
     @Override
-    protected Supplier<CompletableFuture<ExecutionResult>> supplyAsync(
-            final Supplier<CompletableFuture<ExecutionResult>> supplier,
+    public Function<AsyncExecutionInternal<R>, CompletableFuture<ExecutionResult<R>>> applyAsync(
+            Function<AsyncExecutionInternal<R>, CompletableFuture<ExecutionResult<R>>> innerFn,
             final Scheduler scheduler,
-            final FailsafeFuture<Object> future) {
+            final FailsafeFuture<R> future) {
 
-        return () -> {
-            final CompletableFuture<ExecutionResult> original = supplier.get();
-            final CompletableFuture<ExecutionResult> backup = new CompletableFuture<>();
+        return (asyncExecutionInternal) -> {
+            final CompletableFuture<ExecutionResult<R>> original = innerFn.apply(asyncExecutionInternal);
+            final CompletableFuture<ExecutionResult<R>> backup = new CompletableFuture<>();
 
-            final Future<?> scheduledBackup = delay(scheduler, backup(supplier, backup));
+            final Future<?> scheduledBackup = delay(scheduler, backup(innerFn, asyncExecutionInternal, backup));
 
             original.whenComplete(cancel(scheduledBackup));
             backup.whenComplete(cancel(original));
@@ -41,11 +44,12 @@ protected Supplier<CompletableFuture<ExecutionResult>> supplyAsync(
         };
     }
 
-    private Callable<CompletableFuture<ExecutionResult>> backup(
-            final Supplier<CompletableFuture<ExecutionResult>> supplier,
-            final CompletableFuture<ExecutionResult> target) {
+    private Callable<CompletableFuture<ExecutionResult<R>>> backup(
+            final Function<AsyncExecutionInternal<R>, CompletableFuture<ExecutionResult<R>>> innerFn,
+            final AsyncExecutionInternal<R> asyncExecutionInternal,
+            final CompletableFuture<ExecutionResult<R>> target) {
 
-        return () -> supplier.get().whenComplete(forwardTo(target));
+        return () -> innerFn.apply(asyncExecutionInternal).whenComplete(forwardTo(target));
     }
 
     @SuppressWarnings("unchecked")

riptide-failsafe/src/main/java/org/zalando/riptide/failsafe/CheckedPredicateConverter.java

@@ -0,0 +1,15 @@
+package org.zalando.riptide.failsafe;
+
+import dev.failsafe.function.CheckedPredicate;
+
+import java.util.function.Predicate;
+
+public class CheckedPredicateConverter {
+
+    private CheckedPredicateConverter() {
+    }
+
+    public static <T> CheckedPredicate<T> toCheckedPredicate(Predicate<T> predicate) {
+        return predicate::test;
+    }
+}

riptide-failsafe/src/main/java/org/zalando/riptide/failsafe/CompositeDelayFunction.java

@@ -1,8 +1,8 @@
 package org.zalando.riptide.failsafe;
 
+import dev.failsafe.function.ContextualSupplier;
 import lombok.AllArgsConstructor;
-import net.jodah.failsafe.ExecutionContext;
-import net.jodah.failsafe.function.DelayFunction;
+import dev.failsafe.ExecutionContext;
 import org.apiguardian.api.API;
 
 import java.time.Duration;
@@ -14,23 +14,28 @@
 
 @API(status = EXPERIMENTAL)
 @AllArgsConstructor
-public final class CompositeDelayFunction<R, X extends Throwable>
-        implements DelayFunction<R, X> {
+public final class CompositeDelayFunction<R> implements ContextualSupplier<R, Duration> {
 
-    private final Collection<DelayFunction<R, X>> functions;
+    private final Collection<ContextualSupplier<R, Duration>> functions;
 
     @Override
-    public Duration computeDelay(final R result, final X failure, final ExecutionContext context) {
+    public Duration get(final ExecutionContext<R> context) throws Throwable {
         return functions.stream()
-                .map(function -> function.computeDelay(result, failure, context))
+                .map(function -> {
+                    try {
+                        return function.get(context);
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+                })
                 .filter(Objects::nonNull)
                 .findFirst()
                 .orElse(null);
     }
 
     @SafeVarargs
-    public static <R, X extends Throwable> DelayFunction<R, X> composite(
-            final DelayFunction<R, X>... functions) {
+    public static <R, X extends Throwable> ContextualSupplier<R, Duration> composite(
+            final ContextualSupplier<R, Duration>... functions) {
         return new CompositeDelayFunction<>(Arrays.asList(functions));
     }
 

riptide-failsafe/src/main/java/org/zalando/riptide/failsafe/CompositeRetryListener.java

@@ -1,7 +1,7 @@
 package org.zalando.riptide.failsafe;
 
 import lombok.AllArgsConstructor;
-import net.jodah.failsafe.event.ExecutionAttemptedEvent;
+import dev.failsafe.event.ExecutionAttemptedEvent;
 import org.apiguardian.api.API;
 import org.springframework.http.client.ClientHttpResponse;
 import org.zalando.riptide.RequestArguments;

riptide-failsafe/src/main/java/org/zalando/riptide/failsafe/CompositeTaskDecorator.java

@@ -1,7 +1,7 @@
 package org.zalando.riptide.failsafe;
 
 import lombok.AllArgsConstructor;
-import net.jodah.failsafe.function.ContextualSupplier;
+import dev.failsafe.function.ContextualSupplier;
 
 import java.util.Collection;
 
@@ -11,8 +11,8 @@ final class CompositeTaskDecorator implements TaskDecorator {
     private final Collection<TaskDecorator> decorators;
 
     @Override
-    public <T> ContextualSupplier<T> decorate(final ContextualSupplier<T> supplier) {
-        ContextualSupplier<T> result = supplier;
+    public <T, R> ContextualSupplier<T, R> decorate(final ContextualSupplier<T, R> supplier) {
+        ContextualSupplier<T, R> result = supplier;
         for (final TaskDecorator decorator : decorators) {
             result = decorator.decorate(result);
         }

riptide-failsafe/src/main/java/org/zalando/riptide/failsafe/ConditionalRequestPolicy.java

@@ -1,7 +1,7 @@
 package org.zalando.riptide.failsafe;
 
 import lombok.AllArgsConstructor;
-import net.jodah.failsafe.Policy;
+import dev.failsafe.Policy;
 import org.springframework.http.client.ClientHttpResponse;
 import org.zalando.riptide.RequestArguments;
 

riptide-failsafe/src/main/java/org/zalando/riptide/failsafe/DefaultRequestPolicy.java

@@ -1,7 +1,7 @@
 package org.zalando.riptide.failsafe;
 
 import lombok.AllArgsConstructor;
-import net.jodah.failsafe.Policy;
+import dev.failsafe.Policy;
 import org.springframework.http.client.ClientHttpResponse;
 import org.zalando.riptide.RequestArguments;