QuicEndpoint should unbind on context close hook.

Author: vietj

vertx-core/src/main/java/io/vertx/core/net/impl/quic/QuicEndpointImpl.java

@@ -13,11 +13,13 @@
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandler;
 import io.netty.handler.codec.quic.BoringSSLKeylog;
 import io.netty.handler.codec.quic.FlushStrategy;
 import io.netty.handler.codec.quic.QuicCodecBuilder;
 import io.netty.util.internal.PlatformDependent;
+import io.vertx.core.Closeable;
 import io.vertx.core.Completable;
 import io.vertx.core.Future;
 import io.vertx.core.internal.ContextInternal;
@@ -40,12 +42,13 @@
 import java.net.InetSocketAddress;
 import java.time.Duration;
 import java.util.EnumMap;
+import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
 /**
  * @author <a href="mailto:[email protected]">Julien Viet</a>
  */
-public abstract class QuicEndpointImpl implements QuicEndpointInternal, MetricsProvider {
+public abstract class QuicEndpointImpl implements QuicEndpointInternal, MetricsProvider, Closeable {
 
   private static final EnumMap<QuicCongestionControlAlgorithm, io.netty.handler.codec.quic.QuicCongestionControlAlgorithm> CC_MAP = new EnumMap<>(QuicCongestionControlAlgorithm.class);
 
@@ -62,6 +65,7 @@ public abstract class QuicEndpointImpl implements QuicEndpointInternal, MetricsP
   private Channel channel;
   protected ConnectionGroup connectionGroup;
   private FlushStrategy flushStrategy;
+  private ContextInternal context;
 
   public QuicEndpointImpl(VertxInternal vertx, QuicEndpointOptions options) {
 
@@ -95,7 +99,7 @@ public QuicEndpointImpl(VertxInternal vertx, QuicEndpointOptions options) {
     }
 
     this.options = options;
-    this.vertx = vertx;
+    this.vertx = Objects.requireNonNull(vertx);
     this.manager = new SslContextManager(new SSLEngineOptions() {
       @Override
       public SSLEngineOptions copy() {
@@ -183,15 +187,28 @@ protected void handleBind(Channel channel, QuicEndpointMetrics<?, ?> metrics) {
       protected void handleClose(Completable<Void> completion) {
         PromiseInternal<Void> promise = (PromiseInternal<Void>) completion;
         Channel ch = channel;
-        ch.close().addListener(promise);
+        ch.close().addListener((ChannelFutureListener) future -> {
+          ContextInternal ctx;
+          synchronized (QuicEndpointImpl.this) {
+            ctx = context;
+            context = null;
+          }
+          ctx.removeCloseHook(QuicEndpointImpl.this);
+        }).addListener(promise);
       }
     };
   }
 
   @Override
   public Future<Integer> bind(SocketAddress address) {
-    ContextInternal context = vertx.getOrCreateContext();
-    Future<SslContextProvider> f1 = manager.resolveSslContextProvider(options.getSslOptions(), context);
+    ContextInternal current = vertx.getOrCreateContext();
+    synchronized (this) {
+      if (context != null) {
+        return current.failedFuture("Already bound");
+      }
+      context = current;
+    }
+    Future<SslContextProvider> f1 = manager.resolveSslContextProvider(options.getSslOptions(), current);
     return f1.compose(sslContextProvider -> {
       VertxMetrics metricsFactory = vertx.metrics();
       QuicEndpointMetrics<?, ?> metrics;
@@ -200,9 +217,10 @@ public Future<Integer> bind(SocketAddress address) {
       } else {
         metrics = null;
       }
-      return bind(context, address, metrics)
+      return bind(current, address, metrics)
         .map(ch -> {
           handleBind(ch, metrics);
+          context.addCloseHook(this);
           return ((InetSocketAddress)ch.localAddress()).getPort();
         });
     });
@@ -228,4 +246,9 @@ public QuicEndpointInternal flushStrategy(FlushStrategy flushStrategy) {
     this.flushStrategy = flushStrategy;
     return this;
   }
+
+  @Override
+  public void close(Completable<Void> completion) {
+    close().onComplete(completion);
+  }
 }

vertx-core/src/test/java/io/vertx/tests/net/quic/QuicServerTest.java

@@ -16,11 +16,9 @@
 import io.netty.channel.socket.ChannelOutputShutdownException;
 import io.netty.handler.codec.quic.QuicClosedChannelException;
 import io.netty.util.NetUtil;
-import io.vertx.core.Context;
-import io.vertx.core.Future;
-import io.vertx.core.Promise;
-import io.vertx.core.Vertx;
+import io.vertx.core.*;
 import io.vertx.core.buffer.Buffer;
+import io.vertx.core.internal.ContextInternal;
 import io.vertx.core.internal.quic.QuicConnectionInternal;
 import io.vertx.core.net.*;
 import io.vertx.test.core.LinuxOrOsx;
@@ -873,6 +871,22 @@ private void testWriteWhenClosed(boolean write) throws Exception {
     }
   }
 
+  @Test
+  public void testRebind() {
+    Deployable deployable = ctx -> {
+      QuicServer server = QuicServer.create(vertx, serverOptions());
+      server.handler(connection -> {
+
+      });
+      return server.bind(SocketAddress.inetSocketAddress(9999, "localhost"));
+    };
+    int num = 4;
+    for (int i = 0;i < num;i++) {
+      String id = vertx.deployVerticle(deployable).await();
+      vertx.undeploy(id).await();
+    }
+  }
+
   /*  @Test
   public void testSoReuse() throws Exception {