bric3 · September 5, 2022 10:38
diff --git a/HttpClientBug.java b/HttpClientBug.java
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UncheckedIOException;
 import java.net.URI;
 import java.net.http.HttpClient;
 import java.net.http.HttpRequest;
 import java.net.http.HttpResponse;
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.zip.GZIPInputStream;


 /**
 * Work around <a href="https://bugs.openjdk.java.net/browse/JDK-8217627">JDK-8217627</a>,
 * <a href="https://bugs.openjdk.java.net/browse/JDK-8217264">JDK-8217264</a>
 * when using {@link java.net.http.HttpResponse.BodySubscribers#mapping(HttpResponse.BodySubscriber, Function)} and a
 * blocking call like {@link GZIPInputStream#GZIPInputStream(InputStream)}.
 * 
 * <strong>Note this is fixed since JDK 13.</strong>
 */
 public class HttpClientBug {
    public static void main(String[] args) throws IOException, InterruptedException {
        System.getLogger("main").log(System.Logger.Level.INFO, System.getProperty("java.version"));

        var request = HttpRequest.newBuilder(URI.create("https://dog.ceo/api/breeds/image/random"))
                .GET()
                .header("Accept-Encoding", "gzip")
                .build();

        var httpClient = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_1_1)
                .followRedirects(HttpClient.Redirect.NORMAL)
                .connectTimeout(Duration.of(5, ChronoUnit.SECONDS))
                .build();

        var httpResponse = httpClient.send(
                request,
                terminalBodyHandler(gzipBodyHandler())
        );

        if (httpResponse.statusCode() == 200) {
            System.out.println(httpResponse.body().get());
        } else {
            System.out.println("Unexpected status code: " + httpResponse.statusCode());
        }
    }

    /**
     * Body handler that returns a Supplier of the response body as a String.
     *
     * <p>
     *     The supplier is necessary for the same reasons stated in {@link #gzipBodyHandler()},
     *     as it relies on this upstream body handler. So the call to initiate the decoding of
     *     the data has to be made after {@link HttpResponse#body()}.
     * </p>
     *
     * @param upstreamHandler The upstream body handler.
     * @return Body handler that decodes the input stream as a String.
     */
    private static HttpResponse.BodyHandler<Supplier<String>> terminalBodyHandler(HttpResponse.BodyHandler<Supplier<InputStream>> upstreamHandler) {
        return responseInfo -> {
            var statusCode = responseInfo.statusCode();
            var upstream = upstreamHandler.apply(responseInfo);

            if (statusCode >= 200 && statusCode < 300) {
                return HttpResponse.BodySubscribers.mapping(upstream, inputStream -> () -> {
                    try (var is = inputStream.get()) {
                        return new String(is.readAllBytes());
                    } catch (IOException e) {
                        e.printStackTrace();
                        throw new UncheckedIOException(e);
                    }
                });
            } else {
                return HttpResponse.BodySubscribers.mapping(upstream, inputStream -> () -> {
                    try (var is = inputStream.get()) {
                        return new String(is.readAllBytes());
                    } catch (IOException e) {
                        e.printStackTrace();
                        throw new UncheckedIOException(e);
                    }
                });
            }
        };
    }

    /**
     * Returns a body handler that returns a Supplier of inputstream able to handle gzip, brotli compression or nothing
     *
     * <p>
     *     The use of the Supplier is necessary on JDK11u, because GZIPInputStream and BrotliInputStream
     *     are reading the stream in their constructor (typically to read the compressed stream headers),
     *     since this operation is blocking, it blocks the executor from performing other HttpClient tasks
     *     And as such, the {@link HttpClient#send(HttpRequest, HttpResponse.BodyHandler)} call is blocked.
     * </p>
     * <p>
     *     In order to prevent that it is necessary to map to a supplier that make the blocking operations
     *     happen <strong>after</strong> the call to {@link HttpResponse#body()}.
     * </p>
     *
     * @see <a href="https://bugs.openjdk.java.net/browse/JDK-8217627">JDK-8217627</a>
     * @see <a href="https://bugs.openjdk.java.net/browse/JDK-8217264">JDK-8217264</a>
     * @return BodyHandler mapping to an input stream supplier
     */
    private static HttpResponse.BodyHandler<Supplier<InputStream>> gzipBodyHandler() {
        return responseInfo -> {
            var gzipped = responseInfo.headers()
                    .firstValue("content-encoding")
                    .orElse("")
                    .equalsIgnoreCase("gzip");

            if (gzipped) {
                System.out.println("Gzipped response");
                return HttpResponse.BodySubscribers.mapping(
                        HttpResponse.BodySubscribers.ofInputStream(),
                        inputStream -> () -> {
                            try {
                                return new GZIPInputStream(inputStream);
                            } catch (IOException e) {
                                e.printStackTrace();
                                throw new UncheckedIOException(e);
                            }
                        }
                );
            } else {
                return HttpResponse.BodySubscribers.mapping(HttpResponse.BodySubscribers.ofInputStream(), inputStream -> () -> inputStream);
            }
        };
    }
 }
