Async HTTP with Java 11

Author: JulianVennen

CHANGELOG.md

@@ -2,6 +2,17 @@
 ## Java 11
 This library now requires Java 11 or higher.
 
+## Async API
+All methods that make requests to the Exaroton API are now asynchronous. This means that all methods that return a value
+now return a `CompletableFuture` instead. To get the result of the request you can use `CompletableFuture#get()` or
+`CompletableFuture#join()`.
+
+This also changes where exceptions are thrown. Now the following rules apply:
+- IOExceptions are thrown directly by the API methods
+- APIExceptions cause the CompletableFuture to complete exceptionally
+
+If you use `join()` or `get()` a `CompletionException` containing the `APIException` will be thrown.
+
 ## ServerStatus
 The `ServerStatus` class is now an enum instead of a class with static `int` fields. Each status has a numeric
 value (`getValue`), a display name (`getName`) and a brand color (`getColor`).
@@ -12,12 +23,30 @@ If a status code is unknown because the API client has not been updated `OFFLINE
 This library no longer depends directly on any SLF4J implementation. If you want to see log messages
 from this library, you must include an SLF4J implementation in your project.
 
+### API Requests
+
+#### Request Bodies
+`ApiRequest#getBody()` and `ApiRequest#getInputStream()` have been replaced by `ApiRequest#getBodyPublisher()`. For a 
+JSON body you can use `ApiRequest#jsonBodyPublisher(Object)`. This only affects users who extended the request classes.
+
+`PutFileDataRequest`'s constructor has been changed to accept a `Supplier<InputStream>` instead of an `InputStream`.
+
+#### Request Methods
+`ApiRequest#requestRaw()`, `ApiRequest#requestString()` and `ApiRequest#request()` have been replaced by 
+`ExarotonClient#request(ApiRequest, HttpResponse.BodyHandler)` use the respective body handlers to get an input stream,
+string or object.
+
+
 ### Other
 - `Server#subscribe` and `Server#unsubscribe` now accept the `StreamName` enum instead of any string
 - Arrays have been Replaced by Collection's in almost all places
 - Config options now return a generic type instead of `Object`
+- Renamed `ServerFile#getInfo` to `ServerFile#get`
 - Removed `ExarotonClient#getGson()` and `WebsocketClient#getGson()`
-- Renamed `Server#setClient` to `Server#init` and added parameter `gson`
+- Removed `Server#setClient` and `CreditPool#setClient`
+- Removed `ExarotonClient#getBaseUrl()` and `ExarotonClient#createConnection(String, String)`
+- Many classes are now final
+- Added `ApiStatus` annotations to many classes and methods
 
 ## Improvements
 - Update dependencies

src/main/java/com/exaroton/api/APIRequest.java

@@ -3,31 +3,30 @@
 
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
-import org.jetbrains.annotations.NotNull;
 
-import java.io.*;
-import java.lang.reflect.Type;
-import java.net.HttpURLConnection;
-import java.nio.charset.StandardCharsets;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.http.HttpRequest;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
 
