Improve Http stub for pre java11 JVMs

Author: Fox2Code

fallbacks/src/main/java/notjava/net/http/HttpRequest.java

@@ -48,6 +48,8 @@ public static HttpRequest.Builder newBuilder() {
 
     public abstract String method();
 
+    public abstract Optional<Duration> timeout();
+
     public abstract URI uri();
 
     public abstract HttpHeaders headers();

fallbacks/src/main/java/notjava/net/http/HttpResponse.java

@@ -18,6 +18,8 @@ public interface HttpResponse<T> {
 
     interface ResponseInfo {
         int statusCode();
+
+        HttpHeaders headers();
     }
 
     @FunctionalInterface

fallbacks/src/main/java/notjava/net/http/impl/HttpClientImpl.java

@@ -1,12 +1,16 @@
 package notjava.net.http.impl;
 
 import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.Proxy;
 import java.net.ProxySelector;
 import notjava.net.http.HttpClient;
 import notjava.net.http.HttpRequest;
 import notjava.net.http.HttpResponse;
 import notjava.net.http.WebSocket;
 import java.time.Duration;
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
@@ -31,7 +35,42 @@ public Optional<ProxySelector> proxy() {
 
     @Override
     public <T> HttpResponse<T> send(HttpRequest request, HttpResponse.BodyHandler<T> responseBodyHandler) throws IOException, InterruptedException {
-        return null;
+        HttpURLConnection httpURLConnection;
+        if (this.proxySelector == Builder.NO_PROXY) {
+            httpURLConnection = (HttpURLConnection)
+                    request.uri().toURL().openConnection(Proxy.NO_PROXY);
+        } else {
+            httpURLConnection = (HttpURLConnection)
+                    request.uri().toURL().openConnection();
+        }
+        httpURLConnection.setRequestMethod(request.method());
+        for (Map.Entry<String, List<String>> entry : request.headers().map().entrySet()) {
+            for (String value : entry.getValue()) {
+                httpURLConnection.setRequestProperty(entry.getKey(), value);
+            }
+        }
+        Optional<Duration> timeoutOptional = request.timeout();
+        if (timeoutOptional.isPresent()) {
+            httpURLConnection.setConnectTimeout((int) timeoutOptional.get().toMillis());
+        } else if (this.connectTimeout != null) {
+            httpURLConnection.setConnectTimeout((int) this.connectTimeout.toMillis());
+        }
+        httpURLConnection.setDoInput(true);
+        Optional<HttpRequest.BodyPublisher> bodyPublisherOptional = request.bodyPublisher();
+        HttpRequest.BodyPublisher bodyPublisher;
+        if (bodyPublisherOptional.isPresent()) {
+            bodyPublisher = bodyPublisherOptional.get();
+            if (bodyPublisher instanceof ByteArrayBodyPublisherImpl) {
+                httpURLConnection.setDoOutput(true);
+                ((ByteArrayBodyPublisherImpl) bodyPublisher)
+                        .implDirectWrite(httpURLConnection.getOutputStream());
+            }
+        }
+        HttpResponseImpl<T> httpResponse = new HttpResponseImpl<>(
+                httpURLConnection, httpURLConnection.getResponseCode());
+        httpResponse.implRead(httpURLConnection.getInputStream(),
+                responseBodyHandler);
+        return httpResponse;
     }
 
     @Override

fallbacks/src/main/java/notjava/net/http/impl/HttpRequestBuilderImpl.java

@@ -11,9 +11,14 @@
 public class HttpRequestBuilderImpl implements HttpRequest.Builder {
     private final HashMap<String, List<String>> headers = new HashMap<>();
     private HttpRequest.BodyPublisher bodyPublisher;
-    private String method = "GET";
+    private Duration timeout;
+    private String method;
     private URI uri;
 
+    public HttpRequestBuilderImpl() {
+        this.method = "GET";
+    }
+
     @Override
     public HttpRequest.Builder uri(URI uri) {
         this.uri = uri;
@@ -30,6 +35,7 @@ public HttpRequest.Builder header(String name, String value) {
 
     @Override
     public HttpRequest.Builder timeout(Duration duration) {
+        this.timeout = duration;
         return this;
     }
 
@@ -71,6 +77,7 @@ public HttpRequest.Builder DELETE() {
 
     @Override
     public HttpRequest build() {
-        return new HttpRequestImpl(this.method, uri, HttpHeaders.of(headers, (k, v) -> true), bodyPublisher);
+        return new HttpRequestImpl(this.method, this.timeout, this.uri,
+                HttpHeaders.of(this.headers, (k, v) -> true), this.bodyPublisher);
     }
 }

fallbacks/src/main/java/notjava/net/http/impl/HttpRequestImpl.java

@@ -3,16 +3,20 @@
 import java.net.URI;
 import notjava.net.http.HttpHeaders;
 import notjava.net.http.HttpRequest;
+
+import java.time.Duration;
 import java.util.Optional;
 
 public class HttpRequestImpl extends HttpRequest {
     private final String method;
+    private final Duration timeout;
     private final URI uri;
     private final HttpHeaders httpHeaders;
     private final HttpRequest.BodyPublisher bodyPublisher;
 
-    public HttpRequestImpl(String method, URI uri, HttpHeaders httpHeaders, BodyPublisher bodyPublisher) {
+    public HttpRequestImpl(String method, Duration timeout, URI uri, HttpHeaders httpHeaders, BodyPublisher bodyPublisher) {
         this.method = method;
+        this.timeout = timeout;
         this.uri = uri;
         this.httpHeaders = httpHeaders;
         this.bodyPublisher = bodyPublisher;
@@ -28,6 +32,11 @@ public String method() {
         return this.method;
     }
 
+    @Override
+    public Optional<Duration> timeout() {
+        return Optional.empty();
+    }
+
     @Override
     public URI uri() {
         return this.uri;

fallbacks/src/main/java/notjava/net/http/impl/HttpResponseImpl.java

@@ -0,0 +1,64 @@
+package notjava.net.http.impl;
+
+import notjava.net.http.HttpHeaders;
+import notjava.net.http.HttpResponse;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class HttpResponseImpl<T> implements HttpResponse<T>, HttpResponse.ResponseInfo {
+    private final HttpHeaders httpHeaders;
+    private final int statusCode;
+    private CompletableFuture<T> body;
+
+    public HttpResponseImpl(HttpURLConnection httpURLConnection, int statusCode) {
+        this.httpHeaders = HttpHeaders.of(httpURLConnection
+                .getHeaderFields(), (k, v) -> true);
+        this.statusCode = statusCode;
+    }
+
+    @Override
+    public int statusCode() {
+        return this.statusCode;
+    }
+
+    @Override
+    public HttpHeaders headers() {
+        return this.httpHeaders;
+    }
+
+    @Override
+    public T body() {
+        return body.join();
+    }
+
+    public void implRead(InputStream inputStream,
+                         HttpResponse.BodyHandler<T> bodyHandler)
+            throws IOException {
+        BodySubscriber<T> bodySubscriber = bodyHandler.apply(this);
+        byte[] buffer = new byte[2048];
+        List<ByteBuffer> byteBufferList =
+                Collections.singletonList(
+                        ByteBuffer.wrap(buffer));
+        int len;
+        try {
+            while ((len = inputStream.read(buffer)) > 0) {
+                if (len == buffer.length) {
+                    bodySubscriber.onNext(byteBufferList);
+                } else {
+                    bodySubscriber.onNext(Collections.singletonList(
+                            ByteBuffer.wrap(buffer, 0, len)));
+                }
+            }
+        } catch (IOException ioe) {
+            bodySubscriber.onError(ioe);
+            throw ioe;
+        }
+        this.body = bodySubscriber.getBody().toCompletableFuture();
+    }
+}