diff --git a/without-work-around-thread-dump-stack.adoc b/without-work-around-thread-dump-stack.adoc
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.UncheckedIOException;
	import java.net.URI;
	import java.net.http.HttpClient;
	import java.net.http.HttpRequest;
	import java.net.http.HttpResponse;
	import java.time.Duration;
	import java.time.temporal.ChronoUnit;
	import java.util.function.Function;
	import java.util.function.Supplier;
	import java.util.zip.GZIPInputStream;


	/**
	* Work around <a href="https://bugs.openjdk.java.net/browse/JDK-8217627">JDK-8217627</a>,
	* <a href="https://bugs.openjdk.java.net/browse/JDK-8217264">JDK-8217264</a>
	* when using {@link java.net.http.HttpResponse.BodySubscribers#mapping(HttpResponse.BodySubscriber, Function)} and a
	* blocking call like {@link GZIPInputStream#GZIPInputStream(InputStream)}.
	*
	* <strong>Note this is fixed since JDK 13.</strong>
	*/
	public class HttpClientBug {
	public static void main(String[] args) throws IOException, InterruptedException {
	System.getLogger("main").log(System.Logger.Level.INFO, System.getProperty("java.version"));

	var request = HttpRequest.newBuilder(URI.create("https://dog.ceo/api/breeds/image/random"))
	.GET()
	.header("Accept-Encoding", "gzip")
	.build();

	var httpClient = HttpClient.newBuilder()
	.version(HttpClient.Version.HTTP_1_1)
	.followRedirects(HttpClient.Redirect.NORMAL)
	.connectTimeout(Duration.of(5, ChronoUnit.SECONDS))
	.build();

	var httpResponse = httpClient.send(
	request,
	terminalBodyHandler(gzipBodyHandler())
	);

	if (httpResponse.statusCode() == 200) {
	System.out.println(httpResponse.body().get());
	} else {
	System.out.println("Unexpected status code: " + httpResponse.statusCode());
	}
	}

	/**
	* Body handler that returns a Supplier of the response body as a String.
	*
	* <p>
	* The supplier is necessary for the same reasons stated in {@link #gzipBodyHandler()},
	* as it relies on this upstream body handler. So the call to initiate the decoding of
	* the data has to be made after {@link HttpResponse#body()}.
	* </p>
	*
	* @param upstreamHandler The upstream body handler.
	* @return Body handler that decodes the input stream as a String.
	*/
	private static HttpResponse.BodyHandler<Supplier<String>> terminalBodyHandler(HttpResponse.BodyHandler<Supplier<InputStream>> upstreamHandler) {
	return responseInfo -> {
	var statusCode = responseInfo.statusCode();
	var upstream = upstreamHandler.apply(responseInfo);

	if (statusCode >= 200 && statusCode < 300) {
	return HttpResponse.BodySubscribers.mapping(upstream, inputStream -> () -> {
	try (var is = inputStream.get()) {
	return new String(is.readAllBytes());
	} catch (IOException e) {
	e.printStackTrace();
	throw new UncheckedIOException(e);
	}
	});
	} else {
	return HttpResponse.BodySubscribers.mapping(upstream, inputStream -> () -> {
	try (var is = inputStream.get()) {
	return new String(is.readAllBytes());
	} catch (IOException e) {
	e.printStackTrace();
	throw new UncheckedIOException(e);
	}
	});
	}
	};
	}

	/**
	* Returns a body handler that returns a Supplier of inputstream able to handle gzip, brotli compression or nothing
	*
	* <p>
	* The use of the Supplier is necessary on JDK11u, because GZIPInputStream and BrotliInputStream
	* are reading the stream in their constructor (typically to read the compressed stream headers),
	* since this operation is blocking, it blocks the executor from performing other HttpClient tasks
	* And as such, the {@link HttpClient#send(HttpRequest, HttpResponse.BodyHandler)} call is blocked.
	* </p>
	* <p>
	* In order to prevent that it is necessary to map to a supplier that make the blocking operations
	* happen <strong>after</strong> the call to {@link HttpResponse#body()}.
	* </p>
	*
	* @see <a href="https://bugs.openjdk.java.net/browse/JDK-8217627">JDK-8217627</a>
	* @see <a href="https://bugs.openjdk.java.net/browse/JDK-8217264">JDK-8217264</a>
	* @return BodyHandler mapping to an input stream supplier
	*/
	private static HttpResponse.BodyHandler<Supplier<InputStream>> gzipBodyHandler() {
	return responseInfo -> {
	var gzipped = responseInfo.headers()
	.firstValue("content-encoding")
	.orElse("")
	.equalsIgnoreCase("gzip");

	if (gzipped) {
	System.out.println("Gzipped response");
	return HttpResponse.BodySubscribers.mapping(
	HttpResponse.BodySubscribers.ofInputStream(),
	inputStream -> () -> {
	try {
	return new GZIPInputStream(inputStream);
	} catch (IOException e) {
	e.printStackTrace();
	throw new UncheckedIOException(e);
	}
	}
	);
	} else {
	return HttpResponse.BodySubscribers.mapping(HttpResponse.BodySubscribers.ofInputStream(), inputStream -> () -> inputStream);
	}
	};
	}
	}