Inline LettuceFutures.translateException(…) to prevent capturing lamb…

…da instance creation

src/main/java/com/lambdaworks/redis/AbstractRedisClient.java

@@ -357,7 +357,25 @@ public void shutdown() {
      * @param timeUnit the unit of {@code quietPeriod} and {@code timeout}
      */
     public void shutdown(long quietPeriod, long timeout, TimeUnit timeUnit) {
-        LettuceFutures.translateException(() -> shutdownAsync(quietPeriod, timeout, timeUnit).get(), () -> null);
+
+        try {
+            shutdownAsync(quietPeriod, timeout, timeUnit).get();
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (ExecutionException e) {
+
+            if (e.getCause() instanceof RedisCommandExecutionException) {
+                throw new RedisCommandExecutionException(e.getCause().getMessage(), e.getCause());
+            }
+
+            throw new RedisException(e.getCause());
+        } catch (InterruptedException e) {
+
+            Thread.currentThread().interrupt();
+            throw new RedisCommandInterruptedException(e);
+        } catch (Exception e) {
+            throw new RedisCommandExecutionException(e);
+        }
     }
 
     /**

src/main/java/com/lambdaworks/redis/LettuceFutures.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2016 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,8 +15,10 @@
  */
 package com.lambdaworks.redis;
 
-import java.util.concurrent.*;
-import java.util.function.Supplier;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 /**
  * Utility to {@link #awaitAll(long, TimeUnit, Future[])} futures until they are done and to synchronize future execution using
@@ -28,7 +30,6 @@
 public class LettuceFutures {
 
     private LettuceFutures() {
-
     }
 
     /**
@@ -42,8 +43,7 @@ private LettuceFutures() {
      */
     public static boolean awaitAll(long timeout, TimeUnit unit, Future<?>... futures) {
 
-        return translateException(() -> {
-
+        try {
             long nanos = unit.toNanos(timeout);
             long time = System.nanoTime();
 
@@ -61,7 +61,24 @@ public static boolean awaitAll(long timeout, TimeUnit unit, Future<?>... futures
             }
 
             return true;
-        }, () -> false);
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (TimeoutException e) {
+            return false;
+        } catch (ExecutionException e) {
+
+            if (e.getCause() instanceof RedisCommandExecutionException) {
+                throw new RedisCommandExecutionException(e.getCause().getMessage(), e.getCause());
+            }
+
+            throw new RedisException(e.getCause());
+        } catch (InterruptedException e) {
+
+            Thread.currentThread().interrupt();
+            throw new RedisCommandInterruptedException(e);
+        } catch (Exception e) {
+            throw new RedisCommandExecutionException(e);
+        }
     }
 
     /**
@@ -95,33 +112,15 @@ public static <T> T awaitOrCancel(RedisFuture<T> cmd, long timeout, TimeUnit uni
     @Deprecated
     public static <T> T await(long timeout, TimeUnit unit, RedisFuture<T> cmd) {
 
-        return translateException(() -> {
-
+        try {
             if (!cmd.await(timeout, unit)) {
                 cmd.cancel(true);
                 throw new RedisCommandTimeoutException();
             }
 
             return cmd.get();
-        }, () -> null);
-    }
-
-    /**
-     * Execute a {@link Callable} applying exception translation.
-     *
-     * @param callable the {@link Callable} to call.
-     * @param otherwiseTimeout {@link Supplier} for a fallback value when a {@link TimeoutException} is caught.
-     * @return result value of the {@link Callable} or {@link Supplier#get()} if a {@link TimeoutException} occurs.
-     * @since 4.4
-     */
-    protected static <T> T translateException(Callable<T> callable, Supplier<T> otherwiseTimeout) {
-
-        try {
-            return callable.call();
         } catch (RuntimeException e) {
             throw e;
-        } catch (TimeoutException e) {
-            return otherwiseTimeout.get();
         } catch (ExecutionException e) {
 
             if (e.getCause() instanceof RedisCommandExecutionException) {