core: retry part 6, client options - maxAttempts

dapengzhang0 · web-flow · commit c735bb338532 · 2018-02-07T18:00:56.000-08:00
diff --git a/core/src/main/java/io/grpc/ForwardingChannelBuilder.java b/core/src/main/java/io/grpc/ForwardingChannelBuilder.java
@@ -163,6 +163,18 @@ public T keepAliveWithoutCalls(boolean enable) {
     return thisT();
   }
 
+  @Override
+  public T maxRetryAttempts(int maxRetryAttempts) {
+    delegate().maxRetryAttempts(maxRetryAttempts);
+    return thisT();
+  }
+
+  @Override
+  public T maxHedgedAttempts(int maxHedgedAttempts) {
+    delegate().maxHedgedAttempts(maxHedgedAttempts);
+    return thisT();
+  }
+
   @Override
   public T retryBufferSize(long bytes) {
     delegate().retryBufferSize(bytes);
diff --git a/core/src/main/java/io/grpc/ManagedChannelBuilder.java b/core/src/main/java/io/grpc/ManagedChannelBuilder.java
@@ -327,6 +327,40 @@ public T keepAliveWithoutCalls(boolean enable) {
     throw new UnsupportedOperationException();
   }
 
+  /**
+   * Sets max number of retry attempts. The total number of retry attempts for each RPC will not
+   * exceed this number even if service config may allow a higher number. Setting this number to
+   * zero is not effectively the same as {@code disableRetry()} because the former does not disable
+   * <a
+   * href="https://github.com/grpc/proposal/blob/master/A6-client-retries.md#transparent-retries">
+   * transparent retry</a>.
+   *
+   * <p>This method may not work as expected for the current release because retry is not fully
+   * implemented yet.
+   *
+   * @return this
+   * @since 1.11.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3982")
+  public T maxRetryAttempts(int maxRetryAttempts) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets max number of hedged attempts. The total number of hedged attempts for each RPC will not
+   * exceed this number even if service config may allow a higher number.
+   *
+   * <p>This method may not work as expected for the current release because retry is not fully
+   * implemented yet.
+   *
+   * @return this
+   * @since 1.11.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3982")
+  public T maxHedgedAttempts(int maxHedgedAttempts) {
+    throw new UnsupportedOperationException();
+  }
+
   /**
    * Sets the retry buffer size in bytes. If the buffer limit is exceeded, no RPC
    * could retry at the moment, and in hedging case all hedges but one of the same RPC will cancel.
diff --git a/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java b/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java
@@ -127,6 +127,8 @@ public static ManagedChannelBuilder<?> forTarget(String target) {
 
   long idleTimeoutMillis = IDLE_MODE_DEFAULT_TIMEOUT_MILLIS;
 
+  int maxRetryAttempts = 5;
+  int maxHedgedAttempts = 5;
   long retryBufferSize = DEFAULT_RETRY_BUFFER_SIZE_IN_BYTES;
   long perRpcBufferLimit = DEFAULT_PER_RPC_BUFFER_LIMIT_IN_BYTES;
   boolean retryDisabled = true; // TODO(zdapeng): default to false
@@ -291,6 +293,18 @@ public final T idleTimeout(long value, TimeUnit unit) {
     return thisT();
   }
 
+  @Override
+  public final T maxRetryAttempts(int maxRetryAttempts) {
+    this.maxRetryAttempts = maxRetryAttempts;
+    return thisT();
+  }
+
+  @Override
+  public final T maxHedgedAttempts(int maxHedgedAttempts) {
+    this.maxHedgedAttempts = maxHedgedAttempts;
+    return thisT();
+  }
+
   @Override
   public final T retryBufferSize(long bytes) {
     checkArgument(bytes > 0L, "retry buffer size must be positive");
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java b/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
@@ -205,6 +205,8 @@ public final class ManagedChannelImpl extends ManagedChannel implements Instrume
   // One instance per channel.
   private final ChannelBufferMeter channelBufferUsed = new ChannelBufferMeter();
 
+  private final int maxRetryAttempts;
+  private final int maxHedgedAttempts;
   private final long perRpcBufferLimit;
   private final long channelBufferLimit;
 
@@ -512,6 +514,8 @@ ClientStream newSubstream(ClientStreamTracer.Factory tracerFactory, Metadata new
     this.userAgent = builder.userAgent;
     this.proxyDetector = proxyDetector;
 
+    this.maxRetryAttempts = builder.maxRetryAttempts;
+    this.maxHedgedAttempts = builder.maxHedgedAttempts;
     this.channelBufferLimit = builder.retryBufferSize;
     this.perRpcBufferLimit = builder.perRpcBufferLimit;
     this.retryEnabled = !builder.retryDisabled;
@@ -1090,6 +1094,7 @@ public void run() {
     }
   }
 
+  // TODO(zdapeng): take client provided maxAttempts into account.
   // TODO(zdapeng): implement it once the Gson dependency issue is resolved.
   // TODO(zdapeng): test retryEnabled = true/flase really works as expected.
   private static RetryPolicies getRetryPolicies(Attributes config) {
diff --git a/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java b/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java
@@ -330,6 +330,24 @@ public void idleTimeout() {
     assertEquals(TimeUnit.SECONDS.toMillis(30), builder.getIdleTimeoutMillis());
   }
 
+  @Test
+  public void maxRetryAttempts() {
+    Builder builder = new Builder("target");
+    assertEquals(5, builder.maxRetryAttempts);
+
+    builder.maxRetryAttempts(3);
+    assertEquals(3, builder.maxRetryAttempts);
+  }
+
+  @Test
+  public void maxHedgedAttempts() {
+    Builder builder = new Builder("target");
+    assertEquals(5, builder.maxHedgedAttempts);
+
+    builder.maxHedgedAttempts(3);
+    assertEquals(3, builder.maxHedgedAttempts);
+  }
+
   @Test
   public void retryBufferSize() {
     Builder builder = new Builder("target");
