Add async() execution for Void and String

Author: rbygrave

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

@@ -0,0 +1,28 @@
+package io.avaje.http.client;
+
+import java.net.http.HttpResponse;
+import java.util.concurrent.CompletableFuture;
+
+class DHttpAsync implements HttpAsyncResponse {
+
+  private final DHttpClientRequest request;
+
+  DHttpAsync(DHttpClientRequest request) {
+    this.request = request;
+  }
+
+  @Override
+  public CompletableFuture<HttpResponse<Void>> asDiscarding() {
+    return request
+      .performSendAsync(false, HttpResponse.BodyHandlers.discarding())
+      .thenApply(request::afterAsync);
+  }
+
+  @Override
+  public CompletableFuture<HttpResponse<String>> asString() {
+    return request
+      .performSendAsync(true, HttpResponse.BodyHandlers.ofString())
+      .thenApply(request::afterAsync);
+  }
+
+}

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

@@ -9,6 +9,7 @@
 import java.time.Duration;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicReference;
 
 class DHttpClientContext implements HttpClientContext {
@@ -29,6 +30,7 @@ class DHttpClientContext implements HttpClientContext {
   private final boolean withAuthToken;
   private final AuthTokenProvider authTokenProvider;
   private final AtomicReference<AuthToken> tokenRef = new AtomicReference<>();
+  private int loggingMaxBody = 1_000;
 
   DHttpClientContext(HttpClient httpClient, String baseUrl, Duration requestTimeout, BodyAdapter bodyAdapter, RetryHandler retryHandler, RequestListener requestListener, AuthTokenProvider authTokenProvider, RequestIntercept intercept) {
     this.httpClient = httpClient;
@@ -155,6 +157,10 @@ <T> HttpResponse<T> send(HttpRequest.Builder requestBuilder, HttpResponse.BodyHa
     }
   }
 
+  <T> CompletableFuture<HttpResponse<T>> sendAsync(HttpRequest.Builder requestBuilder, HttpResponse.BodyHandler<T> bodyHandler) {
+    return httpClient.sendAsync(requestBuilder.build(), bodyHandler);
+  }
+
   BodyContent write(Object bean, String contentType) {
     return bodyAdapter.beanWriter(bean.getClass()).write(bean, contentType);
   }
@@ -198,4 +204,7 @@ private String authToken() {
     return authToken.token();
   }
 
+  String maxResponseBody(String body) {
+    return body.length() > loggingMaxBody ? body.substring(0, loggingMaxBody) + " <truncated> ..." : body;
+  }
 }

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

@@ -13,6 +13,7 @@
 import java.nio.file.Path;
 import java.time.*;
 import java.util.*;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
@@ -49,6 +50,7 @@ class DHttpClientRequest implements HttpClientRequest, HttpClientResponse {
   private boolean loggableResponseBody;
   private boolean skipAuthToken;
   private boolean suppressLogging;
+  private long startAsyncNanos;
 
   DHttpClientRequest(DHttpClientContext context, Duration requestTimeout) {
     this.context = context;
@@ -276,6 +278,11 @@ private void addHeaders() {
     }
   }
 
+  @Override
+  public HttpAsyncResponse async() {
+    return new DHttpAsync(this);
+  }
+
   @Override
   public HttpClientResponse HEAD() {
     httpRequest = newHead(url.build());
@@ -378,6 +385,21 @@ protected <T> HttpResponse<T> performSend(HttpResponse.BodyHandler<T> responseHa
     }
   }
 
+  protected <T> CompletableFuture<HttpResponse<T>> performSendAsync(boolean loggable, HttpResponse.BodyHandler<T> responseHandler) {
+    loggableResponseBody = loggable;
+    context.beforeRequest(this);
+    addHeaders();
+    startAsyncNanos = System.nanoTime();
+    return context.sendAsync(httpRequest, responseHandler);
+  }
+
+  public <E> HttpResponse<E> afterAsync(HttpResponse<E> response) {
+    requestTimeNanos = System.nanoTime() - startAsyncNanos;
+    httpResponse = response;
+    context.afterResponse(this);
+    return response;
+  }
+
   @Override
   public HttpResponse<byte[]> asByteArray() {
     return withResponseHandler(HttpResponse.BodyHandlers.ofByteArray());
@@ -511,13 +533,9 @@ public String responseBody() {
         return "<suppressed response body>";
       }
       if (encodedResponseBody != null) {
-        return new String(encodedResponseBody.content(), StandardCharsets.UTF_8);
+        return context.maxResponseBody(new String(encodedResponseBody.content(), StandardCharsets.UTF_8));
       } else if (httpResponse != null && loggableResponseBody) {
-        String strBody = httpResponse.body().toString();
-        if (strBody.length() > 1_000) {
-          return strBody.substring(0, 1_000) + "...";
-        }
-        return strBody;
+        return context.maxResponseBody(httpResponse.body().toString());
       }
       return null;
     }

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

@@ -0,0 +1,21 @@
+package io.avaje.http.client;
+
+import java.net.http.HttpResponse;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Async responses as CompletableFuture.
+ */
+public interface HttpAsyncResponse {
+
+  /**
+   * Process discarding response body as {@literal HttpResponse<Void>}.
+   */
+  CompletableFuture<HttpResponse<Void>> asDiscarding();
+
+  /**
+   * Process as String response body {@literal HttpResponse<String>}.
+   */
+  CompletableFuture<HttpResponse<String>> asString();
+
+}

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

@@ -12,6 +12,11 @@
  */
 public interface HttpClientResponse {
 
+  /**
+   * Send the request async using CompletableFuture.
+   */
+  HttpAsyncResponse async();
+
   /**
    * Returning the response using the given response reader.
    *

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

@@ -7,6 +7,8 @@
 import java.net.http.HttpResponse;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -44,6 +46,31 @@ void get_helloMessage() {
     assertThat(hres.statusCode()).isEqualTo(200);
   }
 
+  @Test
+  void async_get_asString() throws ExecutionException, InterruptedException {
+
+    final CompletableFuture<HttpResponse<String>> future = clientContext.request()
+      .path("hello").path("message")
+      .GET()
+      .async().asString();
+
+    final HttpResponse<String> hres = future.get();
+    assertThat(hres.body()).contains("hello world");
+    assertThat(hres.statusCode()).isEqualTo(200);
+  }
+
+  @Test
+  void async_get_asDiscarding() throws ExecutionException, InterruptedException {
+
+    final CompletableFuture<HttpResponse<Void>> future = clientContext.request()
+      .path("hello").path("message")
+      .GET()
+      .async().asDiscarding();
+
+    final HttpResponse<Void> hres = future.get();
+    assertThat(hres.statusCode()).isEqualTo(200);
+  }
+
   @Test
   void get_helloMessage_via_url() {
 

client/src/test/java/org/example/github/GithubTest.java

@@ -4,6 +4,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.avaje.http.client.HttpClientContext;
 import io.avaje.http.client.JacksonBodyAdapter;
+import io.avaje.http.client.RequestLogger;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
@@ -18,12 +19,27 @@ public class GithubTest {
 
   @Test
   @Disabled
-  void test() {
+  void test() throws InterruptedException {
+
     final HttpClientContext clientContext = HttpClientContext.newBuilder()
       .withBaseUrl("https://api.github.com")
       .withBodyAdapter(bodyAdapter)
+      .withRequestListener(new RequestLogger())
       .build();
 
+    clientContext.request()
+      .path("users").path("rbygrave").path("repos")
+      .GET()
+      .async()
+      .asString()
+      .thenAccept(res -> {
+
+        System.out.println("RES: "+res.statusCode());
+        System.out.println("BODY: "+res.body());
+      });
+
+    Thread.sleep(1_000);
+
     // will not work under module classpath without registering the HttpApiProvider
     final Simple simple = clientContext.create(Simple.class);