Support Brotli compression in JDK HTTP Client

Enable Brotli/ZStandard in Jetty HTTP Client
Add tests for compressed responses.

This closes #1744

Author: kwin

maven-resolver-test-http/pom.xml

@@ -81,6 +81,18 @@
       <groupId>org.eclipse.jetty.compression</groupId>
       <artifactId>jetty-compression-server</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.eclipse.jetty.compression</groupId>
+      <artifactId>jetty-compression-zstandard</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.eclipse.jetty.compression</groupId>
+      <artifactId>jetty-compression-brotli</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.eclipse.jetty.compression</groupId>
+      <artifactId>jetty-compression-gzip</artifactId>
+    </dependency>
     <dependency>
       <groupId>jakarta.servlet</groupId>
       <artifactId>jakarta.servlet-api</artifactId>
@@ -98,6 +110,10 @@
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-api</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-params</artifactId>
+    </dependency>
     <dependency>
       <groupId>com.google.code.gson</groupId>
       <artifactId>gson</artifactId>

maven-resolver-test-http/src/main/java/org/eclipse/aether/internal/test/util/http/HttpServer.java

@@ -43,10 +43,17 @@
 import org.eclipse.aether.spi.connector.checksum.ChecksumAlgorithmHelper;
 import org.eclipse.aether.spi.connector.transport.http.RFC9457.RFC9457Payload;
 import org.eclipse.jetty.alpn.server.ALPNServerConnectionFactory;
+import org.eclipse.jetty.compression.server.CompressionConfig;
+import org.eclipse.jetty.compression.server.CompressionHandler;
 import org.eclipse.jetty.http.DateGenerator;
 import org.eclipse.jetty.http.HttpField;
+import org.eclipse.jetty.http.HttpFields;
 import org.eclipse.jetty.http.HttpHeader;
 import org.eclipse.jetty.http.HttpMethod;
+import org.eclipse.jetty.http.HttpURI;
+import org.eclipse.jetty.http.pathmap.MatchedResource;
+import org.eclipse.jetty.http.pathmap.PathMappings;
+import org.eclipse.jetty.http.pathmap.PathSpec;
 import org.eclipse.jetty.http2.server.HTTP2ServerConnectionFactory;
 import org.eclipse.jetty.io.Content;
 import org.eclipse.jetty.server.Handler;
