Have TcpClientImpl implement TcpClient

Author: vietj

vertx-core/src/main/java/io/vertx/core/internal/net/TcpClientInternal.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2011-20123Contributors 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.internal.net;
+
+import io.vertx.core.Closeable;
+import io.vertx.core.Future;
+import io.vertx.core.Promise;
+import io.vertx.core.internal.ContextInternal;
+import io.vertx.core.net.*;
+import io.vertx.core.spi.metrics.MetricsProvider;
+
+/**
+ * Net client internal API.
+ */
+public interface TcpClientInternal extends TcpClient, MetricsProvider, Closeable {
+
+  /**
+   * Open a socket to the {@code remoteAddress} server.
+   *
+   * @param connectOptions the connect options
+   * @param connectHandler the promise to resolve with the connect result
+   * @param context        the socket context
+   */
+  void connectInternal(ConnectOptions connectOptions,
+                       Promise<TcpSocket> connectHandler,
+                       ContextInternal context);
+
+  Future<Void> closeFuture();
+
+}

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

@@ -49,6 +49,6 @@ public NetClientBuilder protocol(String protocol) {
   }
 
   public NetClientInternal build() {
-    return new TcpClientImpl(vertx, config, protocol, sslOptions, registerWriteHandler);
+    return new NetClientImpl(new TcpClientImpl(vertx, config, protocol, sslOptions, registerWriteHandler));
   }
 }

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

@@ -0,0 +1,85 @@
+/*
+ * 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.core.Completable;
+import io.vertx.core.Future;
+import io.vertx.core.Promise;
+import io.vertx.core.internal.ContextInternal;
+import io.vertx.core.internal.net.NetClientInternal;
+import io.vertx.core.net.*;
+import io.vertx.core.spi.metrics.Metrics;
+
+import java.time.Duration;
+
+public class NetClientImpl implements NetClientInternal {
+
+  private TcpClientImpl delegate;
+
+  public NetClientImpl(TcpClientImpl delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public void connectInternal(ConnectOptions connectOptions, Promise<NetSocket> connectHandler, ContextInternal context) {
+    delegate.connectInternal(connectOptions, (Promise)connectHandler, context);
+  }
+
+  @Override
+  public Future<Void> closeFuture() {
+    return delegate.closeFuture();
+  }
+
+  @Override
+  public Future<NetSocket> connect(int port, String host) {
+    return (Future)delegate.connect(port, host);
+  }
+
+  @Override
+  public Future<NetSocket> connect(int port, String host, String serverName) {
+    return (Future)delegate.connect(port, host, serverName);
+  }
+
+  @Override
+  public Future<NetSocket> connect(SocketAddress remoteAddress) {
+    return (Future)delegate.connect(remoteAddress);
+  }
+
+  @Override
+  public Future<NetSocket> connect(SocketAddress remoteAddress, String serverName) {
+    return (Future)delegate.connect(remoteAddress, serverName);
+  }
+
+  @Override
+  public Future<NetSocket> connect(ConnectOptions connectOptions) {
+    return (Future)delegate.connect(connectOptions);
+  }
+
+  @Override
+  public void close(Completable<Void> completion) {
+    delegate.close(completion);
+  }
+
+  @Override
+  public Future<Void> shutdown(Duration timeout) {
+    return delegate.shutdown(timeout);
+  }
+
+  @Override
+  public Future<Boolean> updateSSLOptions(ClientSSLOptions options, boolean force) {
+    return delegate.updateSSLOptions(options, force);
+  }
+
+  @Override
+  public Metrics getMetrics() {
+    return delegate.getMetrics();
+  }
+}

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

@@ -27,6 +27,7 @@
 import io.vertx.core.internal.logging.Logger;
 import io.vertx.core.internal.logging.LoggerFactory;
 import io.vertx.core.internal.net.NetClientInternal;
+import io.vertx.core.internal.net.TcpClientInternal;
 import io.vertx.core.internal.tls.SslContextManager;
 import io.vertx.core.internal.tls.SslContextProvider;
 import io.vertx.core.net.*;
@@ -48,7 +49,7 @@
  * @author <a href="http://tfox.org">Tim Fox</a>
  * @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
  */
