Adapt to context internal changes

vietj · vietj · commit 167d208f7202 · 2023-09-18T14:38:59.000+02:00
diff --git a/vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2ConnectionFactory.java b/vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2ConnectionFactory.java
@@ -19,7 +19,6 @@
 import io.vertx.core.Future;
 import io.vertx.core.Promise;
 import io.vertx.core.impl.ContextInternal;
-import io.vertx.core.impl.EventLoopContext;
 import io.vertx.core.impl.VertxInternal;
 import io.vertx.core.net.NetClient;
 import io.vertx.core.net.SocketAddress;
@@ -43,7 +42,7 @@ public DB2ConnectionFactory(VertxInternal vertx, Supplier<? extends Future<? ext
   }
 
   @Override
-  protected Future<Connection> doConnectInternal(SqlConnectOptions options, EventLoopContext context) {
+  protected Future<Connection> doConnectInternal(SqlConnectOptions options, ContextInternal context) {
     DB2ConnectOptions db2Options = DB2ConnectOptions.wrap(options);
     SocketAddress server = options.getSocketAddress();
     boolean cachePreparedStatements = options.getCachePreparedStatements();
diff --git a/vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2SocketConnection.java b/vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2SocketConnection.java
@@ -22,7 +22,7 @@
 import io.vertx.core.AsyncResult;
 import io.vertx.core.Handler;
 import io.vertx.core.Promise;
-import io.vertx.core.impl.EventLoopContext;
+import io.vertx.core.impl.ContextInternal;
 import io.vertx.core.net.impl.NetSocketInternal;
 import io.vertx.core.spi.metrics.ClientMetrics;
 import io.vertx.db2client.DB2ConnectOptions;
@@ -54,7 +54,7 @@ public DB2SocketConnection(NetSocketInternal socket,
       int preparedStatementCacheSize,
       Predicate<String> preparedStatementCacheSqlFilter,
       int pipeliningLimit,
-      EventLoopContext context) {
+                             ContextInternal context) {
     super(socket, clientMetrics, cachePreparedStatements, preparedStatementCacheSize, preparedStatementCacheSqlFilter, pipeliningLimit, context);
     this.connectOptions = connectOptions;
   }
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLConnectionFactory.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLConnectionFactory.java
@@ -15,7 +15,6 @@
 import io.vertx.core.Future;
 import io.vertx.core.Promise;
 import io.vertx.core.impl.ContextInternal;
-import io.vertx.core.impl.EventLoopContext;
 import io.vertx.core.impl.VertxInternal;
 import io.vertx.core.net.NetClient;
 import io.vertx.core.net.NetClientOptions;
@@ -42,11 +41,11 @@ public MSSQLConnectionFactory(VertxInternal vertx, Supplier<? extends Future<? e
   }
 
   @Override
-  protected Future<Connection> doConnectInternal(SqlConnectOptions options, EventLoopContext context) {
+  protected Future<Connection> doConnectInternal(SqlConnectOptions options, ContextInternal context) {
     return connectOrRedirect(MSSQLConnectOptions.wrap(options), context, 0);
   }
 
-  private Future<Connection> connectOrRedirect(MSSQLConnectOptions options, EventLoopContext context, int redirections) {
+  private Future<Connection> connectOrRedirect(MSSQLConnectOptions options, ContextInternal context, int redirections) {
     if (redirections > 1) {
       return context.failedFuture("The client can be redirected only once");
     }
@@ -72,15 +71,15 @@ private Future<Connection> connectOrRedirect(MSSQLConnectOptions options, EventL
       });
   }
 
-  private MSSQLSocketConnection createSocketConnection(NetSocket so, MSSQLConnectOptions options, int desiredPacketSize, EventLoopContext context) {
+  private MSSQLSocketConnection createSocketConnection(NetSocket so, MSSQLConnectOptions options, int desiredPacketSize, ContextInternal context) {
     VertxMetrics vertxMetrics = vertx.metricsSPI();
     ClientMetrics metrics = vertxMetrics != null ? vertxMetrics.createClientMetrics(options.getSocketAddress(), "sql", options.getMetricsName()) : null;
     MSSQLSocketConnection conn = new MSSQLSocketConnection((NetSocketInternal) so, metrics, options, desiredPacketSize, false, 0, sql -> true, 1, context);
     conn.init();
     return conn;
   }
 
-  private Future<Connection> login(MSSQLSocketConnection conn, MSSQLConnectOptions options, Byte encryptionLevel, EventLoopContext context) {
+  private Future<Connection> login(MSSQLSocketConnection conn, MSSQLConnectOptions options, Byte encryptionLevel, ContextInternal context) {
     boolean clientSslConfig = options.isSsl();
     if (clientSslConfig && encryptionLevel != ENCRYPT_ON && encryptionLevel != ENCRYPT_REQ) {
       Promise<Void> closePromise = context.promise();
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLSocketConnection.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLSocketConnection.java
@@ -17,7 +17,7 @@
 import io.vertx.core.AsyncResult;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
-import io.vertx.core.impl.EventLoopContext;
+import io.vertx.core.impl.ContextInternal;
 import io.vertx.core.impl.future.PromiseInternal;
 import io.vertx.core.net.SocketAddress;
 import io.vertx.core.net.impl.NetSocketInternal;
@@ -59,7 +59,7 @@ public class MSSQLSocketConnection extends SocketConnectionBase {
                         int preparedStatementCacheSize,
                         Predicate<String> preparedStatementCacheSqlFilter,
                         int pipeliningLimit,
-                        EventLoopContext context) {
+                        ContextInternal context) {
     super(socket, clientMetrics, cachePreparedStatements, preparedStatementCacheSize, preparedStatementCacheSqlFilter, pipeliningLimit, context);
     this.connectOptions = connectOptions;
     this.packetSize = packetSize;
diff --git a/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/MySQLConnectionFactory.java b/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/MySQLConnectionFactory.java
@@ -16,7 +16,6 @@
 import io.vertx.core.Promise;
 import io.vertx.core.buffer.Buffer;
 import io.vertx.core.impl.ContextInternal;
-import io.vertx.core.impl.EventLoopContext;
 import io.vertx.core.impl.VertxInternal;
 import io.vertx.core.net.NetClientOptions;
 import io.vertx.core.net.NetSocket;
@@ -47,7 +46,7 @@ public MySQLConnectionFactory(VertxInternal vertx, Supplier<? extends Future<? e
   }
 
   @Override
-  protected Future<Connection> doConnectInternal(SqlConnectOptions options, EventLoopContext context) {
+  protected Future<Connection> doConnectInternal(SqlConnectOptions options, ContextInternal context) {
     MySQLConnectOptions mySQLOptions = MySQLConnectOptions.wrap(options);
     SslMode sslMode = mySQLOptions.isUsingDomainSocket() ? SslMode.DISABLED : mySQLOptions.getSslMode();
     switch (sslMode) {
@@ -86,7 +85,7 @@ private int capabilitiesFlags(MySQLConnectOptions options) {
     return capabilitiesFlags;
   }
 
-  private Future<Connection> doConnect(MySQLConnectOptions options, SslMode sslMode, int initialCapabilitiesFlags, EventLoopContext context) {
+  private Future<Connection> doConnect(MySQLConnectOptions options, SslMode sslMode, int initialCapabilitiesFlags, ContextInternal context) {
     String username = options.getUser();
     String password = options.getPassword();
     String database = options.getDatabase();
diff --git a/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/MySQLSocketConnection.java b/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/MySQLSocketConnection.java
@@ -22,7 +22,7 @@
 import io.vertx.core.Handler;
 import io.vertx.core.Promise;
 import io.vertx.core.buffer.Buffer;
-import io.vertx.core.impl.EventLoopContext;
+import io.vertx.core.impl.ContextInternal;
 import io.vertx.core.net.impl.NetSocketInternal;
 import io.vertx.core.spi.metrics.ClientMetrics;
 import io.vertx.mysqlclient.MySQLAuthenticationPlugin;
@@ -61,7 +61,7 @@ public MySQLSocketConnection(NetSocketInternal socket,
                                int preparedStatementCacheSize,
                                Predicate<String> preparedStatementCacheSqlFilter,
                                int pipeliningLimit,
-                               EventLoopContext context) {
+                               ContextInternal context) {
     super(socket, clientMetrics, cachePreparedStatements, preparedStatementCacheSize, preparedStatementCacheSqlFilter, pipeliningLimit, context);
     this.connectOptions = connectOptions;
   }
diff --git a/vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgConnectionFactory.java b/vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgConnectionFactory.java
@@ -22,7 +22,6 @@
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
 import io.vertx.core.impl.ContextInternal;
-import io.vertx.core.impl.EventLoopContext;
 import io.vertx.core.impl.VertxInternal;
 import io.vertx.core.impl.future.PromiseInternal;
 import io.vertx.core.net.NetSocket;
@@ -69,7 +68,7 @@ private void checkSslMode(PgConnectOptions options) {
   }
 
   @Override
-  protected Future<Connection> doConnectInternal(SqlConnectOptions options, EventLoopContext context) {
+  protected Future<Connection> doConnectInternal(SqlConnectOptions options, ContextInternal context) {
     PgConnectOptions pgOptions = PgConnectOptions.wrap(options);
     try {
       checkSslMode(pgOptions);
@@ -100,7 +99,7 @@ public void cancelRequest(PgConnectOptions options, int processId, int secretKey
     });
   }
 
-  private Future<Connection> doConnect(SocketAddress server, EventLoopContext context, PgConnectOptions options) {
+  private Future<Connection> doConnect(SocketAddress server, ContextInternal context, PgConnectOptions options) {
     SslMode sslMode = options.isUsingDomainSocket() ? SslMode.DISABLE : options.getSslMode();
     Future<Connection> connFuture;
     switch (sslMode) {
@@ -124,7 +123,7 @@ private Future<Connection> doConnect(SocketAddress server, EventLoopContext cont
     return connFuture;
   }
 
-  private Future<Connection> doConnect(SocketAddress server, EventLoopContext context, boolean ssl, PgConnectOptions options) {
+  private Future<Connection> doConnect(SocketAddress server, ContextInternal context, boolean ssl, PgConnectOptions options) {
     Future<NetSocket> soFut;
     try {
       soFut = netClient(options).connect(server, (String) null);
@@ -166,7 +165,7 @@ public Future<SqlConnection> connect(Context context, SqlConnectOptions options)
     return promise.future();
   }
 
-  private PgSocketConnection newSocketConnection(EventLoopContext context, NetSocketInternal socket, PgConnectOptions options) {
+  private PgSocketConnection newSocketConnection(ContextInternal context, NetSocketInternal socket, PgConnectOptions options) {
     boolean cachePreparedStatements = options.getCachePreparedStatements();
     int preparedStatementCacheMaxSize = options.getPreparedStatementCacheMaxSize();
     Predicate<String> preparedStatementCacheSqlFilter = options.getPreparedStatementCacheSqlFilter();
diff --git a/vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgSocketConnection.java b/vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgSocketConnection.java
@@ -24,7 +24,7 @@
 import io.vertx.core.Handler;
 import io.vertx.core.Promise;
 import io.vertx.core.buffer.Buffer;
-import io.vertx.core.impl.EventLoopContext;
+import io.vertx.core.impl.ContextInternal;
 import io.vertx.core.net.impl.NetSocketInternal;
 import io.vertx.core.spi.metrics.ClientMetrics;
 import io.vertx.pgclient.PgConnectOptions;
@@ -66,7 +66,7 @@ public PgSocketConnection(NetSocketInternal socket,
                             Predicate<String> preparedStatementCacheSqlFilter,
                             int pipeliningLimit,
                             boolean useLayer7Proxy,
-                            EventLoopContext context) {
+                            ContextInternal context) {
     super(socket, metrics, cachePreparedStatements, preparedStatementCacheSize, preparedStatementCacheSqlFilter, pipeliningLimit, context);
     this.connectOptions = connectOptions;
     this.useLayer7Proxy = useLayer7Proxy;
diff --git a/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/ConnectionFactoryBase.java b/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/ConnectionFactoryBase.java
@@ -15,7 +15,6 @@
 import io.vertx.core.Promise;
 import io.vertx.core.impl.CloseFuture;
 import io.vertx.core.impl.ContextInternal;
-import io.vertx.core.impl.EventLoopContext;
 import io.vertx.core.impl.VertxInternal;
 import io.vertx.core.impl.future.PromiseInternal;
 import io.vertx.core.json.JsonObject;
@@ -71,15 +70,15 @@ protected NetClient netClient(NetClientOptions options) {
     return client;
   }
 
-  public static EventLoopContext asEventLoopContext(ContextInternal ctx) {
-    if (ctx instanceof EventLoopContext) {
-      return (EventLoopContext) ctx;
+  public static ContextInternal asEventLoopContext(ContextInternal ctx) {
+    if (ctx.isEventLoopContext()) {
+      return ctx;
     } else {
       return ctx.owner().createEventLoopContext(ctx.nettyEventLoop(), ctx.workerPool(), ctx.classLoader());
     }
   }
 
-  public Future<Connection> connect(EventLoopContext context, SqlConnectOptions options) {
+  public Future<Connection> connect(ContextInternal context, SqlConnectOptions options) {
     PromiseInternal<Connection> promise = context.promise();
     context.emit(promise, p -> doConnectWithRetry(options, p, options.getReconnectAttempts()));
     return promise.future();
@@ -96,7 +95,7 @@ public void close(Promise<Void> promise) {
   }
 
   private void doConnectWithRetry(SqlConnectOptions options, PromiseInternal<Connection> promise, int remainingAttempts) {
-    EventLoopContext ctx = (EventLoopContext) promise.context();
+    ContextInternal ctx = promise.context();
     doConnectInternal(options, ctx).onComplete(ar -> {
       if (ar.succeeded()) {
         promise.complete(ar.result());
@@ -115,6 +114,6 @@ private void doConnectWithRetry(SqlConnectOptions options, PromiseInternal<Conne
   /**
    * Establish a connection to the server.
    */
-  protected abstract Future<Connection> doConnectInternal(SqlConnectOptions options, EventLoopContext context);
+  protected abstract Future<Connection> doConnectInternal(SqlConnectOptions options, ContextInternal context);
 
 }
diff --git a/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/SocketConnectionBase.java b/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/SocketConnectionBase.java
@@ -29,7 +29,6 @@
 import io.vertx.core.Vertx;
 import io.vertx.core.VertxException;
 import io.vertx.core.impl.ContextInternal;
-import io.vertx.core.impl.EventLoopContext;
 import io.vertx.core.impl.NoStackTraceThrowable;
 import io.vertx.core.impl.logging.Logger;
 import io.vertx.core.impl.logging.LoggerFactory;
@@ -64,7 +63,7 @@ public enum Status {
 
   private final ClientMetrics metrics;
   protected final PreparedStatementCache psCache;
-  protected final EventLoopContext context;
+  protected final ContextInternal context;
   private final Predicate<String> preparedStatementCacheSqlFilter;
   private Holder holder;
   private final int pipeliningLimit;
@@ -84,7 +83,7 @@ public SocketConnectionBase(NetSocketInternal socket,
                               int preparedStatementCacheSize,
                               Predicate<String> preparedStatementCacheSqlFilter,
                               int pipeliningLimit,
-                              EventLoopContext context) {
+                              ContextInternal context) {
     this.socket = socket;
     this.context = context;
     this.pipeliningLimit = pipeliningLimit;
diff --git a/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/pool/SqlConnectionPool.java b/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/pool/SqlConnectionPool.java
@@ -14,7 +14,6 @@
 import io.netty.channel.EventLoop;
 import io.vertx.core.*;
 import io.vertx.core.impl.ContextInternal;
-import io.vertx.core.impl.EventLoopContext;
 import io.vertx.core.impl.VertxInternal;
 import io.vertx.core.net.SocketAddress;
 import io.vertx.core.net.impl.ConnectionBase;
@@ -89,11 +88,11 @@ public SqlConnectionPool(Function<Context, Future<SqlConnection>> connectionProv
       for (int i = 0; i < eventLoopSize; i++) {
         loops[i] = vertx.nettyEventLoopGroup().next();
       }
-      pool.contextProvider(new Function<ContextInternal, EventLoopContext>() {
+      pool.contextProvider(new Function<ContextInternal, ContextInternal>() {
         int idx = 0;
 
         @Override
-        public EventLoopContext apply(ContextInternal contextInternal) {
+        public ContextInternal apply(ContextInternal contextInternal) {
           EventLoop loop = loops[idx++];
           if (idx == loops.length) {
             idx = 0;
@@ -108,7 +107,7 @@ public EventLoopContext apply(ContextInternal contextInternal) {
 
   private final PoolConnector<PooledConnection> connector = new PoolConnector<PooledConnection>() {
     @Override
-    public void connect(EventLoopContext context, PoolConnector.Listener listener, Handler<AsyncResult<ConnectResult<PooledConnection>>> handler) {
+    public void connect(ContextInternal context, PoolConnector.Listener listener, Handler<AsyncResult<ConnectResult<PooledConnection>>> handler) {
       Future<SqlConnection> future = connectionProvider.apply(context);
       future.onComplete(ar -> {
         if (ar.succeeded()) {
