Merge pull request #74 from raghavan20/match-against-exception-cause

Supporting to match against exception's cause

Author: elennick

README.md

@@ -149,6 +149,14 @@ RetryConfig config = new RetryConfigBuilder()
         .build();
 ```
 
+If you want the executor to continue to retry when encountered exception's cause is among a list of exceptions, then specify **retryOnCausedBy()** config option
+```java
+RetryConfig config = new RetryConfigBuilder()
+        .retryOnCausedBy()
+        .retryOnSpecificExceptions(ConnectException.class, TimeoutException.class)
+        .build();
+```
+
 If you want the executor to continue to retry on all encountered exceptions EXCEPT for a few specific ones, specify this using the **retryOnAnyExceptionExcluding()** config option. If this exception strategy is chosen, only the exceptions specified or their subclasses will interupt the executor and throw an **UnexpectedException**.
 
 ```java

src/main/java/com/evanlennick/retry4j/CallExecutor.java

@@ -10,7 +10,7 @@
 
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
-import java.util.UUID;
+import java.util.*;
 import java.util.concurrent.Callable;
 import java.util.concurrent.TimeUnit;
 
@@ -178,7 +178,8 @@ private void sleep(long millis, int tries) {
         logger.trace("Retry4j executor sleeping for {} ms", millisToSleep);
         try {
             TimeUnit.MILLISECONDS.sleep(millisToSleep);
-        } catch (InterruptedException ignored) {}
+        } catch (InterruptedException ignored) {
+        }
     }
 
     private boolean shouldThrowException(Exception e) {
@@ -191,25 +192,45 @@ private boolean shouldThrowException(Exception e) {
                 return false;
             }
 
-            //config says to retry only on specific exceptions
-            for (Class<? extends Exception> exceptionToRetryOn : this.config.getRetryOnSpecificExceptions()) {
-                if (exceptionToRetryOn.isAssignableFrom(e.getClass())) {
-                    return false;
-                }
+            Set<Class<?>> exceptionsToMatch = new HashSet<>();
+            exceptionsToMatch.add(e.getClass());
+            if (this.config.shouldRetryOnCausedBy()) {
+                exceptionsToMatch.clear();
+                exceptionsToMatch.addAll(getExceptionCauses(e));
             }
 
-            //config says to retry on all except specific exceptions
-            if (!this.config.getRetryOnAnyExceptionExcluding().isEmpty()) {
-                for (Class<? extends Exception> exceptionToNotRetryOn : this.config.getRetryOnAnyExceptionExcluding()) {
-                    if (exceptionToNotRetryOn.isAssignableFrom(e.getClass())) {
-                        return true;
-                    }
-                }
-                return false;
+            return !exceptionsToMatch.stream().anyMatch(ex -> matchesException(ex));
+        }
+    }
+
+    private boolean matchesException(Class<?> thrownExceptionClass) {
+        //config says to retry only on specific exceptions
+        for (Class<? extends Exception> exceptionToRetryOn : this.config.getRetryOnSpecificExceptions()) {
+            if (exceptionToRetryOn.isAssignableFrom(thrownExceptionClass)) {
+                return true;
             }
+        }
 
+        //config says to retry on all except specific exceptions
+        if (!this.config.getRetryOnAnyExceptionExcluding().isEmpty()) {
+            for (Class<? extends Exception> exceptionToNotRetryOn : this.config.getRetryOnAnyExceptionExcluding()) {
+                if (exceptionToNotRetryOn.isAssignableFrom(thrownExceptionClass)) {
+                    return false;
+                }
+            }
             return true;
         }
+        return false;
+    }
+
+    private Set<Class<?>> getExceptionCauses(Exception exception) {
+        Throwable parent = exception;
+        Set<Class<?>> causes = new HashSet<>();
+        while (parent.getCause() != null) {
+            causes.add(parent.getCause().getClass());
+            parent = parent.getCause();
+        }
+        return causes;
     }
 
     @Override

src/main/java/com/evanlennick/retry4j/config/RetryConfig.java

@@ -18,6 +18,7 @@ public class RetryConfig {
     private Object valueToRetryOn;
     private Boolean retryOnValue = false;
     private Function<Exception, Boolean> customRetryOnLogic;
+    private boolean retryOnCausedBy;
 
     public Object getValueToRetryOn() {
         return valueToRetryOn;
@@ -59,6 +60,14 @@ public void setRetryOnAnyExceptionExcluding(Set<Class<? extends Exception>> retr
         this.retryOnAnyExceptionExcluding = retryOnAnyExceptionExcluding;
     }
 
+    public void setRetryOnCausedBy(boolean retryOnCausedBy){
+        this.retryOnCausedBy = retryOnCausedBy;
+    }
+
+    public boolean shouldRetryOnCausedBy() {
+        return retryOnCausedBy;
+    }
+
     public Integer getMaxNumberOfTries() {
         return maxNumberOfTries;
     }

src/main/java/com/evanlennick/retry4j/config/RetryConfigBuilder.java

@@ -23,6 +23,7 @@ public class RetryConfigBuilder {
     private boolean builtInExceptionStrategySpecified;
     private RetryConfig config;
     private boolean validationEnabled;
+    private boolean matchAgainstExceptionCause;
 
     public final static String MUST_SPECIFY_BACKOFF__ERROR_MSG
             = "Retry config must specify a backoff strategy!";
@@ -77,6 +78,11 @@ public RetryConfigBuilder failOnAnyException() {
         return this;
     }
 
+    public RetryConfigBuilder retryOnCausedBy(){
+        config.setRetryOnCausedBy(true);
+        return this;
+    }
+
     @SafeVarargs
     public final RetryConfigBuilder retryOnSpecificExceptions(Class<? extends Exception>... exceptions) {
         validateExceptionStrategyAddition();

src/test/java/com/evanlennick/retry4j/CallExecutorTest.java

@@ -68,6 +68,63 @@ public void verifyExceptionFromCallThrowsCallFailureException() throws Exception
         new CallExecutor(retryConfig).execute(callable);
     }
 
+    @Test(expectedExceptions = {RetriesExhaustedException.class})
+    public void shouldMatchExceptionCauseAndRetry() throws Exception {
+        Callable<Boolean> callable = () -> {
+            throw new Exception(new CustomTestException("message", 3));
+        };
+
+        RetryConfig retryConfig = retryConfigBuilder
+                .retryOnCausedBy()
+                .retryOnSpecificExceptions(CustomTestException.class)
+                .withMaxNumberOfTries(1)
+                .withDelayBetweenTries(0, ChronoUnit.SECONDS)
+                .withFixedBackoff()
+                .build();
+
+        new CallExecutor(retryConfig).execute(callable);
+    }
+
+
+    @Test(expectedExceptions = {RetriesExhaustedException.class})
+    public void shouldMatchExceptionCauseAtGreaterThanALevelDeepAndRetry() throws Exception {
+        class CustomException extends Exception {
+            CustomException(Throwable cause){
+                super(cause);
+            }
+        }
+        Callable<Boolean> callable = () -> {
+            throw new Exception(new CustomException(new RuntimeException(new IOException())));
+        };
+
+        RetryConfig retryConfig = retryConfigBuilder
+                .retryOnCausedBy()
+                .retryOnSpecificExceptions(IOException.class)
+                .withMaxNumberOfTries(1)
+                .withDelayBetweenTries(0, ChronoUnit.SECONDS)
+                .withFixedBackoff()
+                .build();
+
+        new CallExecutor(retryConfig).execute(callable);
+    }
+
+    @Test(expectedExceptions = {UnexpectedException.class})
+    public void shouldThrowUnexpectedIfThrownExceptionCauseDoesNotMatchRetryExceptions() throws Exception {
+        Callable<Boolean> callable = () -> {
+            throw new Exception(new CustomTestException("message", 3));
+        };
+
+        RetryConfig retryConfig = retryConfigBuilder
+                .retryOnCausedBy()
+                .retryOnSpecificExceptions(IOException.class)
+                .withMaxNumberOfTries(1)
+                .withDelayBetweenTries(0, ChronoUnit.SECONDS)
+                .withFixedBackoff()
+                .build();
+
+        new CallExecutor(retryConfig).execute(callable);
+    }
+
     @Test(expectedExceptions = {UnexpectedException.class})
     public void verifySpecificSuperclassExceptionThrowsUnexpectedException() throws Exception {
         Callable<Boolean> callable = () -> {
@@ -153,7 +210,9 @@ public void verifyStatusIsPopulatedOnSuccessfulCall() throws Exception {
 
     @Test
     public void verifyStatusIsPopulatedOnFailedCall() throws Exception {
-        Callable<Boolean> callable = () -> { throw new FileNotFoundException(); };
+        Callable<Boolean> callable = () -> {
+            throw new FileNotFoundException();
+        };
 
         RetryConfig retryConfig = retryConfigBuilder
                 .withMaxNumberOfTries(5)
@@ -252,7 +311,8 @@ public void verifyRetryPolicyTimeoutIsUsed() {
         final long before = System.currentTimeMillis();
         try {
             new CallExecutor<>(retryConfig).execute(callable);
-        } catch (RetriesExhaustedException ignored) {}
+        } catch (RetriesExhaustedException ignored) {
+        }
 
         assertThat(System.currentTimeMillis() - before).isGreaterThan(5000);
         verify(mockBackOffStrategy).getDurationToWait(1, delayBetweenTriesDuration);

src/test/java/com/evanlennick/retry4j/CallExecutorTest_RetryOnCustomLogicTest.java

@@ -83,17 +83,4 @@ public void verifyShouldNotRetryOnCustomException() {
                 });
     }
 
-    private class CustomTestException extends RuntimeException {
-
-        private int someValue;
-
-        public CustomTestException(String message, int someValue) {
-            super(message);
-            this.someValue = someValue;
-        }
-
-        public int getSomeValue() {
-            return someValue;
-        }
-    }
 }

src/test/java/com/evanlennick/retry4j/CustomTestException.java

@@ -0,0 +1,15 @@
+package com.evanlennick.retry4j;
+
+class CustomTestException extends RuntimeException {
+
+    private int someValue;
+
+    public CustomTestException(String message, int someValue) {
+        super(message);
+        this.someValue = someValue;
+    }
+
+    public int getSomeValue() {
+        return someValue;
+    }
+}