Have TcpServerImpl implement TcpServer.

Author: vietj

vertx-core/src/main/java/io/vertx/core/impl/VertxImpl.java

@@ -45,6 +45,7 @@
 import io.vertx.core.internal.*;
 import io.vertx.core.internal.net.NetClientInternal;
 import io.vertx.core.internal.net.NetServerInternal;
+import io.vertx.core.internal.net.TcpServerInternal;
 import io.vertx.core.internal.resolver.NameResolver;
 import io.vertx.core.internal.threadchecker.BlockedThreadChecker;
 import io.vertx.core.net.*;
@@ -149,7 +150,7 @@ private static ThreadFactory virtualThreadFactory() {
   private final VerticleManager verticleManager;
   private final FileResolver fileResolver;
   private final EventExecutorProvider eventExecutorProvider;
-  private final Map<ServerID, NetServerInternal> sharedNetServers = new HashMap<>();
+  private final Map<ServerID, TcpServerInternal> sharedNetServers = new HashMap<>();
   private final ContextLocal<?>[] contextLocals;
   private final List<ContextLocal<?>> contextLocalsList;
   final WorkerPool workerPool;
@@ -595,7 +596,7 @@ private EventLoop stickyEventLoop() {
     return eventLoop;
   }
 
-  public Map<ServerID, NetServerInternal> sharedTcpServers() {
+  public Map<ServerID, TcpServerInternal> sharedTcpServers() {
     return sharedNetServers;
   }
 

vertx-core/src/main/java/io/vertx/core/internal/VertxInternal.java

@@ -17,6 +17,7 @@
 import io.vertx.core.http.impl.HttpClientBuilderInternal;
 import io.vertx.core.impl.*;
 import io.vertx.core.internal.deployment.DeploymentManager;
+import io.vertx.core.internal.net.TcpServerInternal;
 import io.vertx.core.internal.resolver.NameResolver;
 import io.vertx.core.internal.threadchecker.BlockedThreadChecker;
 import io.vertx.core.net.NetServerOptions;
@@ -130,7 +131,7 @@ default NetServerInternal createNetServer() {
 
   WorkerPool internalWorkerPool();
 
-  Map<ServerID, NetServerInternal> sharedTcpServers();
+  Map<ServerID, TcpServerInternal> sharedTcpServers();
 
   VertxMetrics metrics();
 

vertx-core/src/main/java/io/vertx/core/internal/VertxWrapper.java

@@ -21,6 +21,7 @@
 import io.vertx.core.http.*;
 import io.vertx.core.http.impl.HttpClientBuilderInternal;
 import io.vertx.core.internal.deployment.DeploymentManager;
+import io.vertx.core.internal.net.TcpServerInternal;
 import io.vertx.core.internal.resolver.NameResolver;
 import io.vertx.core.internal.threadchecker.BlockedThreadChecker;
 import io.vertx.core.net.NetClient;
@@ -257,7 +258,7 @@ public WorkerPool internalWorkerPool() {
   }
 
   @Override
-  public Map<ServerID, NetServerInternal> sharedTcpServers() {
+  public Map<ServerID, TcpServerInternal> sharedTcpServers() {
     return delegate.sharedTcpServers();
   }
 

vertx-core/src/main/java/io/vertx/core/net/TcpServer.java

@@ -146,6 +146,14 @@ default Future<Boolean> updateSSLOptions(ServerSSLOptions options) {
     return updateSSLOptions(options, false);
   }
 
+  /**
+   * The socket address the server is listening on. This is useful if you bound the server specifying 0 as port number
+   * signifying an ephemeral port
+   *
+   * @return the server bind address the server is listening on or {@code null}
+   */
+  SocketAddress bindAddress();
+
   /**
    * <p>Update the server with new SSL {@code options}, the update happens if the options object is valid and different
    * from the existing options object.

vertx-core/src/main/java/io/vertx/core/net/impl/tcp/CleanableNetServer.java

@@ -43,7 +43,7 @@ public void close(Completable<Void> completion) {
   }
 
   @Override
-  public Future<NetServer> listen(ContextInternal context, SocketAddress localAddress) {
+  public Future<SocketAddress> listen(ContextInternal context, SocketAddress localAddress) {
     synchronized (this) {
       if (listenContext != null) {
         return context.failedFuture(new IllegalStateException());

vertx-core/src/main/java/io/vertx/core/net/impl/tcp/NetServerBuilder.java

@@ -65,7 +65,7 @@ public NetServerBuilder protocol(String protocol) {
   }
 
   public NetServerInternal build() {
-    NetServerInternal server;
+    TcpServerImpl server;
     if (cleanable) {
       server = new CleanableNetServer(vertx,
         config,
@@ -83,6 +83,6 @@ public NetServerInternal build() {
         registerWriteHandler
       );
     }
-    return server;
+    return new NetServerImpl(server);
   }
 }

vertx-core/src/main/java/io/vertx/core/net/impl/tcp/NetServerImpl.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2011-2026 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.net.impl.tcp;
+
+import io.vertx.codegen.annotations.Nullable;
+import io.vertx.core.Future;
+import io.vertx.core.Handler;
+import io.vertx.core.internal.ContextInternal;
+import io.vertx.core.internal.net.NetServerInternal;
+import io.vertx.core.internal.tls.SslContextProvider;
+import io.vertx.core.net.*;
+import io.vertx.core.spi.metrics.Metrics;
+
+import java.time.Duration;
+
+public class NetServerImpl implements NetServerInternal {
+
+  private Handler<NetSocket> connectHandler;
+  private TcpServerImpl delegate;
+
+  public NetServerImpl(TcpServerImpl delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public NetServerInternal connectHandler(@Nullable Handler<NetSocket> handler) {
+    connectHandler = handler;
+    delegate.connectHandler((Handler)handler);
+    return this;
+  }
+
+  @Override
+  public NetServerInternal exceptionHandler(Handler<Throwable> handler) {
+    delegate.exceptionHandler(handler);
+    return this;
+  }
+
+  @Override
+  public SslContextProvider sslContextProvider() {
+    return delegate.sslContextProvider();
+  }
+
+  @Override
+  public Future<NetServer> listen(ContextInternal context, SocketAddress localAddress) {
+    return delegate.listen(context, localAddress).map(this);
+  }
+
+  @Override
+  public int sniEntrySize() {
+    return delegate.sniEntrySize();
+  }
+
+  @Override
+  public boolean isClosed() {
+    return delegate.isClosed();
+  }
+
+  @Override
+  public Handler<NetSocket> connectHandler() {
+    return connectHandler;
+  }
+
+  @Override
+  public Future<NetServer> listen() {
+    return delegate.listen().map(this);
+  }
+
+  @Override
+  public Future<NetServer> listen(SocketAddress localAddress) {
+    return delegate.listen(localAddress).map(this);
+  }
+
+  @Override
+  public Future<Void> shutdown(Duration timeout) {
+    return delegate.shutdown(timeout);
+  }
+
+  @Override
+  public int actualPort() {
+    SocketAddress addr = delegate.bindAddress();
+    return addr != null ? addr.port() : -1;
+  }
+
+  @Override
+  public Future<Boolean> updateSSLOptions(ServerSSLOptions options, boolean force) {
+    return delegate.updateSSLOptions(options, force);
+  }
+
+  @Override
+  public Future<Boolean> updateTrafficShapingOptions(TrafficShapingOptions options) {
+    return delegate.updateTrafficShapingOptions(options);
+  }
+
+  @Override
+  public Metrics getMetrics() {
+    return delegate.getMetrics();
+  }
+}

vertx-core/src/main/java/io/vertx/core/net/impl/tcp/TcpServerImpl.java

@@ -38,6 +38,7 @@
 import io.vertx.core.internal.net.NetServerInternal;
 import io.vertx.core.internal.net.SslChannelProvider;
 import io.vertx.core.internal.net.SslHandshakeCompletionHandler;
+import io.vertx.core.internal.net.TcpServerInternal;
 import io.vertx.core.internal.resolver.NameResolver;
 import io.vertx.core.internal.tls.SslContextManager;
 import io.vertx.core.internal.tls.SslContextProvider;
@@ -59,7 +60,7 @@
  * @author <a href="http://tfox.org">Tim Fox</a>
  * @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
  */
-public class TcpServerImpl implements NetServerInternal {
+public class TcpServerImpl implements TcpServerInternal {
 
   private static final Logger log = LoggerFactory.getLogger(TcpServerImpl.class);
 
@@ -69,7 +70,7 @@ public class TcpServerImpl implements NetServerInternal {
   private final boolean fileRegionEnabled;
   private final boolean registerWriteHandler;
   private final String protocol;
-  private Handler<NetSocket> handler;
+  private Handler<TcpSocket> handler;
   private Handler<Throwable> exceptionHandler;
 
   // Per server
@@ -114,12 +115,7 @@ public SslContextProvider sslContextProvider() {
   }
 
   @Override
-  public synchronized Handler<NetSocket> connectHandler() {
-    return handler;
-  }
-
-  @Override
-  public synchronized TcpServerImpl connectHandler(Handler<NetSocket> handler) {
+  public synchronized TcpServerImpl connectHandler(Handler<TcpSocket> handler) {
     if (isListening()) {
       throw new IllegalStateException("Cannot set connectHandler when server is listening");
     }
@@ -136,11 +132,6 @@ public synchronized TcpServerImpl exceptionHandler(Handler<Throwable> handler) {
     return this;
   }
 
-  public int actualPort() {
-    TcpServerImpl server = actualServer;
-    return server != null ? server.actualPort : actualPort;
-  }
-
   @Override
   public Future<Void> shutdown(Duration timeout) {
     ConnectionGroup group = channelGroup;
@@ -151,22 +142,22 @@ public Future<Void> shutdown(Duration timeout) {
   }
 
   @Override
-  public Future<NetServer> listen(SocketAddress localAddress) {
+  public Future<SocketAddress> listen(SocketAddress localAddress) {
     return listen(vertx.getOrCreateContext(), localAddress);
   }
 
-  public Future<NetServer> listen(ContextInternal context, SocketAddress localAddress) {
+  public Future<SocketAddress> listen(ContextInternal context, SocketAddress localAddress) {
     if (localAddress == null) {
       throw new NullPointerException("No null bind local address");
     }
     if (handler == null) {
       throw new IllegalStateException("Set connect handler first");
     }
-    return bind(context, localAddress).map(this);
+    return bind(context, localAddress);
   }
 
   @Override
-  public Future<NetServer> listen() {
+  public Future<SocketAddress> listen() {
     return listen(config.getPort(), config.getHost());
   }
 
@@ -177,11 +168,11 @@ public boolean isClosed() {
   private class NetSocketInitializer {
 
     private final ContextInternal context;
-    private final Handler<NetSocket> connectionHandler;
+    private final Handler<TcpSocket> connectionHandler;
     private final Handler<Throwable> exceptionHandler;
     private final GlobalTrafficShapingHandler trafficShapingHandler;
 
-    NetSocketInitializer(ContextInternal context, Handler<NetSocket> connectionHandler, Handler<Throwable> exceptionHandler, GlobalTrafficShapingHandler trafficShapingHandler) {
+    NetSocketInitializer(ContextInternal context, Handler<TcpSocket> connectionHandler, Handler<Throwable> exceptionHandler, GlobalTrafficShapingHandler trafficShapingHandler) {
       this.context = context;
       this.connectionHandler = connectionHandler;
       this.exceptionHandler = exceptionHandler;
@@ -320,6 +311,19 @@ public int sniEntrySize() {
     return sslContextManager.sniEntrySize();
   }
 
+  @Override
+  public SocketAddress bindAddress() {
+    Future<Channel> f = bindFuture;
+    if (f == null) {
+      return null;
+    }
+    Channel ch = f.result();
+    if (ch == null) {
+      return null;
+    }
+    return vertx.transport().convert(ch.localAddress());
+  }
+
   public Future<Boolean> updateSSLOptions(ServerSSLOptions options, boolean force) {
     TcpServerImpl server = actualServer;
     if (server != null && server != this) {
@@ -406,16 +410,17 @@ public void updateTrafficShapingOptions(TrafficShapingOptions options, Promise<B
     }
   }
 
-  private synchronized Future<Channel> bind(ContextInternal context, SocketAddress localAddress) {
+  private synchronized Future<SocketAddress> bind(ContextInternal context, SocketAddress localAddress) {
     if (listening) {
       throw new IllegalStateException("Listen already called");
     }
 
     this.listening = true;
     this.eventLoop = context.nettyEventLoop();
 
+    PromiseInternal<Channel> promise = context.promise();
     SocketAddress bindAddress;
-    Map<ServerID, NetServerInternal> sharedNetServers = vertx.sharedTcpServers();
+    Map<ServerID, TcpServerInternal> sharedNetServers = (Map)vertx.sharedTcpServers();
     synchronized (sharedNetServers) {
       actualPort = localAddress.port();
       String hostOrPath = localAddress.isInetSocket() ? localAddress.host() : localAddress.path();
@@ -451,7 +456,6 @@ protected void handleShutdown(Duration timeout, Completable<Void> completion) {
         }
       };
       channelGroup = group;
-      PromiseInternal<Channel> promise = context.promise();
       if (main == null) {
 
         SslContextManager helper;
@@ -508,8 +512,6 @@ protected void handleShutdown(Duration timeout, Completable<Void> completion) {
           }
           listening = false;
         });
-
-        return bindFuture;
       } else {
         // Server already exists with that host/port - we will use that
         actualServer = main;
@@ -523,9 +525,10 @@ protected void handleShutdown(Duration timeout, Completable<Void> completion) {
         };
         actualServer.channelBalancer.addWorker(eventLoop, worker);
         main.bindFuture.onComplete(promise);
-        return promise.future();
       }
     }
+    return promise.future()
+      .map(ch -> vertx.transport().convert(ch.localAddress()));
   }
 
   private void bind(
@@ -535,7 +538,7 @@ private void bind(
     SocketAddress localAddress,
     boolean shared,
     Promise<Channel> promise,
-    Map<ServerID, NetServerInternal> sharedNetServers,
+    Map<ServerID, TcpServerInternal> sharedNetServers,
     ServerID id) {
     // Socket bind
     channelBalancer.addWorker(eventLoop, worker);
@@ -629,7 +632,7 @@ private void handleShutdown(Completable<Void> completion) {
       completion.succeed();
       return;
     }
-    Map<ServerID, NetServerInternal> servers = vertx.sharedTcpServers();
+    Map<ServerID, TcpServerInternal> servers = vertx.sharedTcpServers();
     boolean hasHandlers;
     synchronized (servers) {
       ServerChannelLoadBalancer balancer = actualServer.channelBalancer;