HTTP/3 impl

Author: vietj

vertx-core/src/main/java/io/vertx/core/Vertx.java

@@ -229,6 +229,22 @@ default NetClient createNetClient() {
    */
   HttpServer createHttpServer(HttpServerOptions options);
 
+  /**
+   * Create an HTTP3 client using the specified options
+   *
+   * @param options  the options to use
+   * @return the server
+   */
+  HttpClientAgent createHttpClient(Http3ClientOptions options);
+
+  /**
+   * Create an HTTP3 server using the specified options
+   *
+   * @param options  the options to use
+   * @return the server
+   */
+  HttpServer createHttpServer(Http3ServerOptions options);
+
   /**
    * Create an HTTP/HTTPS server using default options
    *

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

@@ -0,0 +1,21 @@
+package io.vertx.core.http;
+
+import io.vertx.codegen.annotations.DataObject;
+import io.vertx.core.net.QLogConfig;
+import io.vertx.core.net.QuicClientOptions;
+
+@DataObject
+public class Http3ClientOptions extends QuicClientOptions {
+
+  public Http3ClientOptions() {
+  }
+
+  public Http3ClientOptions(Http3ClientOptions other) {
+    super(other);
+  }
+
+  @Override
+  public Http3ClientOptions setQLogConfig(QLogConfig qLogConfig) {
+    return (Http3ClientOptions)super.setQLogConfig(qLogConfig);
+  }
+}

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

@@ -0,0 +1,44 @@
+package io.vertx.core.http;
+
+import io.vertx.codegen.annotations.DataObject;
+import io.vertx.core.net.KeyCertOptions;
+import io.vertx.core.net.QLogConfig;
+import io.vertx.core.net.QuicServerOptions;
+
+import java.time.Duration;
+
+@DataObject
+public class Http3ServerOptions extends QuicServerOptions {
+
+  public Http3ServerOptions() {
+  }
+
+  public Http3ServerOptions(Http3ServerOptions other) {
+    super(other);
+  }
+
+  @Override
+  public Http3ServerOptions setQLogConfig(QLogConfig qLogConfig) {
+    return (Http3ServerOptions)super.setQLogConfig(qLogConfig);
+  }
+
+  @Override
+  public Http3ServerOptions setLoadBalanced(boolean loadBalanced) {
+    return (Http3ServerOptions)super.setLoadBalanced(loadBalanced);
+  }
+
+  @Override
+  public Http3ServerOptions setValidateClientAddress(boolean validateClientAddress) {
+    return (Http3ServerOptions)super.setValidateClientAddress(validateClientAddress);
+  }
+
+  @Override
+  public Http3ServerOptions setClientAddressValidationTimeWindow(Duration clientAddressValidationTimeWindow) {
+    return (Http3ServerOptions)super.setClientAddressValidationTimeWindow(clientAddressValidationTimeWindow);
+  }
+
+  @Override
+  public Http3ServerOptions setClientAddressValidationKey(KeyCertOptions validationKey) {
+    return (Http3ServerOptions)super.setClientAddressValidationKey(validationKey);
+  }
+}

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

@@ -0,0 +1,104 @@
+/*
+ * 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.http3.Http3;
+import io.vertx.core.Future;
+import io.vertx.core.Promise;
+import io.vertx.core.http.Http3ClientOptions;
+import io.vertx.core.http.impl.http3.Http3ClientConnection;
+import io.vertx.core.internal.ContextInternal;
+import io.vertx.core.internal.VertxInternal;
+import io.vertx.core.internal.quic.QuicConnectionInternal;
+import io.vertx.core.net.*;
+import io.vertx.core.spi.metrics.ClientMetrics;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class Http3ChannelConnector implements HttpChannelConnector {
+
+  private final VertxInternal vertx;
+  private final Lock lock;
+  private Future<QuicClient> clientFuture;
+  private final Http3ClientOptions options;
+
+  public Http3ChannelConnector(VertxInternal vertxInternal,  Http3ClientOptions options) {
+
+    options = new Http3ClientOptions(options);
+    options.getSslOptions().setApplicationLayerProtocols(Arrays.asList(Http3.supportedApplicationProtocols()));
+    options.getTransportOptions().setInitialMaxData(10000000L);
+    options.getTransportOptions().setInitialMaxStreamDataBidirectionalLocal(1000000L);
+    options.getTransportOptions().setInitialMaxStreamDataBidirectionalRemote(1000000L);
+    options.getTransportOptions().setInitialMaxStreamDataUnidirectional(1000000L);
+    options.getTransportOptions().setInitialMaxStreamsBidirectional(100L);
+    options.getTransportOptions().setInitialMaxStreamsUnidirectional(100L);
+
+    this.vertx = vertxInternal;
+    this.lock = new ReentrantLock();
+    this.options = options;
+  }
+
+  @Override
+  public Future<HttpClientConnection> httpConnect(ContextInternal context, SocketAddress server, HostAndPort authority, HttpConnectParams params, long maxLifetimeMillis, ClientMetrics<?, ?, ?> metrics) {
+
+    lock.lock();
+    Future<QuicClient> fut = clientFuture;
+    if (fut == null) {
+      QuicClient client = QuicClient.create(vertx, this.options);
+      fut = client.bind(SocketAddress.inetSocketAddress(0, "localhost")).map(client);
+      clientFuture = fut;
+      lock.unlock();
+    } else {
+      lock.unlock();
+    }
+    Promise<HttpClientConnection> promise = context.promise();
+
+    fut.onComplete((res, err) -> {
+      if (err == null) {
+        Future<QuicConnection> f = res.connect(server);
+        f.onComplete((res2, err2) -> {
+          if (err2 == null) {
+            Http3ClientConnection c = new Http3ClientConnection((QuicConnectionInternal) res2);
+            c.init();
+            promise.complete(c);
+          } else {
+            promise.fail(err2);
+          }
+        });
+      } else {
+        promise.fail(err);
+      }
+    });
+
+    return promise.future();
+  }
+
+  @Override
+  public Future<Void> shutdown(Duration timeout) {
+    if (clientFuture == null) {
+      return vertx.getOrCreateContext().succeededFuture();
+    } else {
+      return clientFuture.compose(client -> client.shutdown(timeout));
+    }
+  }
+
+  @Override
+  public Future<Void> close() {
+    if (clientFuture == null) {
+      return vertx.getOrCreateContext().succeededFuture();
+    } else {
+      return clientFuture.compose(QuicEndpoint::close);
+    }
+  }
+}

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

@@ -45,14 +45,14 @@
  */
 public class HttpClientImpl extends HttpClientBase implements HttpClientInternal, MetricsProvider {
 
-  static class Config {
-    List<String> nonProxyHosts;
-    boolean verifyHost;
-    boolean defaultSsl;
-    String defaultHost;
-    int defaultPort;
-    int maxRedirects;
-    int initialPoolKind;
+  public static class Config {
+    public List<String> nonProxyHosts;
+    public boolean verifyHost;
+    public boolean defaultSsl;
+    public String defaultHost;
+    public int defaultPort;
+    public int maxRedirects;
+    public int initialPoolKind;
   }
 
   // Pattern to check we are not dealing with an absoluate URI