-public abstract class APIRequest<Datatype> {
+public abstract class APIRequest<Response> {
     /**
-     * exaroton API client
+     * Build the HttpRequest
+     * @param builder HttpRequest builder with preconfigured options
+     * @param baseUrl base URL
+     * @return HttpRequest
+     * @throws URISyntaxException if the constructed URI is invalid
      */
-    protected final ExarotonClient client;
+    public HttpRequest build(Gson gson, HttpRequest.Builder builder, URL baseUrl) throws URISyntaxException {
+        builder.uri(baseUrl.toURI().resolve(getPath()))
+                .method(this.getMethod(), getBodyPublisher(gson, builder));
 
-    /**
-     * Gson instance used for (de-)serialization
-     */
-    protected final Gson gson;
+        for (Map.Entry<String, String> header : this.getHeaders().entrySet()) {
+            builder.header(header.getKey(), header.getValue());
+        }
 
-    public APIRequest(@NotNull ExarotonClient client, @NotNull Gson gson) {
-        this.client = Objects.requireNonNull(client);
-        this.gson = Objects.requireNonNull(gson);
+        return builder.build();
     }
 
     /**
@@ -63,78 +62,6 @@ protected String getPath() {
         return path;
     }
 
-    /**
-     * Execute this API Request and get the raw InputStream
-     * @return InputStream
-     * @throws APIException if the request fails
-     */
-    public InputStream requestRaw() throws APIException {
-        HttpURLConnection connection = null;
-        InputStream stream;
-        try {
-            connection = client.createConnection(this.getMethod(), this.getPath());
-            for (Map.Entry<String, String> entry : this.getHeaders().entrySet()) {
-                connection.setRequestProperty(entry.getKey(), entry.getValue());
-            }
-
-            Object body = this.getBody();
-            InputStream inputStream = this.getInputStream();
-            if (body != null) {
-                inputStream = new ByteArrayInputStream(gson.toJson(body).getBytes(StandardCharsets.UTF_8));
-                connection.setRequestProperty("Content-Type", "application/json");
-            }
-
-            if (inputStream != null) {
-                connection.setDoOutput(true);
-                OutputStream out = connection.getOutputStream();
-                byte[] buf = new byte[8192];
-                int length;
-                while ((length = inputStream.read(buf)) > 0) {
-                    out.write(buf, 0, length);
-                }
-            }
-            stream = connection.getInputStream();
-        }
-        catch (IOException e) {
-            if (connection == null || connection.getErrorStream() == null) {
-                throw new APIException("Failed to request data from exaroton API", e);
-            }
-
-            stream = connection.getErrorStream();
-        }
-
-        return stream;
-    }
-
-    /**
-     * Execute this API Request and get the response as a String
-     * @return response as a String
-     * @throws APIException if the request fails
-     */
-    public String requestString() throws APIException {
-        try (InputStream stream = this.requestRaw()) {
-            return new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))
-                    .lines()
-                    .collect(Collectors.joining("\n"));
-        }
-        catch (IOException e) {
-            throw new APIException("Failed to read input stream", e);
-        }
-    }
-
-    /**
-     * Execute this API Request and parse the API response
-     * @return Parsed API response
-     * @throws APIException if the request fails
-     */
-    public APIResponse<Datatype> request() throws APIException {
-        String json = this.requestString();
-        APIResponse<Datatype> response = gson.fromJson(json, this.getType());
-        if (!response.isSuccess()) throw new APIException(response.getError());
-
-        return response;
-    }
-
     /**
      * @return request headers
      */
@@ -148,7 +75,7 @@ protected HashMap<String, String> getHeaders() {
      * get the type required for parsing the JSON response
      * @return response type
      */
-    protected abstract TypeToken<APIResponse<Datatype>> getType();
+    protected abstract TypeToken<APIResponse<Response>> getType();
 
     /**
      * data that will be replaced in the endpoint
@@ -159,17 +86,24 @@ protected HashMap<String, String> getData() {
     }
 
     /**
-     * @return input stream with data that should be sent to the request
+     * Get the body publisher for the request
+     * @param gson gson instance
+     * @param builder request builder to set the Content-Type header
+     * @param body request body
+     * @return a body publisher
      */
-    protected InputStream getInputStream() {
-        return null;
+    protected HttpRequest.BodyPublisher jsonBodyPublisher(Gson gson, HttpRequest.Builder builder, Object body) {
+        builder.header("Content-Type", "application/json");
+        return HttpRequest.BodyPublishers.ofString(gson.toJson(body));
     }
 
     /**
-     * Get the request body
-     * @return request body
+     * Get the body publisher for the request
+     * @param gson gson instance
+     * @param builder request builder which can be used to set a Content-Type header
+     * @return a body publisher
      */
-    protected Object getBody() {
-        return null;
+    protected HttpRequest.BodyPublisher getBodyPublisher(Gson gson, HttpRequest.Builder builder) {
+        return HttpRequest.BodyPublishers.noBody();
     }
 }

src/main/java/com/exaroton/api/APIResponse.java

@@ -1,5 +1,17 @@
 package com.exaroton.api;
 
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+
+import java.net.http.HttpResponse;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Flow;
+
 public class APIResponse<Datatype> {
 
     /**
@@ -17,19 +29,30 @@ public class APIResponse<Datatype> {
      */
     private final Datatype data;
 
+    /**
+     * Create a BodyHandler for APIResponse
+     * @param gson gson instance
+     * @param token type token of the response data
+     * @return BodyHandler
+     * @param <T> response data type
+     */
+    public static <T> HttpResponse.BodyHandler<APIResponse<T>> bodyHandler(ExarotonClient client, Gson gson, TypeToken<APIResponse<T>> token) {
+        return responseInfo -> new BodySubscriber<>(client, gson, token);
+    }
+
     /**
      * create an APIResponse
+     *
      * @param success request success
-     * @param error error message
-     * @param data response data
+     * @param error   error message
+     * @param data    response data
      */
     public APIResponse(boolean success, String error, Datatype data) {
         this.success = success;
         this.error = error;
         this.data = data;
     }
 
-
     /**
      * @return request success
      */
@@ -50,4 +73,56 @@ public String getError() {
     public Datatype getData() {
         return data;
     }
+
+
+    private static final class BodySubscriber<T> implements HttpResponse.BodySubscriber<APIResponse<T>> {
+        private final ExarotonClient client;
+        private final Gson gson;
+        private final TypeToken<APIResponse<T>> token;
+        private final HttpResponse.BodySubscriber<String> parent;
+
+        private BodySubscriber(ExarotonClient client, Gson gson, TypeToken<APIResponse<T>> token) {
+            this.client = client;
+            this.gson = gson;
+            this.token = token;
+            this.parent = HttpResponse.BodySubscribers.ofString(StandardCharsets.UTF_8);
+        }
+
+
+        @Override
+        public CompletionStage<APIResponse<T>> getBody() {
+            return parent.getBody().thenCompose(json -> {
+                APIResponse<T> response = gson.fromJson(json, token);
+                if (!response.isSuccess()) {
+                    return CompletableFuture.failedFuture(new APIException(response.getError()));
+                }
+
+                if (response.getData() instanceof Initializable) {
+                    ((Initializable) response.getData()).initialize(client, gson);
+                }
+
+                return CompletableFuture.completedFuture(response);
+            });
+        }
+
+        @Override
+        public void onSubscribe(Flow.Subscription subscription) {
+            parent.onSubscribe(subscription);
+        }
+
+        @Override
+        public void onNext(List<ByteBuffer> item) {
+            parent.onNext(item);
+        }
+
+        @Override
+        public void onError(Throwable throwable) {
+            parent.onError(throwable);
+        }
+
+        @Override
+        public void onComplete() {
+            parent.onComplete();
+        }
+    }
 }