Add QUIC and HTTP/3 transport examples

Signed-off-by: jeroen.veltman <jeroen.veltman@nextend.nl>

Author: veltmanj

rsocket-examples/build.gradle

@@ -18,11 +18,18 @@ plugins {
     id 'java'
 }
 
+def netty_incubator_quic_version = "0.0.73.Final"
+def netty_incubator_http3_version = "0.0.30.Final"
+
 dependencies {
     implementation project(':rsocket-core')
     implementation project(':rsocket-load-balancer')
+    implementation project(':rsocket-transport-h3')
     implementation project(':rsocket-transport-local')
     implementation project(':rsocket-transport-netty')
+    implementation project(':rsocket-transport-quic')
+    implementation "io.netty.incubator:netty-incubator-codec-classes-quic:${netty_incubator_quic_version}"
+    implementation "io.netty.incubator:netty-incubator-codec-http3:${netty_incubator_http3_version}"
 
     implementation "io.micrometer:micrometer-core"
     implementation "io.micrometer:micrometer-tracing"

rsocket-examples/src/main/java/io/rsocket/examples/transport/h3/Http3TransportFactory.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2015-2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.rsocket.examples.transport.h3;
+
+import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
+import io.netty.handler.ssl.util.SelfSignedCertificate;
+import io.netty.incubator.codec.http3.Http3;
+import io.netty.incubator.codec.quic.QuicSslContext;
+import io.netty.incubator.codec.quic.QuicSslContextBuilder;
+import io.rsocket.transport.netty.Http3TransportConfig;
+import io.rsocket.transport.netty.QuicTransportConfig;
+import io.rsocket.transport.netty.client.Http3ClientTransport;
+import io.rsocket.transport.netty.server.Http3ServerTransport;
+import java.net.InetSocketAddress;
+
+public final class Http3TransportFactory {
+
+  private static final String DEFAULT_HOST = "localhost";
+  private static final String DEFAULT_PATH = "/rsocket";
+  private static final SelfSignedCertificate CERTIFICATE = createCertificate();
+  private static final Http3TransportConfig SERVER_CONFIG = createServerConfig();
+  private static final Http3TransportConfig CLIENT_CONFIG = createClientConfig();
+
+  static {
+    Runtime.getRuntime().addShutdownHook(new Thread(CERTIFICATE::delete));
+  }
+
+  private Http3TransportFactory() {}
+
+  public static Http3ClientTransport client(int port) {
+    return client(DEFAULT_HOST, port);
+  }
+
+  public static Http3ClientTransport client(String host, int port) {
+    return Http3ClientTransport.create(host, port).config(CLIENT_CONFIG);
+  }
+
+  public static Http3ClientTransport client(InetSocketAddress address) {
+    return client(address.getHostString(), address.getPort());
+  }
+
+  public static Http3ServerTransport server(int port) {
+    return server(DEFAULT_HOST, port);
+  }
+
+  public static Http3ServerTransport server(String host, int port) {
+    return Http3ServerTransport.create(host, port).config(SERVER_CONFIG);
+  }
+
+  private static SelfSignedCertificate createCertificate() {
+    try {
+      return new SelfSignedCertificate();
+    } catch (Exception e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+
+  private static Http3TransportConfig createServerConfig() {
+    try {
+      QuicSslContext serverSslContext =
+          QuicSslContextBuilder.forServer(
+                  CERTIFICATE.privateKey(), null, CERTIFICATE.certificate())
+              .applicationProtocols(Http3.supportedApplicationProtocols())
+              .build();
+
+      return Http3TransportConfig.builder()
+          .path(DEFAULT_PATH)
+          .quicConfig(QuicTransportConfig.builder().sslContext(serverSslContext).build())
+          .build();
+    } catch (Exception e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+
+  private static Http3TransportConfig createClientConfig() {
+    try {
+      QuicSslContext clientSslContext =
+          QuicSslContextBuilder.forClient()
+              .trustManager(InsecureTrustManagerFactory.INSTANCE)
+              .applicationProtocols(Http3.supportedApplicationProtocols())
+              .build();
+
+      return Http3TransportConfig.builder()
+          .path(DEFAULT_PATH)
+          .quicConfig(
+              QuicTransportConfig.builder()
+                  .sslContext(clientSslContext)
+                  .validateCertificates(false)
+                  .build())
+          .build();
+    } catch (Exception e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+}

rsocket-examples/src/main/java/io/rsocket/examples/transport/h3/channel/ChannelEchoClient.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2015-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.rsocket.examples.transport.h3.channel;
+
+import io.rsocket.Payload;
+import io.rsocket.RSocket;
+import io.rsocket.SocketAcceptor;
+import io.rsocket.core.RSocketConnector;
+import io.rsocket.core.RSocketServer;
+import io.rsocket.examples.transport.h3.Http3TransportFactory;
+import io.rsocket.util.DefaultPayload;
+import java.time.Duration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import reactor.core.publisher.Flux;
+
+public final class ChannelEchoClient {
+
+  private static final Logger logger = LoggerFactory.getLogger(ChannelEchoClient.class);
+
+  public static void main(String[] args) {
+
+    SocketAcceptor echoAcceptor =
+        SocketAcceptor.forRequestChannel(
+            payloads ->
+                Flux.from(payloads)
+                    .map(Payload::getDataUtf8)
+                    .map(s -> "Echo: " + s)
+                    .map(DefaultPayload::create));
+
+    RSocketServer.create(echoAcceptor).bindNow(Http3TransportFactory.server("localhost", 7000));
+
+    RSocket socket =
+        RSocketConnector.connectWith(Http3TransportFactory.client("localhost", 7000)).block();
+
+    socket
+        .requestChannel(
+            Flux.interval(Duration.ofMillis(1000)).map(i -> DefaultPayload.create("Hello")))
+        .map(Payload::getDataUtf8)
+        .doOnNext(logger::debug)
+        .take(10)
+        .doFinally(signalType -> socket.dispose())
+        .then()
+        .block();
+  }
+}

rsocket-examples/src/main/java/io/rsocket/examples/transport/h3/client/RSocketClientExample.java

@@ -0,0 +1,54 @@
+package io.rsocket.examples.transport.h3.client;
+
+import io.rsocket.Payload;
+import io.rsocket.RSocket;
+import io.rsocket.SocketAcceptor;
+import io.rsocket.core.RSocketClient;
+import io.rsocket.core.RSocketConnector;
+import io.rsocket.core.RSocketServer;
+import io.rsocket.examples.transport.h3.Http3TransportFactory;
+import io.rsocket.util.DefaultPayload;
+import java.time.Duration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import reactor.core.publisher.Mono;
+import reactor.util.retry.Retry;
+
+public class RSocketClientExample {
+  static final Logger logger = LoggerFactory.getLogger(RSocketClientExample.class);
+
+  public static void main(String[] args) {
+
+    RSocketServer.create(
+            SocketAcceptor.forRequestResponse(
+                p -> {
+                  String data = p.getDataUtf8();
+                  logger.info("Received request data {}", data);
+
+                  Payload responsePayload = DefaultPayload.create("Echo: " + data);
+                  p.release();
+
+                  return Mono.just(responsePayload);
+                }))
+        .bind(Http3TransportFactory.server("localhost", 7000))
+        .delaySubscription(Duration.ofSeconds(5))
+        .doOnNext(cc -> logger.info("Server started on the address : {}", cc.address()))
+        .block();
+
+    Mono<RSocket> source =
+        RSocketConnector.create()
+            .reconnect(Retry.backoff(50, Duration.ofMillis(500)))
+            .connect(Http3TransportFactory.client("localhost", 7000));
+
+    RSocketClient.from(source)
+        .requestResponse(Mono.just(DefaultPayload.create("Test Request")))
+        .doOnSubscribe(s -> logger.info("Executing Request"))
+        .doOnNext(
+            d -> {
+              logger.info("Received response data {}", d.getDataUtf8());
+              d.release();
+            })
+        .repeat(10)
+        .blockLast();
+  }
+}