Initial client add

Author: rbygrave

client/pom.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <parent>
+    <artifactId>java11-oss</artifactId>
+    <groupId>org.avaje</groupId>
+    <version>2.1.2</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <artifactId>http-client</artifactId>
+  <groupId>org.avaje.beta.http</groupId>
+  <version>0.1-SNAPSHOT</version>
+
+  <dependencies>
+
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.25</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.dinject</groupId>
+      <artifactId>dinject-controller</artifactId>
+      <version>1.21</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.11.1</version>
+    </dependency>
+
+    <!-- test dependencies  -->
+
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-api</artifactId>
+      <version>5.5.2</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <version>3.16.1</version>
+      <scope>test</scope>
+    </dependency>
+
+  </dependencies>
+
+</project>

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

@@ -0,0 +1,13 @@
+package io.avaje.http.client;
+
+import java.util.List;
+
+public interface BodyAdapter {
+
+  BodyWriter beanWriter(Class<?> cls);
+
+  <T> BodyReader<T> beanReader(Class<T> cls);
+
+  <T> BodyReader<List<T>> listReader(Class<T> cls);
+
+}

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

@@ -0,0 +1,27 @@
+package io.avaje.http.client;
+
+public class BodyContent {
+
+  public static final String JSON_UTF8 = "application/json; charset=UTF-8";
+
+  private final String contentType;
+
+  private final byte[] content;
+
+  public static BodyContent asJson(byte[] content) {
+    return new BodyContent(JSON_UTF8, content);
+  }
+
+  public BodyContent(String contentType, byte[] content) {
+    this.contentType = contentType;
+    this.content = content;
+  }
+
+  public String contentType() {
+    return contentType;
+  }
+
+  public byte[] content() {
+    return content;
+  }
+}

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

@@ -0,0 +1,7 @@
+package io.avaje.http.client;
+
+public interface BodyReader<T> {
+
+  T read(BodyContent content);
+
+}

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

@@ -0,0 +1,24 @@
+package io.avaje.http.client;
+
+/**
+ * Writes beans as content for a specific content type.
+ */
+public interface BodyWriter {
+
+  /**
+   * Write the bean as content using the default content type.
+   * <p>
+   * Used when all beans sent via POST, PUT, PATCH will be sent as
+   * a single content type like <code>application/json; charset=utf8</code>.
+   */
+  BodyContent write(Object bean);
+
+  /**
+   * Write the bean as content with the requested content type.
+   * <p>
+   * The writer is expected to use the given contentType to determine
+   * how to write the bean as content.
+   */
+  BodyContent write(Object bean, String contentType);
+
+}

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

