Initial implementation of BeforeRetry prototype.

api/src/main/java/io/smallrye/faulttolerance/api/BeforeRetryAnnotation.java

@@ -0,0 +1,12 @@
+package io.smallrye.faulttolerance.api;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ ElementType.METHOD, ElementType.TYPE })
+public @interface BeforeRetryAnnotation {
+    String beforeRetryMethod() default "";
+}

implementation/autoconfig/core/src/main/java/io/smallrye/faulttolerance/autoconfig/FaultToleranceMethod.java

@@ -12,6 +12,7 @@
 
 import io.smallrye.common.annotation.Blocking;
 import io.smallrye.common.annotation.NonBlocking;
+import io.smallrye.faulttolerance.api.BeforeRetryAnnotation;
 import io.smallrye.faulttolerance.api.CircuitBreakerName;
 import io.smallrye.faulttolerance.api.CustomBackoff;
 import io.smallrye.faulttolerance.api.ExponentialBackoff;
@@ -41,6 +42,7 @@ public class FaultToleranceMethod {
     public Bulkhead bulkhead;
     public CircuitBreaker circuitBreaker;
     public Fallback fallback;
+    public BeforeRetryAnnotation beforeRetryAnnotation;
     public Retry retry;
     public Timeout timeout;
 

implementation/core/src/main/java/io/smallrye/faulttolerance/core/before/retry/BeforeRetry.java

@@ -0,0 +1,33 @@
+package io.smallrye.faulttolerance.core.before.retry;
+
+import static io.smallrye.faulttolerance.core.before.retry.BeforeRetryLogger.LOG;
+
+import io.smallrye.faulttolerance.core.FaultToleranceStrategy;
+import io.smallrye.faulttolerance.core.InvocationContext;
+
+public class BeforeRetry<V> implements FaultToleranceStrategy<V> {
+
+    private final BeforeRetryFunction<V> beforeRetry;
+
+    private final FaultToleranceStrategy<V> delegate;
+
+    public BeforeRetry(FaultToleranceStrategy<V> delegate, BeforeRetryFunction<V> beforeRetry) {
+        this.delegate = delegate;
+        this.beforeRetry = beforeRetry;
+    }
+
+    @Override
+    public V apply(InvocationContext<V> ctx) throws Exception {
+        LOG.trace("BeforeRetry started");
+        try {
+            return doApply(ctx);
+        } finally {
+            LOG.trace("BeforeRetry finished");
+        }
+    }
+
+    private V doApply(InvocationContext<V> ctx) throws Exception {
+        beforeRetry.call(ctx);
+        return delegate.apply(ctx);
+    }
+}

implementation/core/src/main/java/io/smallrye/faulttolerance/core/before/retry/BeforeRetryFunction.java

@@ -0,0 +1,8 @@
+package io.smallrye.faulttolerance.core.before.retry;
+
+import io.smallrye.faulttolerance.core.InvocationContext;
+
+@FunctionalInterface
+public interface BeforeRetryFunction<T> {
+    void call(InvocationContext<T> invocationContext) throws Exception;
+}

implementation/core/src/main/java/io/smallrye/faulttolerance/core/before/retry/BeforeRetryLogger.java

@@ -0,0 +1,10 @@
+package io.smallrye.faulttolerance.core.before.retry;
+
+import org.jboss.logging.BasicLogger;
+import org.jboss.logging.Logger;
+import org.jboss.logging.annotations.MessageLogger;
+
+@MessageLogger(projectCode = "SRFTL", length = 5)
+interface BeforeRetryLogger extends BasicLogger {
+    BeforeRetryLogger LOG = Logger.getMessageLogger(BeforeRetryLogger.class, BeforeRetryLogger.class.getPackage().getName());
+}

implementation/fault-tolerance/src/main/java/io/smallrye/faulttolerance/FaultToleranceInterceptor.java

@@ -51,6 +51,8 @@
 import io.smallrye.faulttolerance.core.async.CompletionStageExecution;
 import io.smallrye.faulttolerance.core.async.FutureExecution;
 import io.smallrye.faulttolerance.core.async.RememberEventLoop;
+import io.smallrye.faulttolerance.core.before.retry.BeforeRetry;
+import io.smallrye.faulttolerance.core.before.retry.BeforeRetryFunction;
 import io.smallrye.faulttolerance.core.bulkhead.CompletionStageThreadPoolBulkhead;
 import io.smallrye.faulttolerance.core.bulkhead.FutureThreadPoolBulkhead;
 import io.smallrye.faulttolerance.core.bulkhead.SemaphoreBulkhead;
@@ -332,6 +334,10 @@ private <T> FaultToleranceStrategy<T> prepareSyncStrategy(FaultToleranceOperatio
         }
 
         if (operation.hasRetry()) {
+            if (operation.hasBeforeRetry()) {
+                result = new BeforeRetry<>(result, prepareBeforeRetryFunction(point, operation));
+            }
+
             long maxDurationMs = getTimeInMs(operation.getRetry().maxDuration(), operation.getRetry().durationUnit());
 
             Supplier<BackOff> backoff = prepareRetryBackoff(operation);
@@ -362,6 +368,47 @@ private <T> FaultToleranceStrategy<T> prepareSyncStrategy(FaultToleranceOperatio
         return result;
     }
 
+    private static <V> BeforeRetryFunction<V> prepareBeforeRetryFunction(InterceptionPoint point,
+            FaultToleranceOperation operation) {
+        Method beforeRetryMethod;
+
+        String beforeRetryMethodName = operation.getBeforeRetry().beforeRetryMethod();
+
+        if (!"".equals(beforeRetryMethodName)) {
+            try {
+                Method method = point.method();
+                beforeRetryMethod = SecurityActions.getDeclaredMethod(point.beanClass(), method.getDeclaringClass(),
+                        beforeRetryMethodName, method.getGenericParameterTypes());
+                if (beforeRetryMethod == null) {
+                    throw new FaultToleranceException("Could not obtain BeforeRetry method " + beforeRetryMethodName);
+                }
+                SecurityActions.setAccessible(beforeRetryMethod);
+            } catch (PrivilegedActionException e) {
+                throw new FaultToleranceException("Could not obtain BeforeRetry method", e);
+            }
+        } else {
+            throw new FaultToleranceException("Could not obtain BeforeRetry method");
+        }
+
+        return invocationContext -> {
+            InvocationContext interceptionContext = invocationContext.get(InvocationContext.class);
+            try {
+                beforeRetryMethod.invoke(interceptionContext.getTarget(),
+                        interceptionContext.getParameters());
+            } catch (InvocationTargetException e) {
+                Throwable cause = e.getCause();
+                if (cause instanceof Exception) {
+                    throw (Exception) cause;
+                }
+                throw new FaultToleranceException("Error during BeforeRetry method invocation", cause);
+            } catch (Exception e) {
+                throw e;
+            } catch (Throwable e) {
+                throw new FaultToleranceException("Error during BeforeRetry method invocation", e);
+            }
+        };
+    }
+
     private <T> FaultToleranceStrategy<Future<T>> prepareFutureStrategy(FaultToleranceOperation operation,
             InterceptionPoint point) {
         FaultToleranceStrategy<Future<T>> result = invocation();

implementation/fault-tolerance/src/main/java/io/smallrye/faulttolerance/config/BeforeRetryConfig.java

@@ -0,0 +1,13 @@
+package io.smallrye.faulttolerance.config;
+
+import io.smallrye.faulttolerance.api.BeforeRetryAnnotation;
+import io.smallrye.faulttolerance.autoconfig.AutoConfig;
+import io.smallrye.faulttolerance.autoconfig.Config;
+
+@AutoConfig
+public interface BeforeRetryConfig extends BeforeRetryAnnotation, Config {
+
+    @Override
+    default void validate() {
+    }
+}

implementation/fault-tolerance/src/main/java/io/smallrye/faulttolerance/config/FaultToleranceMethods.java

@@ -16,6 +16,7 @@
 
 import io.smallrye.common.annotation.Blocking;
 import io.smallrye.common.annotation.NonBlocking;
+import io.smallrye.faulttolerance.api.BeforeRetryAnnotation;
 import io.smallrye.faulttolerance.api.CircuitBreakerName;
 import io.smallrye.faulttolerance.api.CustomBackoff;
 import io.smallrye.faulttolerance.api.ExponentialBackoff;
@@ -36,6 +37,7 @@ public static FaultToleranceMethod create(AnnotatedMethod<?> method) {
         result.bulkhead = getAnnotation(Bulkhead.class, method, annotationsPresentDirectly);
         result.circuitBreaker = getAnnotation(CircuitBreaker.class, method, annotationsPresentDirectly);
         result.fallback = getAnnotation(Fallback.class, method, annotationsPresentDirectly);
+        result.beforeRetryAnnotation = getAnnotation(BeforeRetryAnnotation.class, method, annotationsPresentDirectly);
         result.retry = getAnnotation(Retry.class, method, annotationsPresentDirectly);
         result.timeout = getAnnotation(Timeout.class, method, annotationsPresentDirectly);
 
@@ -82,6 +84,8 @@ public static FaultToleranceMethod create(Class<?> beanClass, Method method) {
         result.bulkhead = getAnnotation(Bulkhead.class, method, beanClass, annotationsPresentDirectly);
         result.circuitBreaker = getAnnotation(CircuitBreaker.class, method, beanClass, annotationsPresentDirectly);
         result.fallback = getAnnotation(Fallback.class, method, beanClass, annotationsPresentDirectly);
+        result.beforeRetryAnnotation = getAnnotation(BeforeRetryAnnotation.class, method, beanClass,
+                annotationsPresentDirectly);
         result.retry = getAnnotation(Retry.class, method, beanClass, annotationsPresentDirectly);
         result.timeout = getAnnotation(Timeout.class, method, beanClass, annotationsPresentDirectly);
 

implementation/fault-tolerance/src/main/java/io/smallrye/faulttolerance/config/FaultToleranceOperation.java

@@ -28,6 +28,7 @@
 import org.eclipse.microprofile.faulttolerance.Timeout;
 import org.eclipse.microprofile.faulttolerance.exceptions.FaultToleranceDefinitionException;
 
+import io.smallrye.faulttolerance.api.BeforeRetryAnnotation;
 import io.smallrye.faulttolerance.api.CircuitBreakerName;
 import io.smallrye.faulttolerance.api.CustomBackoff;
 import io.smallrye.faulttolerance.api.ExponentialBackoff;
@@ -53,6 +54,7 @@ public static FaultToleranceOperation create(FaultToleranceMethod method) {
                 CircuitBreakerNameConfigImpl.create(method),
                 FallbackConfigImpl.create(method),
                 RetryConfigImpl.create(method),
+                BeforeRetryConfigImpl.create(method),
                 TimeoutConfigImpl.create(method),
                 ExponentialBackoffConfigImpl.create(method),
                 FibonacciBackoffConfigImpl.create(method),
@@ -79,6 +81,8 @@ public static FaultToleranceOperation create(FaultToleranceMethod method) {
 
     private final RetryConfig retry;
 
+    private final BeforeRetryConfig beforeRetry;
+
     private final TimeoutConfig timeout;
 
     private final ExponentialBackoffConfig exponentialBackoff;
@@ -97,6 +101,7 @@ private FaultToleranceOperation(Class<?> beanClass,
             CircuitBreakerNameConfig circuitBreakerName,
             FallbackConfig fallback,
             RetryConfig retry,
+            BeforeRetryConfig beforeRetry,
             TimeoutConfig timeout,
             ExponentialBackoffConfig exponentialBackoff,
             FibonacciBackoffConfig fibonacciBackoff,
@@ -113,6 +118,7 @@ private FaultToleranceOperation(Class<?> beanClass,
         this.circuitBreakerName = circuitBreakerName;
         this.fallback = fallback;
         this.retry = retry;
+        this.beforeRetry = beforeRetry;
         this.timeout = timeout;
 
         this.exponentialBackoff = exponentialBackoff;
@@ -195,6 +201,14 @@ public Fallback getFallback() {
         return fallback;
     }
 
+    public boolean hasBeforeRetry() {
+        return beforeRetry != null;
+    }
+
+    public BeforeRetryAnnotation getBeforeRetry() {
+        return beforeRetry;
+    }
+
     public boolean hasRetry() {
         return retry != null;
     }

testsuite/basic/src/test/java/io/smallrye/faulttolerance/before/retry/BeforeRetryTest.java

@@ -0,0 +1,29 @@
+package io.smallrye.faulttolerance.before.retry;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import javax.inject.Inject;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import io.smallrye.faulttolerance.util.FaultToleranceBasicTest;
+
+@FaultToleranceBasicTest
+public class BeforeRetryTest {
+
+    @Inject
+    private BeforeRetryTestBean beforeRetryTestBean;
+
+    @AfterEach
+    public void cleanUp() {
+        beforeRetryTestBean.reset();
+    }
+
+    @Test
+    public void call() {
+        String value = beforeRetryTestBean.call();
+        assertThat(value).isEqualTo("call 2");
+        assertThat(beforeRetryTestBean.getBeforeRetryRuns()).isEqualTo(2);
+    }
+}

testsuite/basic/src/test/java/io/smallrye/faulttolerance/before/retry/BeforeRetryTestBean.java

@@ -0,0 +1,39 @@
+package io.smallrye.faulttolerance.before.retry;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.enterprise.context.Dependent;
+
+import org.eclipse.microprofile.faulttolerance.Retry;
+
+import io.smallrye.faulttolerance.api.BeforeRetryAnnotation;
+
+@Dependent
+public class BeforeRetryTestBean {
+
+    private final AtomicInteger attempt = new AtomicInteger();
+
+    private final AtomicInteger beforeRetryRuns = new AtomicInteger();
+
+    @Retry(maxRetries = 2)
+    @BeforeRetryAnnotation(beforeRetryMethod = "beforeRetry")
+    public String call() {
+        if (attempt.getAndIncrement() < 1) {
+            throw new IllegalStateException();
+        }
+        return "call " + attempt.get();
+    }
+
+    public void beforeRetry() {
+        beforeRetryRuns.incrementAndGet();
+    }
+
+    public void reset() {
+        attempt.set(0);
+        beforeRetryRuns.set(0);
+    }
+
+    int getBeforeRetryRuns() {
+        return beforeRetryRuns.get();
+    }
+}