RetryHelper can be configured to not retry on socket timeouts.

gcloud-java-core/src/main/java/com/google/gcloud/RetryHelper.java

@@ -29,6 +29,7 @@
 import com.google.common.base.Stopwatch;
 
 import java.io.InterruptedIOException;
+import java.net.SocketTimeoutException;
 import java.nio.channels.ClosedByInterruptException;
 import java.util.concurrent.Callable;
 import java.util.logging.Level;
@@ -44,14 +45,14 @@
 public class RetryHelper<V> {
 
  private static final Logger log = Logger.getLogger(RetryHelper.class.getName());
+ private final static boolean DEFAULT_RETRY_ON_TIMEOUTS = true;
 
  private final Stopwatch stopwatch;
  private final Callable<V> callable;
  private final RetryParams params;
  private final ExceptionHandler exceptionHandler;
  private int attemptNumber;
 
-
  private static final ThreadLocal<Context> context = new ThreadLocal<>();
 
  public static class RetryHelperException extends RuntimeException {
@@ -172,7 +173,7 @@ public String toString() {
  return toStringHelper.toString();
  }
 
- private V doRetry() throws RetryHelperException {
+ private V doRetry(boolean retryOnTimeout) throws RetryHelperException {
  stopwatch.start();
  while (true) {
  attemptNumber++;
@@ -189,7 +190,8 @@ private V doRetry() throws RetryHelperException {
  }
  exception = e;
  } catch (Exception e) {
- if (!exceptionHandler.shouldRetry(e)) {
+ if (!exceptionHandler.shouldRetry(e)
+ || !retryOnTimeout && e.getCause() instanceof SocketTimeoutException) {
  throw new NonRetriableException(e);
  }
  exception = e;
@@ -229,22 +231,30 @@ private static long getExponentialValue(long initialDelay, double backoffFactor,
 
  public static <V> V runWithRetries(Callable<V> callable) throws RetryHelperException {
  return runWithRetries(callable, RetryParams.defaultInstance(),
- ExceptionHandler.defaultInstance());
+ ExceptionHandler.defaultInstance(), DEFAULT_RETRY_ON_TIMEOUTS);
  }
 
  public static <V> V runWithRetries(Callable<V> callable, RetryParams params,
  ExceptionHandler exceptionHandler) throws RetryHelperException {
- return runWithRetries(callable, params, exceptionHandler, Stopwatch.createUnstarted());
+ return runWithRetries(callable, params, exceptionHandler, Stopwatch.createUnstarted(),
+ DEFAULT_RETRY_ON_TIMEOUTS);
+ }
+
+ public static <V> V runWithRetries(Callable<V> callable, RetryParams params,
+ ExceptionHandler exceptionHandler, boolean retryOnTimeout) throws RetryHelperException {
+ return runWithRetries(callable, params, exceptionHandler, Stopwatch.createUnstarted(),
+ retryOnTimeout);
  }
 
  @VisibleForTesting
  static <V> V runWithRetries(Callable<V> callable, RetryParams params,
- ExceptionHandler exceptionHandler, Stopwatch stopwatch) throws RetryHelperException {
+ ExceptionHandler exceptionHandler, Stopwatch stopwatch, boolean retryOnTimeout)
+ throws RetryHelperException {
  RetryHelper<V> retryHelper = new RetryHelper<>(callable, params, exceptionHandler, stopwatch);
  Context previousContext = getContext();
  setContext(new Context(retryHelper));
  try {
- return retryHelper.doRetry();
+ return retryHelper.doRetry(retryOnTimeout);
  } finally {
  setContext(previousContext);
  }

gcloud-java-core/src/test/java/com/google/gcloud/RetryHelperTest.java

@@ -30,6 +30,7 @@
 import org.junit.Test;
 
 import java.io.IOException;
+import java.net.SocketTimeoutException;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.concurrent.Callable;
@@ -194,14 +195,40 @@ public void testTriesNoMoreLongerThanTotalRetryPeriod() {
  }
  throw new RuntimeException();
  }
- }), params, handler, stopwatch);
+ }), params, handler, stopwatch, true);
  fail();
  } catch (RetriesExhaustedException expected) {
  // verify timesCalled
  assertEquals(sleepOnAttempt, timesCalled.get());
  }
  }
 
+ @Test
+ public void testNoRetriesOnSocketTimeout() {
+ final FakeTicker ticker = new FakeTicker();
+ Stopwatch stopwatch = Stopwatch.createUnstarted(ticker);
+ RetryParams params = RetryParams.builder().initialRetryDelayMillis(0)
+ .totalRetryPeriodMillis(999)
+ .retryMinAttempts(5)
+ .retryMaxAttempts(10)
+ .build();
+ ExceptionHandler handler = ExceptionHandler.builder().retryOn(RuntimeException.class).build();
+ final AtomicInteger timesCalled = new AtomicInteger(0);
+ try {
+ RetryHelper.runWithRetries(callable(new Runnable() {
+ @Override public void run() {
+ timesCalled.incrementAndGet();
+ throw new RetryHelper.RetryHelperException(
+ new SocketTimeoutException("Simulated socket timeout"));
+ }
+ }), params, handler, stopwatch, false);
+ fail();
+ } catch (RetryHelper.RetryHelperException expected) {
+ // verify timesCalled
+ assertEquals(1, timesCalled.get());
+ }
+ }
+
  @Test
  public void testBackoffIsExponential() {
  // Total retry period set to 60 seconds so as to not factor into test

gcloud-java-dns/src/main/java/com/google/gcloud/dns/DnsImpl.java

@@ -215,7 +215,7 @@ public Zone create(final ZoneInfo zoneInfo, Dns.ZoneOption... options) {
  public ManagedZone call() {
  return dnsRpc.create(zoneInfo.toPb(), optionsMap);
  }
- }, options().retryParams(), EXCEPTION_HANDLER);
+ }, options().retryParams(), EXCEPTION_HANDLER, false);
  return answer == null ? null : Zone.fromPb(this, answer);
  } catch (RetryHelper.RetryHelperException ex) {
  throw DnsException.translateAndThrow(ex);
@@ -247,7 +247,7 @@ public boolean delete(final String zoneName) {
  public Boolean call() {
  return dnsRpc.deleteZone(zoneName);
  }
- }, options().retryParams(), EXCEPTION_HANDLER);
+ }, options().retryParams(), EXCEPTION_HANDLER, false);
  } catch (RetryHelper.RetryHelperException ex) {
  throw DnsException.translateAndThrow(ex);
  }
@@ -281,7 +281,7 @@ public ChangeRequest applyChangeRequest(final String zoneName,
  public Change call() {
  return dnsRpc.applyChangeRequest(zoneName, changeRequest.toPb(), optionsMap);
  }
- }, options().retryParams(), EXCEPTION_HANDLER);
+ }, options().retryParams(), EXCEPTION_HANDLER, false);
  return answer == null ? null : ChangeRequest.fromPb(this, zoneName, answer); // not null
  } catch (RetryHelper.RetryHelperException ex) {
  throw DnsException.translateAndThrow(ex);