@@ -0,0 +1,140 @@
+package io.avaje.http.client;
+
+import java.io.IOException;
+import java.net.http.HttpClient;
+import java.net.http.HttpHeaders;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+
+class DHttpClientContext implements HttpClientContext {
+
+  private final HttpClient httpClient;
+  private final String baseUrl;
+  private final Duration requestTimeout;
+  private final BodyAdapter bodyAdapter;
+  private final RequestListener requestListener;
+
+  DHttpClientContext(HttpClient httpClient, String baseUrl, Duration requestTimeout, BodyAdapter bodyAdapter, RequestListener requestListener) {
+    this.httpClient = httpClient;
+    this.baseUrl = baseUrl;
+    this.requestTimeout = requestTimeout;
+    this.bodyAdapter = bodyAdapter;
+    this.requestListener = requestListener;
+  }
+
+  @Override
+  public HttpClientRequest request() {
+    return new DHttpClientRequest(this, requestTimeout);
+  }
+
+  @Override
+  public BodyAdapter converters() {
+    return bodyAdapter;
+  }
+
+  @Override
+  public UrlBuilder url() {
+    return new UrlBuilder(baseUrl);
+  }
+
+  @Override
+  public HttpClient httpClient() {
+    return httpClient;
+  }
+
+  @Override
+  public void checkResponse(HttpResponse<?> response) {
+    if (response.statusCode() >= 300) {
+      throw new HttpException(response, this);
+    }
+  }
+
+  void check(HttpResponse<byte[]> response) {
+    if (response.statusCode() >= 300) {
+      throw new HttpException(this, response);
+    }
+  }
+  @Override
+  public BodyContent readContent(HttpResponse<byte[]> httpResponse) {
+    byte[] bodyBytes = decodeContent(httpResponse);
+    final String contentType = getContentType(httpResponse);
+    return new BodyContent(contentType, bodyBytes);
+  }
+
+  String getContentType(HttpResponse<byte[]> httpResponse) {
+    return firstHeader(httpResponse.headers(), "Content-Type", "content-type");
+  }
+
+  String getContentEncoding(HttpResponse<byte[]> httpResponse) {
+    return firstHeader(httpResponse.headers(), "Content-Encoding", "content-encoding");
+  }
+
+  @Override
+  public byte[] decodeContent(String encoding, byte[] body) {
+    if (encoding.equals("gzip")) {
+      return GzipUtil.gzipDecode(body);
+    }
+    // todo: register decoders with context and use them
+    return body;
+  }
+
+  public byte[] decodeContent(HttpResponse<byte[]> httpResponse) {
+    String encoding = getContentEncoding(httpResponse);
+    return encoding == null ? httpResponse.body() : decodeContent(encoding, httpResponse.body());
+  }
+
+  String firstHeader(HttpHeaders headers, String... names) {
+    final Map<String, List<String>> map = headers.map();
+    for (String key : names) {
+      final List<String> values = map.get(key);
+      if (values != null && !values.isEmpty()) {
+        return values.get(0);
+      }
+    }
+    return null;
+  }
+
+  <T> HttpResponse<T> send(HttpRequest.Builder requestBuilder, HttpResponse.BodyHandler<T> bodyHandler) {
+    final HttpRequest request = applyFilters(requestBuilder).build();
+    try {
+      return httpClient.send(request, bodyHandler);
+    } catch (IOException e) {
+      throw new HttpException(499, e);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new HttpException(499, e);
+    }
+  }
+
+  private HttpRequest.Builder applyFilters(HttpRequest.Builder hreq) {
+    return hreq;
+  }
+
+  BodyContent write(Object bean, String contentType) {
+    return bodyAdapter.beanWriter(bean.getClass()).write(bean, contentType);
+  }
+
+  <T> T readBean(Class<T> cls, BodyContent content) {
+    return bodyAdapter.beanReader(cls).read(content);
+  }
+
+  <T> List<T> readList(Class<T> cls, BodyContent content) {
+    return bodyAdapter.listReader(cls).read(content);
+  }
+
+
+  void afterResponse(DHttpClientRequest request) {
+    if (requestListener != null) {
+      requestListener.response(request.listenerEvent());
+    }
+  }
+
+  void afterResponseHandler(DHttpClientRequest request) {
+    if (requestListener != null) {
+      requestListener.response(request.listenerEvent());
+    }
+  }
+}

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

@@ -0,0 +1,69 @@
+package io.avaje.http.client;
+
+import java.net.http.HttpClient;
+import java.time.Duration;
+
+import static java.util.Objects.requireNonNull;
+
+class DHttpClientContextBuilder implements HttpClientContext.Builder {
+
+  private HttpClient client;
+
+  private String baseUrl;
+
+  private Duration requestTimeout = Duration.ofSeconds(20);
+
+  private BodyAdapter bodyAdapter;
+
+  private RequestListener requestListener;
+
+  DHttpClientContextBuilder() {
+  }
+
+  @Override
+  public HttpClientContext.Builder with(HttpClient client) {
+    this.client = client;
+    return this;
+  }
+
+  @Override
+  public HttpClientContext.Builder withBaseUrl(String baseUrl) {
+    this.baseUrl = baseUrl;
+    return this;
+  }
+
+  @Override
+  public HttpClientContext.Builder withRequestTimeout(Duration requestTimeout) {
+    this.requestTimeout = requestTimeout;
+    return this;
+  }
+
+  @Override
+  public HttpClientContext.Builder withBodyAdapter(BodyAdapter adapter) {
+    this.bodyAdapter = adapter;
+    return this;
+  }
+
+  @Override
+  public HttpClientContext.Builder withRequestListener(RequestListener requestListener) {
+    this.requestListener = requestListener;
+    return this;
+  }
+
+  @Override
+  public HttpClientContext build() {
+    requireNonNull(baseUrl, "baseUrl is not specified");
+    requireNonNull(requestTimeout, "requestTimeout is not specified");
+    if (client == null) {
+      client = defaultClient();
+    }
+    return new DHttpClientContext(client, baseUrl, requestTimeout, bodyAdapter, requestListener);
+  }
+
+  private HttpClient defaultClient() {
+    return HttpClient.newBuilder()
+      .connectTimeout(Duration.ofSeconds(20))
+      .build();
+  }
+
+}