Merge pull request #5613 from eclipse-vertx/encapsulate-http2-connection-handler

HTTP/2 multiplex implementation

Author: vietj

vertx-core/src/main/generated/io/vertx/core/http/HttpClientOptionsConverter.java

@@ -34,6 +34,11 @@ static void fromJson(Iterable<java.util.Map.Entry<String, Object>> json, HttpCli
             obj.setHttp2UpgradeMaxContentLength(((Number)member.getValue()).intValue());
           }
           break;
+        case "http2MultiplexImplementation":
+          if (member.getValue() instanceof Boolean) {
+            obj.setHttp2MultiplexImplementation((Boolean)member.getValue());
+          }
+          break;
         case "keepAlive":
           if (member.getValue() instanceof Boolean) {
             obj.setKeepAlive((Boolean)member.getValue());
@@ -162,6 +167,7 @@ static void toJson(HttpClientOptions obj, java.util.Map<String, Object> json) {
     json.put("http2ConnectionWindowSize", obj.getHttp2ConnectionWindowSize());
     json.put("http2KeepAliveTimeout", obj.getHttp2KeepAliveTimeout());
     json.put("http2UpgradeMaxContentLength", obj.getHttp2UpgradeMaxContentLength());
+    json.put("http2MultiplexImplementation", obj.getHttp2MultiplexImplementation());
     json.put("keepAlive", obj.isKeepAlive());
     json.put("keepAliveTimeout", obj.getKeepAliveTimeout());
     json.put("pipelining", obj.isPipelining());

vertx-core/src/main/generated/io/vertx/core/http/HttpServerOptionsConverter.java

@@ -184,6 +184,11 @@ static void fromJson(Iterable<java.util.Map.Entry<String, Object>> json, HttpSer
             obj.setStrictThreadMode((Boolean)member.getValue());
           }
           break;
+        case "http2MultiplexImplementation":
+          if (member.getValue() instanceof Boolean) {
+            obj.setHttp2MultiplexImplementation((Boolean)member.getValue());
+          }
+          break;
       }
     }
   }
@@ -239,5 +244,6 @@ static void toJson(HttpServerOptions obj, java.util.Map<String, Object> json) {
       json.put("http2RstFloodWindowDurationTimeUnit", obj.getHttp2RstFloodWindowDurationTimeUnit().name());
     }
     json.put("strictThreadMode", obj.getStrictThreadMode());
+    json.put("http2MultiplexImplementation", obj.getHttp2MultiplexImplementation());
   }
 }

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

