Functional methods for exception handling

Author: ekoutanov

src/main/java/au/com/williamhill/flywheel/util/Exceptions.java

@@ -0,0 +1,79 @@
+package au.com.williamhill.flywheel.util;
+
+import java.util.function.*;
+
+/**
+ *  Functional equivalent of a try-catch block, as well as complimentary utilities.
+ */
+public final class Exceptions {
+  private Exceptions() {}
+  
+  /**
+   *  A {@link Runnable} that may throw an exception.
+   */
+  @FunctionalInterface
+  public interface ThrowingRunnable extends ThrowingSupplier<Void> {
+    void run() throws Exception;
+    
+    @Override default Void create() throws Exception {
+      run();
+      return null;
+    }
+  }
+  
+  /**
+   *  A {@link Supplier} that may throw an exception.
+   *  
+   *  @param <T> The return type.
+   */
+  @FunctionalInterface
+  public interface ThrowingSupplier<T> {
+    T create() throws Exception;
+  }
+  
+  /**
+   *  Invokes a given block. If an exception is thrown, it is
+   *  first passed through the given {@code exceptionManager} mapping {@link Function} before being rethrown.
+   *  
+   *  @param <X> The exterior exception type.
+   *  @param runnable The runnable block.
+   *  @param exceptionMapper The exception mapper (from the interior exception to the exterior exception type).
+   *  @throws X The exterior exception if the {@code runnable} block faulted.
+   */  
+  public static <X extends Exception> void rethrow(ThrowingRunnable runnable, Function<Exception, X> exceptionMapper) throws X {
+    rethrow((ThrowingSupplier<Void>) runnable, exceptionMapper);
+  }
+  
+  /**
+   *  Invokes a given supplier block returning the outcome if successful. Otherwise, if an exception is thrown, it is
+   *  first passed through the given {@code exceptionManager} mapping {@link Function} before being rethrown.
+   *  
+   *  @param <T> The return type.
+   *  @param <X> The exterior exception type.
+   *  @param supplier The supplier block.
+   *  @param exceptionMapper The exception mapper (from the interior exception to the exterior exception type).
+   *  @return The value returned by the {@code supplier} block.
+   *  @throws X The exterior exception if the {@code supplier} block faulted.
+   */
+  public static <T, X extends Exception> T rethrow(ThrowingSupplier<T> supplier, Function<Exception, X> exceptionMapper) throws X {
+    try {
+      return supplier.create();
+    } catch (Exception e) {
+      throw exceptionMapper.apply(e);
+    }
+  }
+  
+  /**
+   *  Obtains the root cause of a given exception.
+   *  
+   *  @param throwable The exception.
+   *  @return The root cause.
+   */
+  public static Throwable getRootCause(Throwable throwable) {
+    Throwable cause = throwable;
+    while (cause.getCause() != null) {
+      cause = cause.getCause();
+    }
+    return cause;
+  }
+}

src/test/java/au/com/williamhill/flywheel/util/ExceptionsTest.java

@@ -0,0 +1,52 @@
+package au.com.williamhill.flywheel.util;
+
+import static org.junit.Assert.*;
+
+import org.junit.*;
+
+import com.obsidiandynamics.assertion.*;
+
+public final class ExceptionsTest {
+  @Test
+  public void testConformance() throws Exception {
+    Assertions.assertUtilityClassWellDefined(Exceptions.class);
+  }
+  
+  private class TestException extends Exception {
+    private static final long serialVersionUID = 1L;
+    TestException(Throwable cause) { super(cause); }
+    TestException(String m, Throwable cause) { super(m, cause); }
+  }
+
+  @Test
+  public void testReturnNoThrow() throws TestException {
+    final String value = Exceptions.rethrow(() -> "ok", e -> new TestException(e));
+    assertEquals("ok", value);
+  }
+
+  @Test
+  public void testReturnThrow() {
+    final Exception cause = new Exception("boom");
+    try {
+      Exceptions.rethrow(() -> {
+        throw cause;
+      }, e -> new TestException("thrown", e));
+      fail("Expected exception not thrown");
+    } catch (TestException e) {
+      assertEquals(cause, e.getCause());
+      assertEquals("thrown", e.getMessage());
+    }
+  }
+  
+  @Test
+  public void testVoidNoThrow() throws TestException {
+    Exceptions.rethrow(() -> {}, e -> new TestException(e));
+  }
+  
+  @Test
+  public void testRootCause() {
+    final Exception root = new Exception("root");
+    final Exception intermediate = new Exception("intermediate", root);
+    assertEquals(root, Exceptions.getRootCause(intermediate));
+  }
+}

standalone/src/main/java/au/com/williamhill/flywheel/Launchpad.java

@@ -10,6 +10,10 @@
 
 import com.obsidiandynamics.indigo.util.*;
 
+import au.com.williamhill.flywheel.util.*;
+import au.com.williamhill.flywheel.util.Exceptions.ThrowingRunnable;
+import au.com.williamhill.flywheel.util.Exceptions.ThrowingSupplier;
+
 public final class Launchpad {
   private static final String DEF_PROFILE = "conf/default";
 
@@ -33,21 +37,17 @@ static final class LaunchpadException extends Exception {
     if (! profileYaml.exists()) {
       throw new LaunchpadException("Profile configuration " + profileYaml + " is missing", null);
     }
-    
-    try {
-      profile = Profile.fromFile(profileYaml);
-    } catch (Exception e) {
-      throw new LaunchpadException("Error reading profile", getRootCause(e));
-    }
+
+    profile = rethrowLaunchpadException(() -> {
+      return Profile.fromFile(profileYaml);
+    }, "Error reading profile");
 
     final StringBuilder sb = new StringBuilder();
 
-    try {
+    rethrowLaunchpadException(() -> {
       sb.append("\n  Flywheel version: ").append(FlywheelVersion.get());
       sb.append("\n  Indigo version: ").append(IndigoVersion.get());
-    } catch (IOException e) {
-      throw new LaunchpadException("Error retrieving version", e);
-    }
+    }, "Error retrieving version"); 
 
     sb.append("\n  Properties:");
     for (Map.Entry<String, ?> entry : profile.properties.entrySet()) {
@@ -63,21 +63,17 @@ static final class LaunchpadException extends Exception {
     log.info(sb.toString());
   }
 
-  private static Throwable getRootCause(Throwable throwable) {
-    Throwable cause = throwable;
-    while (cause.getCause() != null) {
-      cause = cause.getCause();
-    }
-    return cause;
+  private static void rethrowLaunchpadException(ThrowingRunnable lambda, String message) throws LaunchpadException {
+    rethrowLaunchpadException((ThrowingSupplier<Void>) lambda, message);
+  }
+  
+  private static <T> T rethrowLaunchpadException(ThrowingSupplier<T> lambda, String message) throws LaunchpadException {
+    return Exceptions.rethrow(lambda, e -> new LaunchpadException(message, Exceptions.getRootCause(e)));
   }
 
   public void launch(String[] args) throws LaunchpadException {
     for (Launcher launcher : profile.launchers) {
-      try {
-        launcher.launch(args);
-      } catch (Exception e) {
-        throw new LaunchpadException("Failed to launch " + launcher, getRootCause(e));
-      }
+      rethrowLaunchpadException(() -> launcher.launch(args), "Failed to launch " + launcher);
     }
   }