@@ -72,12 +79,16 @@ public static class LogEntry {
 
         private final String path;
 
-        private final Map<String, String> headers;
+        private final Map<String, String> requestHeaders;
 
-        public LogEntry(String method, String path, Map<String, String> headers) {
+        private final Map<String, String> responseHeaders;
+
+        public LogEntry(
+                String method, String path, Map<String, String> requestHeaders, Map<String, String> responseHeaders) {
             this.method = method;
             this.path = path;
-            this.headers = headers;
+            this.requestHeaders = requestHeaders;
+            this.responseHeaders = responseHeaders;
         }
 
         public String getMethod() {
@@ -88,8 +99,12 @@ public String getPath() {
             return path;
         }
 
-        public Map<String, String> getHeaders() {
-            return headers;
+        public Map<String, String> getRequestHeaders() {
+            return requestHeaders;
+        }
+
+        public Map<String, String> getResponseHeaders() {
+            return responseHeaders;
         }
 
         @Override
@@ -290,15 +305,15 @@ public HttpServer start() throws Exception {
         server = new Server();
         httpConnector = new ServerConnector(server);
         server.addConnector(httpConnector);
-        server.setHandler(new Handler.Sequence(
+
+        server.setHandler(new LogHandler(new CompressionEnforcingHandler(new Handler.Sequence(
                 new ConnectionClosingHandler(),
                 new ServerErrorHandler(),
-                new LogHandler(),
                 new ProxyAuthHandler(),
                 new AuthHandler(),
                 new RedirectHandler(),
                 new RepoHandler(),
-                new RFC9457Handler()));
+                new RFC9457Handler()))));
         server.start();
 
         return this;
@@ -313,6 +328,112 @@ public void stop() throws Exception {
         }
     }
 
+    private class CompressionEnforcingHandler extends CompressionHandler {
+        // duplicate of CompressionHandler.pathConfigs which is private
+        private final PathMappings<CompressionConfig> pathConfigs = new PathMappings<>();
+
+        CompressionEnforcingHandler(Handler handler) {
+            super(handler);
+            this.putConfiguration(
+                    "/br/*",
+                    CompressionConfig.builder().compressIncludeEncoding("br").build());
+            this.putConfiguration(
+                    "/zstd/*",
+                    CompressionConfig.builder().compressIncludeEncoding("zstd").build());
+            this.putConfiguration(
+                    "/gzip/*",
+                    CompressionConfig.builder().compressIncludeEncoding("gzip").build());
+            this.putConfiguration(
+                    "/deflate/*",
+                    CompressionConfig.builder()
+                            .compressIncludeEncoding("deflate")
+                            .build());
+        }
+
+        @Override
+        public CompressionConfig putConfiguration(PathSpec pathSpec, CompressionConfig config) {
+            // deliberately not set it in the super class yet
+            return pathConfigs.put(pathSpec, config);
+        }
+
+        @Override
+        public boolean handle(Request request, Response response, Callback callback) throws Exception {
+            Handler next = getHandler();
+            if (next == null) {
+                return false;
+            }
+            String pathInContext = Request.getPathInContext(request);
+            MatchedResource<CompressionConfig> matchedConfig = this.pathConfigs.getMatched(pathInContext);
+            if (matchedConfig == null) {
+                if (LOGGER.isDebugEnabled()) {
+                    LOGGER.debug("skipping compression: path {} has no matching compression config", pathInContext);
+                }
+                // No configuration, skip
+                return next.handle(request, response, callback);
+            }
+
+            // set the matched config in the super class for further processing, but for all paths
+            // no need to reset it later as this handler is not used among multiple requests
+            super.putConfiguration(PathSpec.from("/*"), matchedConfig.getResource());
+            // first path segment determines the encoding, remove it from the request path for further processing
+            return super.handle(new StripLeadingPathSegmentsRequestWrapper(request, 1), response, callback);
+        }
+    }
+
+    private static class StripLeadingPathSegmentsRequestWrapper extends Request.Wrapper {
+        private final HttpURI modifiedURI;
+
+        StripLeadingPathSegmentsRequestWrapper(Request wrapped, int segmentsToStrip) {
+            super(wrapped);
+            this.modifiedURI = stripPathSegments(wrapped.getHttpURI(), segmentsToStrip);
+        }
+
+        private static org.eclipse.jetty.http.HttpURI stripPathSegments(
+                org.eclipse.jetty.http.HttpURI originalURI, int segmentsToStrip) {
+            if (segmentsToStrip <= 0) {
+                return originalURI;
+            }
+
+            String originalPath = originalURI.getPath();
+            if (originalPath == null || originalPath.isEmpty()) {
+                return originalURI;
+            }
+
+            // Split path into segments
+            String[] segments = originalPath.split("/");
+            StringBuilder newPath = new StringBuilder();
+
+            // Skip empty first segment (from leading /) and the specified number of segments
+            int skipCount = 0;
+            for (int i = 0; i < segments.length; i++) {
+                if (segments[i].isEmpty() && i == 0) {
+                    // Skip leading empty segment from leading /
+                    continue;
+                }
+                if (skipCount < segmentsToStrip) {
+                    skipCount++;
+                    continue;
+                }
+                newPath.append("/").append(segments[i]);
+            }
+
+            // If we stripped everything, return root path
+            if (newPath.isEmpty()) {
+                newPath.append("/");
+            }
+
+            // Build new URI with modified path
+            return org.eclipse.jetty.http.HttpURI.build(originalURI)
+                    .path(newPath.toString())
+                    .asImmutable();
+        }
+
+        @Override
+        public HttpURI getHttpURI() {
+            return modifiedURI;
+        }
+    }
+
     private class ConnectionClosingHandler extends Handler.Abstract {
 
         @Override
@@ -337,22 +458,41 @@ public boolean handle(Request request, Response response, Callback callback) thr
         }
     }
 
-    private class LogHandler extends Handler.Abstract {
+    private class LogHandler extends Handler.Wrapper {
+
+        LogHandler(Handler handler) {
+            super(handler);
+        }
+
         @Override
-        public boolean handle(Request req, Response response, Callback callback) {
+        public boolean handle(Request req, Response response, Callback callback) throws Exception {
+
             LOGGER.info(
                     "{} {}{}",
                     req.getMethod(),
                     req.getHttpURI().getDecodedPath(),
                     req.getHttpURI().getQuery() != null ? "?" + req.getHttpURI().getQuery() : "");
 
-            Map<String, String> headers = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
-            for (HttpField header : req.getHeaders()) {
-                headers.put(header.getName(), header.getValueList().stream().collect(Collectors.joining(", ")));
+            Map<String, String> requestHeaders =
+                    toUnmodifiableMap(req.getHeaders()); // capture request headers before other handlers modify them
+            try {
+                return super.handle(req, response, callback);
+            } finally {
+                // capture response headers after other handlers modified them
+                logEntries.add(new LogEntry(
+                        req.getMethod(),
+                        req.getHttpURI().getPathQuery(),
+                        requestHeaders,
+                        toUnmodifiableMap(response.getHeaders())));
             }
-            logEntries.add(new LogEntry(
-                    req.getMethod(), req.getHttpURI().getPathQuery(), Collections.unmodifiableMap(headers)));
-            return false;
+        }
+
+        Map<String, String> toUnmodifiableMap(HttpFields headers) {
+            Map<String, String> map = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+            for (HttpField header : headers) {
+                map.put(header.getName(), header.getValueList().stream().collect(Collectors.joining(", ")));
+            }
+            return Collections.unmodifiableMap(map);
         }
     }