@@ -157,6 +157,11 @@ public class HttpClientOptions extends ClientOptionsBase {
    */
   public static final String DEFAULT_NAME = "__vertx.DEFAULT";
 
+  /**
+   * Use HTTP/2 multiplex implementation = {@code false}
+   */
+  public static final boolean DEFAULT_HTTP_2_MULTIPLEX_IMPLEMENTATION = false;
+
   private boolean verifyHost = true;
   private boolean keepAlive;
   private int keepAliveTimeout;
@@ -166,6 +171,7 @@ public class HttpClientOptions extends ClientOptionsBase {
   private int http2ConnectionWindowSize;
   private int http2KeepAliveTimeout;
   private int http2UpgradeMaxContentLength;
+  private boolean http2MultiplexImplementation;
 
   private boolean decompressionSupported;
   private String defaultHost;
@@ -221,6 +227,7 @@ public HttpClientOptions(HttpClientOptions other) {
     this.http2ConnectionWindowSize = other.http2ConnectionWindowSize;
     this.http2KeepAliveTimeout = other.getHttp2KeepAliveTimeout();
     this.http2UpgradeMaxContentLength = other.getHttp2UpgradeMaxContentLength();
+    this.http2MultiplexImplementation = other.getHttp2MultiplexImplementation();
     this.decompressionSupported = other.decompressionSupported;
     this.defaultHost = other.defaultHost;
     this.defaultPort = other.defaultPort;
@@ -272,6 +279,7 @@ private void init() {
     http2ConnectionWindowSize = DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE;
     http2KeepAliveTimeout = DEFAULT_HTTP2_KEEP_ALIVE_TIMEOUT;
     http2UpgradeMaxContentLength = DEFAULT_HTTP2_UPGRADE_MAX_CONTENT_LENGTH;
+    http2MultiplexImplementation = DEFAULT_HTTP_2_MULTIPLEX_IMPLEMENTATION;
     decompressionSupported = DEFAULT_DECOMPRESSION_SUPPORTED;
     defaultHost = DEFAULT_DEFAULT_HOST;
     defaultPort = DEFAULT_DEFAULT_PORT;
@@ -559,6 +567,24 @@ public HttpClientOptions setHttp2UpgradeMaxContentLength(int http2UpgradeMaxCont
     return this;
   }
 
+  /**
+   * @return whether to use the HTTP/2 implementation based on multiplexed channel
+   */
+  public boolean getHttp2MultiplexImplementation() {
+    return http2MultiplexImplementation;
+  }
+
+  /**
+   * Set which HTTP/2 implementation to use
+   *
+   * @param http2MultiplexImplementation whether to use the HTTP/2 multiplex implementation
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpClientOptions setHttp2MultiplexImplementation(boolean http2MultiplexImplementation) {
+    this.http2MultiplexImplementation = http2MultiplexImplementation;
+    return this;
+  }
+
   /**
    * Is keep alive enabled on the client?
    *

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

@@ -20,7 +20,7 @@
 import io.vertx.codegen.annotations.VertxGen;
 import io.vertx.core.MultiMap;
 import io.vertx.core.http.impl.headers.HeadersMultiMap;
-import io.vertx.core.http.impl.headers.Http2HeadersAdaptor;
+import io.vertx.core.http.impl.http2.Http2HeadersMultiMap;
 
 /**
  * Contains a bunch of useful HTTP headers stuff:
@@ -507,7 +507,7 @@ static MultiMap headers(HttpVersion version) {
       case HTTP_1_1:
         return HeadersMultiMap.httpHeaders();
       case HTTP_2:
-        return new Http2HeadersAdaptor(new DefaultHttp2Headers());
+        return new Http2HeadersMultiMap(new DefaultHttp2Headers());
       default:
         throw new AssertionError();
     }

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

@@ -206,6 +206,11 @@ public class HttpServerOptions extends NetServerOptions {
    */
   public static final boolean DEFAULT_STRICT_THREAD_MODE_STRICT = false;
 
+  /**
+   * Use HTTP/2 multiplex implementation = {@code false}
+   */
+  public static final boolean DEFAULT_HTTP_2_MULTIPLEX_IMPLEMENTATION = false;
+
   private boolean compressionSupported;
   private int compressionLevel;
   private int compressionContentSizeThreshold;
@@ -239,6 +244,7 @@ public class HttpServerOptions extends NetServerOptions {
   private int http2RstFloodWindowDuration;
   private TimeUnit http2RstFloodWindowDurationTimeUnit;
   private boolean strictThreadMode;
+  private boolean http2MultiplexImplementation;
 
   /**
    * Default constructor
@@ -289,6 +295,7 @@ public HttpServerOptions(HttpServerOptions other) {
     this.http2RstFloodWindowDuration = other.http2RstFloodWindowDuration;
     this.http2RstFloodWindowDurationTimeUnit = other.http2RstFloodWindowDurationTimeUnit;
     this.strictThreadMode = other.strictThreadMode;
+    this.http2MultiplexImplementation = other.http2MultiplexImplementation;
   }
 
   /**
@@ -346,6 +353,7 @@ private void init() {
     http2RstFloodMaxRstFramePerWindow = DEFAULT_HTTP2_RST_FLOOD_MAX_RST_FRAME_PER_WINDOW;
     http2RstFloodWindowDuration = DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION;
     http2RstFloodWindowDurationTimeUnit = DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION_TIME_UNIT;
+    http2MultiplexImplementation = DEFAULT_HTTP_2_MULTIPLEX_IMPLEMENTATION;
   }
 
   /**
@@ -1285,4 +1293,22 @@ public HttpServerOptions setStrictThreadMode(boolean strictThreadMode) {
     this.strictThreadMode = strictThreadMode;
     return this;
   }
+
+  /**
+   * @return whether to use the HTTP/2 implementation based on multiplexed channel
+   */
+  public boolean getHttp2MultiplexImplementation() {
+    return http2MultiplexImplementation;
+  }
+
+  /**
+   * Set which HTTP/2 implementation to use
+   *
+   * @param http2MultiplexImplementation whether to use the HTTP/2 multiplex implementation
+   * @return a reference to this, so the API can be used fluently
+   */
+  public HttpServerOptions setHttp2MultiplexImplementation(boolean http2MultiplexImplementation) {
+    this.http2MultiplexImplementation = http2MultiplexImplementation;
+    return this;
+  }
 }

vertx-core/src/main/java/io/vertx/core/http/impl/CleanableHttpClient.java

@@ -12,7 +12,13 @@
 
 import io.vertx.core.Completable;
 import io.vertx.core.Future;
-import io.vertx.core.http.*;
+import io.vertx.core.http.HttpClient;
+import io.vertx.core.http.HttpClientConnection;
+import io.vertx.core.http.HttpClientOptions;
+import io.vertx.core.http.HttpClientRequest;
+import io.vertx.core.http.HttpClientResponse;
+import io.vertx.core.http.HttpConnectOptions;
+import io.vertx.core.http.RequestOptions;
 import io.vertx.core.internal.VertxInternal;
 import io.vertx.core.internal.http.HttpClientInternal;
 import io.vertx.core.net.ClientSSLOptions;

vertx-core/src/main/java/io/vertx/core/http/impl/CompressionManager.java

@@ -0,0 +1,85 @@
+/*
+ * 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.impl;
+
+import io.netty.handler.codec.Headers;
+import io.netty.handler.codec.compression.CompressionOptions;
+import io.netty.handler.codec.http.HttpContentCompressor;
+import io.netty.handler.codec.http.HttpHeaderNames;
+
+import static io.vertx.core.http.HttpHeaders.CONTENT_ENCODING;
+import static io.vertx.core.http.HttpHeaders.IDENTITY;
+
+/**
+ *
+ */
+public class CompressionManager {
+
+  private final EncodingDetector encodingDetector;
+  private final CompressionOptions[] options;
+
+  public CompressionManager(int contentSizeThreshold, CompressionOptions[] options) {
+    this.options = options;
+    this.encodingDetector = new EncodingDetector(contentSizeThreshold, options);
+  }
+
+  public CompressionOptions[] options() {
+    return options;
+  }
+
+  public String determineEncoding(String acceptEncoding) {
+    return encodingDetector.determineEncoding(acceptEncoding);
+  }
+
+  /**
+   * Set the {@code responseHeaders} content-encoding header.
+   *
+   * @param requestHeaders
+   * @param responseHeaders
+   */
+  public void setContentEncoding(Headers<CharSequence, CharSequence, ?> requestHeaders, Headers<CharSequence, CharSequence, ?> responseHeaders) {
+    String contentEncodingToApply = determineContentEncodingToApply(requestHeaders, responseHeaders);
+    if (contentEncodingToApply == null || contentEncodingToApply.equalsIgnoreCase(IDENTITY.toString())) {
+      if (responseHeaders.contains(CONTENT_ENCODING, IDENTITY)) {
+        responseHeaders.remove(CONTENT_ENCODING);
+      }
+    } else {
+      responseHeaders.set(CONTENT_ENCODING, contentEncodingToApply);
+    }
+  }
+
+  private String determineContentEncodingToApply(Headers<CharSequence, CharSequence, ?> requestHeaders, Headers<CharSequence, CharSequence, ?> responseHeaders) {
+    if (responseHeaders.contains(CONTENT_ENCODING)) {
+      return null;
+    }
+    return determineContentEncoding(requestHeaders);
+  }
+
+  private String determineContentEncoding(Headers<CharSequence, CharSequence, ?> headers) {
+    String acceptEncoding = headers.get(HttpHeaderNames.ACCEPT_ENCODING) != null ? headers.get(HttpHeaderNames.ACCEPT_ENCODING).toString() : null;
+    if (acceptEncoding != null) {
+      return determineEncoding(acceptEncoding);
+    }
+    return null;
+  }
+
+  private static class EncodingDetector extends HttpContentCompressor {
+
+    private EncodingDetector(int contentSizeThreshold, CompressionOptions[] compressionOptions) {
+      super(contentSizeThreshold, compressionOptions);
+    }
+
+    @Override
+    protected String determineEncoding(String acceptEncoding) {
+      return super.determineEncoding(acceptEncoding);
+    }
+  }
+}