-class TcpClientImpl implements NetClientInternal {
+class TcpClientImpl implements TcpClientInternal {
 
   private static final Logger log = LoggerFactory.getLogger(TcpClientImpl.class);
   protected final Duration idleTimeout;
@@ -108,22 +109,22 @@ protected void initChannel(ChannelPipeline pipeline, boolean ssl) {
   }
 
   @Override
-  public Future<NetSocket> connect(int port, String host) {
+  public Future<TcpSocket> connect(int port, String host) {
     return connect(port, host, (String) null);
   }
 
   @Override
-  public Future<NetSocket> connect(int port, String host, String serverName) {
+  public Future<TcpSocket> connect(int port, String host, String serverName) {
     return connect(SocketAddress.inetSocketAddress(port, host), serverName);
   }
 
   @Override
-  public Future<NetSocket> connect(SocketAddress remoteAddress) {
+  public Future<TcpSocket> connect(SocketAddress remoteAddress) {
     return connect(remoteAddress, null);
   }
 
   @Override
-  public Future<NetSocket> connect(SocketAddress remoteAddress, String serverName) {
+  public Future<TcpSocket> connect(SocketAddress remoteAddress, String serverName) {
     ConnectOptions connectOptions = new ConnectOptions();
     connectOptions.setRemoteAddress(remoteAddress);
     String peerHost = remoteAddress.host();
@@ -141,15 +142,15 @@ public Future<NetSocket> connect(SocketAddress remoteAddress, String serverName)
   }
 
   @Override
-  public Future<NetSocket> connect(ConnectOptions connectOptions) {
+  public Future<TcpSocket> connect(ConnectOptions connectOptions) {
     ContextInternal context = vertx.getOrCreateContext();
-    Promise<NetSocket> promise = context.promise();
+    Promise<TcpSocket> promise = context.promise();
     connectInternal(connectOptions, registerWriteHandler, promise, context, config.getReconnectAttempts());
     return promise.future();
   }
 
   @Override
-  public void connectInternal(ConnectOptions connectOptions, Promise<NetSocket> connectHandler, ContextInternal context) {
+  public void connectInternal(ConnectOptions connectOptions, Promise<TcpSocket> connectHandler, ContextInternal context) {
     ClientSSLOptions sslOptions = connectOptions.getSslOptions();
     if (sslOptions == null) {
       connectOptions.setSslOptions(this.sslOptions);
@@ -172,7 +173,6 @@ private void handleClose(Completable<Void> completion) {
     }
   }
 
-  @Override
   public void close(Completable<Void> completion) {
     channelGroup.shutdown(0, TimeUnit.SECONDS).onComplete(completion);
   }
@@ -208,7 +208,7 @@ public Future<Boolean> updateSSLOptions(ClientSSLOptions options, boolean force)
 
   private void connectInternal(ConnectOptions connectOptions,
                                boolean registerWriteHandlers,
-                               Promise<NetSocket> connectHandler,
+                               Promise<TcpSocket> connectHandler,
                                ContextInternal context,
                                int remainingAttempts) {
     if (channelGroup.isStarted()) {
@@ -242,7 +242,7 @@ private void connectInternal2(ConnectOptions connectOptions,
                                 ClientSSLOptions sslOptions,
                                 SslContextProvider sslContextProvider,
                                 boolean registerWriteHandlers,
-                                Promise<NetSocket> connectHandler,
+                                Promise<TcpSocket> connectHandler,
                                 ContextInternal context,
                                 int remainingAttempts) {
     EventLoop eventLoop = context.nettyEventLoop();
@@ -375,7 +375,7 @@ private static SocketAddress peerAddress(SocketAddress remoteAddress, ConnectOpt
   private void connected(ContextInternal context,
                          ClientSSLOptions sslOptions,
                          Channel ch,
-                         Promise<NetSocket> connectHandler,
+                         Promise<TcpSocket> connectHandler,
                          SocketAddress remoteAddress,
                          boolean ssl,
                          boolean registerWriteHandlers) {
@@ -400,7 +400,7 @@ private void connected(ContextInternal context,
     ch.pipeline().addLast("handler", handler);
   }
 
-  private void failed(ContextInternal context, Channel ch, Throwable th, Promise<NetSocket> connectHandler) {
+  private void failed(ContextInternal context, Channel ch, Throwable th, Promise<TcpSocket> connectHandler) {
     if (ch != null) {
       ch.close();
     }