Introduce HttpCompressionOptions.

Motivation:

HTTP/3 will require configure of compression. This introduces a new HttpCompressionOptions configuration that encapsulate anything related to compression configuration.

Changes:

The HttpServerConfiguration is modified to use this setting and delegate the current related methods to the underlying compression object to support the transition.

HTTP compression tests have been reworked to use the new HTTP configuration mechanism and reduce the proliferation of test subclasses to reduce the amount of necessary code to test the variety of algorithms.

Author: vietj

vertx-core/src/main/java/io/vertx/core/http/HttpCompressionOptions.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2011-2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+ * which is available at https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+ */
+package io.vertx.core.http;
+
+import io.netty.handler.codec.compression.CompressionOptions;
+import io.vertx.codegen.annotations.DataObject;
+import io.vertx.core.impl.Arguments;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * HTTP compression configuration.
+ */
+@DataObject
+public class HttpCompressionOptions {
+
+  private int contentSizeThreshold;
+  private List<CompressionOptions> compressors;
+
+  public HttpCompressionOptions() {
+    this.contentSizeThreshold = HttpServerOptions.DEFAULT_COMPRESSION_CONTENT_SIZE_THRESHOLD;
+    this.compressors = null;
+  }
+
+  public HttpCompressionOptions(HttpCompressionOptions other) {
+    this.contentSizeThreshold = other.contentSizeThreshold;
+    this.compressors = other.compressors != null ? new ArrayList<>(other.compressors) : null;
+  }
+
+  /**
+   * @return the compression content size threshold
+   */
+  public int getContentSizeThreshold() {
+    return contentSizeThreshold;
+  }
+
+  /**
+   * Set the compression content size threshold if compression is enabled. This is only applicable for HTTP/1.x response bodies.
+   * If the response content size in bytes is greater than this threshold, then the response is compressed. Otherwise, it is not compressed.
+   *
+   * @param contentSizeThreshold integer greater than or equal to 0.
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpCompressionOptions setContentSizeThreshold(int contentSizeThreshold) {
+    Arguments.require(contentSizeThreshold >= 0, "compressionContentSizeThreshold must be >= 0");
+    this.contentSizeThreshold = contentSizeThreshold;
+    return this;
+  }
+
+  /**
+   * @return the list of compressor to use
+   */
+  public List<CompressionOptions> getCompressors() {
+    return compressors;
+  }
+
+  /**
+   * Add a compressor.
+   *
+   * @see #setCompressors(List)
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpCompressionOptions addCompressor(CompressionOptions compressor) {
+    if (compressors == null) {
+      compressors = new ArrayList<>();
+    }
+    compressors.add(compressor);
+    return this;
+  }
+
+  /**
+   * @param compressors the list of compressors
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpCompressionOptions setCompressors(List<CompressionOptions> compressors) {
+    this.compressors = compressors;
+    return this;
+  }
+}

vertx-core/src/main/java/io/vertx/core/http/HttpServerOptions.java

@@ -211,8 +211,7 @@ public class HttpServerOptions extends NetServerOptions {
 
   private boolean compressionSupported;
   private int compressionLevel;
-  private int compressionContentSizeThreshold;
-  private List<CompressionOptions> compressors;
+  private HttpCompressionOptions compression;
   private int maxWebSocketFrameSize;
   private int maxWebSocketMessageSize;
   private List<String> webSocketSubProtocols;
@@ -261,8 +260,7 @@ public HttpServerOptions(HttpServerOptions other) {
     super(other);
     this.compressionSupported = other.isCompressionSupported();
     this.compressionLevel = other.getCompressionLevel();
-    this.compressionContentSizeThreshold = other.getCompressionContentSizeThreshold();
-    this.compressors = other.compressors != null ? new ArrayList<>(other.compressors) : null;
+    this.compression = other.compression != null ? new HttpCompressionOptions(other.compression) : new HttpCompressionOptions();
     this.maxWebSocketFrameSize = other.maxWebSocketFrameSize;
     this.maxWebSocketMessageSize = other.maxWebSocketMessageSize;
     this.webSocketSubProtocols = other.webSocketSubProtocols != null ? new ArrayList<>(other.webSocketSubProtocols) : null;
@@ -320,8 +318,7 @@ public JsonObject toJson() {
   private void init() {
     strictThreadMode = DEFAULT_STRICT_THREAD_MODE_STRICT;
     compressionSupported = DEFAULT_COMPRESSION_SUPPORTED;
-    compressionLevel = DEFAULT_COMPRESSION_LEVEL;
-    compressionContentSizeThreshold = DEFAULT_COMPRESSION_CONTENT_SIZE_THRESHOLD;
+    compression = new HttpCompressionOptions();
     maxWebSocketFrameSize = DEFAULT_MAX_WEBSOCKET_FRAME_SIZE;
     maxWebSocketMessageSize = DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE;
     handle100ContinueAutomatically = DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY;
@@ -572,6 +569,24 @@ public HttpServerOptions setCompressionSupported(boolean compressionSupported) {
     return this;
   }
 
+  /**
+   * @return the compression configuration
+   */
+  public HttpCompressionOptions getCompression() {
+    return compression;
+  }
+
+  /**
+   * Configure the server compression, this overwrites any previously configuration.
+   *
+   * @param compression the new configuration
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpServerOptions setCompression(HttpCompressionOptions compression) {
+    this.compression = compression == null ? new HttpCompressionOptions() : compression;
+    return this;
+  }
+
   /**
    *
    * @return the server gzip/deflate 'compression level' to be used in responses when client and server support is turned on
@@ -580,7 +595,6 @@ public int getCompressionLevel() {
     return this.compressionLevel;
   }
 
-
   /**
    * This method allows to set the compression level to be used in http1.x/2 response bodies
    * when compression support is turned on (@see setCompressionSupported) and the client advertises
@@ -616,7 +630,7 @@ public HttpServerOptions setCompressionLevel(int compressionLevel) {
    * @return the compression content size threshold
    */
   public int getCompressionContentSizeThreshold() {
-    return compressionContentSizeThreshold;
+    return compression.getContentSizeThreshold();
   }
 
   /**
@@ -627,16 +641,15 @@ public int getCompressionContentSizeThreshold() {
    * @return a reference to this, so the API can be used fluently
    */
   public HttpServerOptions setCompressionContentSizeThreshold(int compressionContentSizeThreshold) {
-    Arguments.require(compressionContentSizeThreshold >= 0, "compressionContentSizeThreshold must be >= 0");
-    this.compressionContentSizeThreshold = compressionContentSizeThreshold;
+    compression.setContentSizeThreshold(compressionContentSizeThreshold);
     return this;
   }
 
   /**
    * @return the list of compressor to use
    */
   public List<CompressionOptions> getCompressors() {
-    return compressors;
+    return compression.getCompressors();
   }
 
   /**
@@ -646,10 +659,7 @@ public List<CompressionOptions> getCompressors() {
    * @return a reference to this, so the API can be used fluently
    */
   public HttpServerOptions addCompressor(CompressionOptions compressor) {
-    if (compressors == null) {
-      compressors = new ArrayList<>();
-    }
-    compressors.add(compressor);
+    compression.addCompressor(compressor);
     return this;
   }
 
@@ -662,7 +672,7 @@ public HttpServerOptions addCompressor(CompressionOptions compressor) {
    * @return a reference to this, so the API can be used fluently
    */
   public HttpServerOptions setCompressors(List<CompressionOptions> compressors) {
-    this.compressors = compressors;
+    compression.setCompressors(compressors);
     return this;
   }
 

vertx-core/src/test/java/io/vertx/test/http/HttpConfig.java

@@ -76,6 +76,21 @@ public HttpClientBuilder builder(Vertx vertx) {
     public HttpServerConfig forServer() {
       HttpServerOptions options = createBaseServerOptions();
       return new HttpServerConfig() {
+        @Override
+        public HttpServerConfig setDecompressionSupported(boolean supported) {
+          options.setDecompressionSupported(supported);
+          return this;
+        }
+        @Override
+        public HttpServerConfig setCompressionSupported(boolean supported) {
+          options.setCompressionSupported(supported);
+          return this;
+        }
+        @Override
+        public HttpServerConfig setCompression(HttpCompressionOptions compression) {
+          options.setCompression(compression);
+          return this;
+        }
         @Override
         public HttpServerConfig setMaxFormBufferedBytes(int maxFormBufferedBytes) {
           options.setMaxFormBufferedBytes(maxFormBufferedBytes);

vertx-core/src/test/java/io/vertx/test/http/HttpServerConfig.java

@@ -1,12 +1,16 @@
 package io.vertx.test.http;
 
 import io.vertx.core.Vertx;
+import io.vertx.core.http.HttpCompressionOptions;
 import io.vertx.core.http.HttpServer;
 
 import java.time.Duration;
 
 public interface HttpServerConfig {
 
+  HttpServerConfig setDecompressionSupported(boolean supported);
+  HttpServerConfig setCompressionSupported(boolean supported);
+  HttpServerConfig setCompression(HttpCompressionOptions compression);
   HttpServerConfig setMaxFormBufferedBytes(int maxFormBufferedBytes);
   HttpServerConfig setMaxFormAttributeSize(int maxSize);
   HttpServerConfig setMaxFormFields(int maxFormFields);

vertx-core/src/test/java/io/vertx/tests/http/compression/CompressionConfig.java

@@ -0,0 +1,57 @@
+package io.vertx.tests.http.compression;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.MessageToByteEncoder;
+import io.netty.handler.codec.compression.*;
+
+import java.util.function.Supplier;
+
+public class CompressionConfig {
+
+  public static CompressionConfig gzip(int level) {
+    return new CompressionConfig("gzip", () -> new JdkZlibEncoder(ZlibWrapper.GZIP, level),
+      StandardCompressionOptions.gzip(level, StandardCompressionOptions.gzip().windowBits(), StandardCompressionOptions.gzip().memLevel())) {
+      @Override
+      public String toString() {
+        return "(gzip level:" + level + ")";
+      }
+    };
+  }
+
+  public static CompressionConfig brotli() {
+    return new CompressionConfig("br", BrotliEncoder::new, StandardCompressionOptions.brotli()) {
+      @Override
+      public String toString() {
+        return "(brotli)";
+      }
+    };
+  }
+
+  public static CompressionConfig snappy() {
+    return new CompressionConfig("snappy", SnappyFrameEncoder::new, StandardCompressionOptions.snappy()) {
+      @Override
+      public String toString() {
+        return "(snappy)";
+      }
+    };
+  }
+
+  public static CompressionConfig zstd() {
+    return new CompressionConfig("zstd", ZstdEncoder::new, StandardCompressionOptions.zstd()) {
+      @Override
+      public String toString() {
+        return "(zstd)";
+      }
+    };
+  }
+
+  public final String encoding;
+  public final Supplier<MessageToByteEncoder<ByteBuf>> encoder;
+  public final CompressionOptions compressor;
+
+  public CompressionConfig(String encoding, Supplier<MessageToByteEncoder<ByteBuf>> encoder, CompressionOptions compressor) {
+    this.encoding = encoding;
+    this.encoder = encoder;
+    this.compressor = compressor;
+  }
+}