Have TcpServerImpl implement TcpServer.

Author: vietj

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,119 @@
+/*
+ * 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 volatile SocketAddress bindAddress;
+  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(addr -> {
+      bindAddress = addr;
+      return 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(addr -> {
+      bindAddress = addr;
+      return this;
+    });
+  }
+
+  @Override
+  public Future<NetServer> listen(SocketAddress localAddress) {
+    return delegate.listen(localAddress)
+      .map(addr -> {
+      bindAddress = addr;
+      return this;
+    });
+  }
+
+  @Override
+  public Future<Void> shutdown(Duration timeout) {
+    return delegate.shutdown(timeout);
+  }
+
+  @Override
+  public int actualPort() {
+    SocketAddress addr = 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;
@@ -406,16 +397,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 +443,6 @@ protected void handleShutdown(Duration timeout, Completable<Void> completion) {
         }
       };
       channelGroup = group;
-      PromiseInternal<Channel> promise = context.promise();
       if (main == null) {
 
         SslContextManager helper;
@@ -508,8 +499,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 +512,11 @@ 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 +526,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);