#14 - Add RetryHandler with the option to define it on the HttpContext

Author: rbygrave

client/pom.xml

@@ -96,6 +96,7 @@
             --add-modules com.fasterxml.jackson.databind
             --add-opens io.avaje.http.client/io.avaje.http.client=ALL-UNNAMED
             --add-opens io.avaje.http.client/org.example.webserver=ALL-UNNAMED
+            --add-opens io.avaje.http.client/org.example.github=ALL-UNNAMED
             --add-opens io.avaje.http.client/org.example.webserver=com.fasterxml.jackson.databind
             --add-opens io.avaje.http.client/org.example.github=com.fasterxml.jackson.databind
           </argLine>

client/src/main/java/io/avaje/http/client/DHttpClientContext.java

@@ -19,15 +19,17 @@ class DHttpClientContext implements HttpClientContext {
   private final BodyAdapter bodyAdapter;
   private final RequestListener requestListener;
   private final RequestIntercept requestIntercept;
+  private final RetryHandler retryHandler;
   private final boolean withAuthToken;
   private final AuthTokenProvider authTokenProvider;
   private final AtomicReference<AuthToken> tokenRef = new AtomicReference<>();
 
-  DHttpClientContext(HttpClient httpClient, String baseUrl, Duration requestTimeout, BodyAdapter bodyAdapter, RequestListener requestListener, AuthTokenProvider authTokenProvider, RequestIntercept intercept) {
+  DHttpClientContext(HttpClient httpClient, String baseUrl, Duration requestTimeout, BodyAdapter bodyAdapter, RetryHandler retryHandler, RequestListener requestListener, AuthTokenProvider authTokenProvider, RequestIntercept intercept) {
     this.httpClient = httpClient;
     this.baseUrl = baseUrl;
     this.requestTimeout = requestTimeout;
     this.bodyAdapter = bodyAdapter;
+    this.retryHandler = retryHandler;
     this.requestListener = requestListener;
     this.authTokenProvider = authTokenProvider;
     this.withAuthToken = authTokenProvider != null;
@@ -58,12 +60,14 @@ public <T> T create(Class<T> clientInterface) {
   private <T> String clientImplementationClassName(Class<T> clientInterface) {
     String packageName = clientInterface.getPackageName();
     String simpleName = clientInterface.getSimpleName();
-    return packageName + ".httpclient." + simpleName + "$httpclient";
+    return packageName + ".httpclient." + simpleName + "$HttpClient";
   }
 
   @Override
   public HttpClientRequest request() {
-    return new DHttpClientRequest(this, requestTimeout);
+    return retryHandler == null
+      ? new DHttpClientRequest(this, requestTimeout)
+      : new DHttpClientRequestWithRetry(this, requestTimeout, retryHandler);
   }
 
   @Override

client/src/main/java/io/avaje/http/client/DHttpClientContextBuilder.java

@@ -13,22 +13,17 @@
 class DHttpClientContextBuilder implements HttpClientContext.Builder {
 
   private HttpClient client;
-
   private String baseUrl;
-
   private Duration requestTimeout = Duration.ofSeconds(20);
-
   private BodyAdapter bodyAdapter;
+  private RetryHandler retryHandler;
+  private AuthTokenProvider authTokenProvider;
 
   private CookieHandler cookieHandler = new CookieManager();
-
   private HttpClient.Redirect redirect = HttpClient.Redirect.NORMAL;
-
   private HttpClient.Version version;
   private Executor executor;
 
-  private AuthTokenProvider authTokenProvider;
-
   private final List<RequestIntercept> interceptors = new ArrayList<>();
   private final List<RequestListener> listeners = new ArrayList<>();
 
@@ -59,6 +54,12 @@ public HttpClientContext.Builder withBodyAdapter(BodyAdapter adapter) {
     return this;
   }
 
+  @Override
+  public HttpClientContext.Builder withRetryHandler(RetryHandler retryHandler) {
+    this.retryHandler = retryHandler;
+    return this;
+  }
+
   @Override
   public HttpClientContext.Builder withRequestListener(RequestListener requestListener) {
     this.listeners.add(requestListener);
@@ -108,7 +109,7 @@ public HttpClientContext build() {
     if (client == null) {
       client = defaultClient();
     }
-    return new DHttpClientContext(client, baseUrl, requestTimeout, bodyAdapter, buildListener(), authTokenProvider, buildIntercept());
+    return new DHttpClientContext(client, baseUrl, requestTimeout, bodyAdapter, retryHandler, buildListener(), authTokenProvider, buildIntercept());
   }
 
   private RequestListener buildListener() {

client/src/main/java/io/avaje/http/client/DHttpClientRequest.java

@@ -45,7 +45,7 @@ class DHttpClientRequest implements HttpClientRequest, HttpClientResponse {
   private boolean loggableResponseBody;
   private boolean skipAuthToken;
 
-  public DHttpClientRequest(DHttpClientContext context, Duration requestTimeout) {
+  DHttpClientRequest(DHttpClientContext context, Duration requestTimeout) {
     this.context = context;
     this.requestTimeout = requestTimeout;
     this.url = context.url();
@@ -322,14 +322,21 @@ public <T> List<T> list(Class<T> cls) {
   public <T> HttpResponse<T> withResponseHandler(HttpResponse.BodyHandler<T> responseHandler) {
     context.beforeRequest(this);
     addHeaders();
-    final long startNanos = System.nanoTime();
-    final HttpResponse<T> response = context.send(httpRequest, responseHandler);
-    requestTimeNanos = System.nanoTime() - startNanos;
+    HttpResponse<T> response = performSend(responseHandler);
     httpResponse = response;
     context.afterResponse(this);
     return response;
   }
 
+  protected <T> HttpResponse<T> performSend(HttpResponse.BodyHandler<T> responseHandler) {
+    final long startNanos = System.nanoTime();
+    try {
+      return context.send(httpRequest, responseHandler);
+    } finally {
+      requestTimeNanos = System.nanoTime() - startNanos;
+    }
+  }
+
   @Override
   public HttpResponse<byte[]> asByteArray() {
     return withResponseHandler(HttpResponse.BodyHandlers.ofByteArray());

client/src/main/java/io/avaje/http/client/DHttpClientRequestWithRetry.java

@@ -0,0 +1,35 @@
+package io.avaje.http.client;
+
+import java.net.http.HttpResponse;
+import java.time.Duration;
+
+/**
+ * Extends DHttpClientRequest with retry attempts.
+ */
+class DHttpClientRequestWithRetry extends DHttpClientRequest {
+
+  private final RetryHandler retryHandler;
+  private int retryCount;
+
+  DHttpClientRequestWithRetry(DHttpClientContext context, Duration requestTimeout, RetryHandler retryHandler) {
+    super(context, requestTimeout);
+    this.retryHandler = retryHandler;
+  }
+
+  /**
+   * Perform send with retry.
+   */
+  @Override
+  protected <T> HttpResponse<T> performSend(HttpResponse.BodyHandler<T> responseHandler) {
+    HttpResponse<T> res;
+    res = super.performSend(responseHandler);
+    if (res.statusCode() < 300) {
+      return res;
+    }
+    while (retryHandler.isRetry(retryCount++, res)) {
+      res = super.performSend(responseHandler);
+    }
+    return res;
+  }
+
+}

client/src/main/java/io/avaje/http/client/HttpClientContext.java

@@ -159,6 +159,11 @@ interface Builder {
      */
     Builder withBodyAdapter(BodyAdapter adapter);
 
+    /**
+     * Set a RetryHandler to use to retry requests.
+     */
+    Builder withRetryHandler(RetryHandler retryHandler);
+
     /**
      * Add a request listener. Multiple listeners may be added, when
      * do so they will process events in the order they were added.

client/src/main/java/io/avaje/http/client/RetryHandler.java

@@ -0,0 +1,19 @@
+package io.avaje.http.client;
+
+import java.net.http.HttpResponse;
+
+/**
+ * Define how retry should occur on a request.
+ */
+public interface RetryHandler {
+
+  /**
+   * Return true if the request should be retried.
+   *
+   * @param retryCount The number of retry attempts already executed
+   * @param response   The HTTP response
+   * @return True if the request should be retried or false if not
+   */
+  boolean isRetry(int retryCount, HttpResponse<?> response);
+
+}

client/src/main/java/io/avaje/http/client/SimpleRetryHandler.java

@@ -0,0 +1,37 @@
+package io.avaje.http.client;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.http.HttpResponse;
+
+/**
+ * Simple retry with max attempts and linear backoff.
+ */
+public class SimpleRetryHandler implements RetryHandler {
+
+  private static final Logger log = LoggerFactory.getLogger(SimpleRetryHandler.class);
+
+  private final int maxRetries;
+  private final long backoffMillis;
+
+  public SimpleRetryHandler(int maxRetries, long backoffMillis) {
+    this.maxRetries = maxRetries;
+    this.backoffMillis = backoffMillis;
+  }
+
+  @Override
+  public boolean isRetry(int retryCount, HttpResponse<?> response) {
+    if (response.statusCode() < 500 || retryCount >= maxRetries) {
+      return false;
+    }
+    log.debug("retry count:{} status:{} uri:{}", retryCount, response.statusCode(), response.uri());
+    try {
+      Thread.sleep(backoffMillis);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      return false;
+    }
+    return true;
+  }
+}

client/src/test/java/io/avaje/http/client/DHttpClientContextTest.java

@@ -10,7 +10,7 @@
 
 class DHttpClientContextTest {
 
-  private final DHttpClientContext context = new DHttpClientContext(null, null, null, null, null, null, null);
+  private final DHttpClientContext context = new DHttpClientContext(null, null, null, null, null, null, null, null);
 
   @Test
   void create() {

client/src/test/java/io/avaje/http/client/RetryTest.java

@@ -0,0 +1,34 @@
+package io.avaje.http.client;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
+
+import java.net.http.HttpResponse;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RetryTest extends BaseWebTest {
+
+  final HttpClientContext clientContext = initClientWithRetry();
+
+  static HttpClientContext initClientWithRetry() {
+    return HttpClientContext.newBuilder()
+      .withBaseUrl("http://localhost:8887")
+      .withBodyAdapter(new JacksonBodyAdapter(new ObjectMapper()))
+      .withRequestListener(new RequestLogger())
+      .withRetryHandler(new SimpleRetryHandler(4, 1))
+      .build();
+  }
+
+  @Test
+  void retryTest() {
+
+    HttpResponse<String> res = clientContext.request()
+      .path("hello/retry")
+      .get()
+      .asString();
+
+    assertThat(res.body()).isEqualTo("All good at 3rd attempt");
+  }
+
+}