Remove deprecated pool connection provider

vietj · vietj · commit 4819fc1be1cf · 2023-09-23T12:20:55.000+02:00
diff --git a/vertx-db2-client/src/main/java/io/vertx/db2client/spi/DB2Driver.java b/vertx-db2-client/src/main/java/io/vertx/db2client/spi/DB2Driver.java
@@ -63,9 +63,8 @@ public Pool newPool(Vertx vertx, Supplier<Future<DB2ConnectOptions>> databases,
 
   private PoolImpl newPoolImpl(VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<DB2ConnectOptions>> databases, PoolOptions options, NetClientOptions transportOptions, CloseFuture closeFuture) {
     boolean pipelinedPool = options instanceof Db2PoolOptions && ((Db2PoolOptions) options).isPipelined();
-    PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, options, null, null, connectHandler, closeFuture);
     ConnectionFactory<DB2ConnectOptions> factory = createConnectionFactory(vertx, transportOptions);
-    pool.connectionProvider(context -> factory.connect(context, databases.get()));
+    PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, options, null, null, context -> factory.connect(context, databases.get()), connectHandler, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/spi/MSSQLDriver.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/spi/MSSQLDriver.java
@@ -64,9 +64,8 @@ public Pool newPool(Vertx vertx, Supplier<Future<MSSQLConnectOptions>> databases
   }
 
   private PoolImpl newPoolImpl(VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<MSSQLConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, CloseFuture closeFuture) {
-    PoolImpl pool = new PoolImpl(vertx, this, false, poolOptions, null, null, connectHandler, closeFuture);
     ConnectionFactory<MSSQLConnectOptions> factory = createConnectionFactory(vertx, transportOptions);
-    pool.connectionProvider(context -> factory.connect(context, databases.get()));
+    PoolImpl pool = new PoolImpl(vertx, this, false, poolOptions, null, null, context -> factory.connect(context, databases.get()), connectHandler, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;
diff --git a/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/spi/MySQLDriver.java b/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/spi/MySQLDriver.java
@@ -63,9 +63,8 @@ public Pool newPool(Vertx vertx, Supplier<Future<MySQLConnectOptions>> databases
 
   private PoolImpl newPoolImpl(VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<MySQLConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, CloseFuture closeFuture) {
     boolean pipelinedPool = poolOptions instanceof MySQLPoolOptions && ((MySQLPoolOptions) poolOptions).isPipelined();
-    PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, poolOptions, null, null, connectHandler, closeFuture);
     ConnectionFactory<MySQLConnectOptions> factory = createConnectionFactory(vertx, transportOptions);
-    pool.connectionProvider(context -> factory.connect(context, databases.get()));
+    PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, poolOptions, null, null, context -> factory.connect(context, databases.get()), connectHandler, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;
diff --git a/vertx-oracle-client/src/main/java/io/vertx/oracleclient/spi/OracleDriver.java b/vertx-oracle-client/src/main/java/io/vertx/oracleclient/spi/OracleDriver.java
@@ -60,9 +60,8 @@ public Pool newPool(Vertx vertx, Supplier<Future<OracleConnectOptions>> database
   private PoolImpl newPoolImpl(VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<OracleConnectOptions>> databases, PoolOptions options, CloseFuture closeFuture) {
     Function<Connection, Future<Void>> afterAcquire = conn -> ((OracleJdbcConnection) conn).afterAcquire();
     Function<Connection, Future<Void>> beforeRecycle = conn -> ((OracleJdbcConnection) conn).beforeRecycle();
-    PoolImpl pool = new PoolImpl(vertx, this,  false, options, afterAcquire, beforeRecycle, connectHandler, closeFuture);
     ConnectionFactory<OracleConnectOptions> factory = createConnectionFactory(vertx, null);
-    pool.connectionProvider(context -> factory.connect(context, databases.get()));
+    PoolImpl pool = new PoolImpl(vertx, this,  false, options, afterAcquire, beforeRecycle, context -> factory.connect(context, databases.get()), connectHandler, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;
diff --git a/vertx-pg-client/src/main/java/io/vertx/pgclient/spi/PgDriver.java b/vertx-pg-client/src/main/java/io/vertx/pgclient/spi/PgDriver.java
@@ -1,5 +1,6 @@
 package io.vertx.pgclient.spi;
 
+import io.vertx.core.Context;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
 import io.vertx.core.Vertx;
@@ -21,6 +22,7 @@
 import io.vertx.sqlclient.spi.ConnectionFactory;
 import io.vertx.sqlclient.spi.Driver;
 
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 public class PgDriver implements Driver<PgConnectOptions> {
@@ -41,11 +43,10 @@ public Pool newPool(Vertx vertx, Supplier<Future<PgConnectOptions>> databases, P
     return new CloseablePool(vx, closeFuture, pool);
   }
 
-  private PoolImpl newPoolImpl(VertxInternal vertx, Handler<SqlConnection> connectHandler,  Supplier<Future<PgConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, CloseFuture closeFuture) {
+  private PoolImpl newPoolImpl(VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<PgConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, CloseFuture closeFuture) {
     boolean pipelinedPool = poolOptions instanceof PgPoolOptions && ((PgPoolOptions) poolOptions).isPipelined();
-    PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, poolOptions, null, null, connectHandler, closeFuture);
     ConnectionFactory<PgConnectOptions> factory = createConnectionFactory(vertx, transportOptions);
-    pool.connectionProvider(context -> factory.connect(context, databases.get()));
+    PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, poolOptions, null, null, context -> factory.connect(context, databases.get()), connectHandler, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;
diff --git a/vertx-pg-client/src/test/java/io/vertx/pgclient/CloseConnectionTest.java b/vertx-pg-client/src/test/java/io/vertx/pgclient/CloseConnectionTest.java
@@ -1,26 +1,17 @@
 package io.vertx.pgclient;
 
 import io.netty.buffer.ByteBufUtil;
-import io.vertx.core.Context;
-import io.vertx.core.Future;
-import io.vertx.core.Promise;
 import io.vertx.core.Vertx;
 import io.vertx.core.buffer.Buffer;
-import io.vertx.core.net.NetClientOptions;
 import io.vertx.ext.unit.Async;
 import io.vertx.ext.unit.TestContext;
-import io.vertx.pgclient.spi.PgDriver;
 import io.vertx.sqlclient.Pool;
 import io.vertx.sqlclient.PoolOptions;
 import io.vertx.sqlclient.ProxyServer;
-import io.vertx.sqlclient.SqlConnection;
-import io.vertx.sqlclient.spi.ConnectionFactory;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-import java.util.function.Function;
-
 public class CloseConnectionTest extends PgTestBase {
 
   protected Vertx vertx;
@@ -57,25 +48,6 @@ public void testClosePooledConnection(TestContext ctx) {
     });
   }
 
-  @Test
-  public void testCloseNetSocket(TestContext ctx) {
-    testCloseConnection(ctx, () -> {
-      Pool pool = PgBuilder.pool().connectingTo(options).with(new PoolOptions().setMaxSize(1)).using(vertx).build();
-      ConnectionFactory factory = PgDriver.INSTANCE.createConnectionFactory(vertx, new NetClientOptions());
-      pool.connectionProvider(new Function<Context, Future<SqlConnection>>() {
-        @Override
-        public Future<SqlConnection> apply(Context context) {
-          return factory.connect(context, options);
-        }
-      });
-      pool.getConnection().onComplete(ctx.asyncAssertSuccess(conn -> {
-        conn.close().onComplete(ctx.asyncAssertSuccess(v -> {
-          factory.close(Promise.promise());
-        }));
-      }));
-    });
-  }
-
   private void testCloseConnection(TestContext ctx, Runnable test) {
     Async async = ctx.async();
     ProxyServer proxy = ProxyServer.create(vertx, options.getPort(), options.getHost());
diff --git a/vertx-pg-client/src/test/java/io/vertx/pgclient/PgPoolTest.java b/vertx-pg-client/src/test/java/io/vertx/pgclient/PgPoolTest.java
@@ -18,20 +18,16 @@
 package io.vertx.pgclient;
 
 import io.netty.channel.EventLoop;
-import io.vertx.core.Future;
 import io.vertx.core.Handler;
 import io.vertx.core.VertxOptions;
 import io.vertx.core.impl.ContextInternal;
-import io.vertx.core.net.NetClientOptions;
 import io.vertx.ext.unit.Async;
 import io.vertx.ext.unit.TestContext;
 import io.vertx.ext.unit.junit.Repeat;
 import io.vertx.ext.unit.junit.RepeatRule;
 import io.vertx.pgclient.impl.PgSocketConnection;
-import io.vertx.pgclient.spi.PgDriver;
 import io.vertx.sqlclient.*;
 import io.vertx.sqlclient.impl.SqlConnectionInternal;
-import io.vertx.sqlclient.spi.ConnectionFactory;
 import org.junit.Rule;
 import org.junit.Test;
 
@@ -619,48 +615,4 @@ public void testConnectionClosedInHook(TestContext ctx) {
       }));
     }));
   }
-
-  @Test
-  public void testConnectionClosedInProvider1(TestContext ctx) {
-    testConnectionClosedInProvider(ctx, true);
-  }
-
-  @Test
-  public void testConnectionClosedInProvider2(TestContext ctx) {
-    testConnectionClosedInProvider(ctx, false);
-  }
-
-  private void testConnectionClosedInProvider(TestContext ctx, boolean immediately) {
-    Async async = ctx.async(2);
-    ProxyServer proxy = ProxyServer.create(vertx, options.getPort(), options.getHost());
-    AtomicReference<ProxyServer.Connection> proxyConn = new AtomicReference<>();
-    proxy.proxyHandler(conn -> {
-      proxyConn.set(conn);
-      conn.connect();
-    });
-    proxy.listen(8080, "localhost", ctx.asyncAssertSuccess(v1 -> {
-      PgConnectOptions options = new PgConnectOptions(this.options).setPort(8080).setHost("localhost");
-      ConnectionFactory factory = PgDriver.INSTANCE.createConnectionFactory(vertx, new NetClientOptions());
-      Pool pool = createPool(options, new PoolOptions().setMaxSize(1));
-      pool.connectionProvider(context -> {
-        Future<SqlConnection> fut = factory.connect(context, options);
-        if (immediately) {
-          return fut.map(conn -> {
-            conn.close();
-            return conn;
-          });
-        } else {
-          return fut.flatMap(conn -> conn.close().map(conn));
-        }
-      });
-      pool
-        .getConnection()
-        .onComplete(ctx.asyncAssertFailure(conn -> {
-        vertx.runOnContext(v -> {
-          ctx.assertEquals(0, pool.size());
-          async.complete();
-        });
-      }));
-    }));
-  }
 }
diff --git a/vertx-pg-client/src/test/java/io/vertx/pgclient/PoolMultiTest.java b/vertx-pg-client/src/test/java/io/vertx/pgclient/PoolMultiTest.java
@@ -11,6 +11,7 @@
 import io.vertx.pgclient.spi.PgDriver;
 import io.vertx.sqlclient.Pool;
 import io.vertx.sqlclient.PoolOptions;
+import io.vertx.sqlclient.SqlConnectOptions;
 import io.vertx.sqlclient.SqlConnection;
 import io.vertx.sqlclient.spi.ConnectionFactory;
 import org.junit.After;
@@ -24,6 +25,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 import static org.junit.Assert.assertEquals;
 
@@ -55,15 +57,18 @@ public void testListLoadBalancing(TestContext ctx) {
 
   @Test
   public void testAsyncLoadBalancing(TestContext ctx) {
-    Pool pool = PgBuilder.pool().with(new PoolOptions().setMaxSize(5)).using(vertx).build();
-    ConnectionFactory provider = PgDriver.INSTANCE.createConnectionFactory(vertx, new NetClientOptions());
-    pool.connectionProvider(new Function<Context, Future<SqlConnection>>() {
-      int idx = 0;
-      @Override
-      public Future<SqlConnection> apply(Context context) {
-        return provider.connect(context, idx++ % 2 == 0 ? db1.options() : db2.options());
-      }
-    });
+    Pool pool = PgBuilder.pool()
+      .with(new PoolOptions().setMaxSize(5))
+      .connectingTo(new Supplier<Future<SqlConnectOptions>>() {
+        int idx = 0;
+        @Override
+        public Future<SqlConnectOptions> get() {
+          SqlConnectOptions connectOptions = idx++ % 2 == 0 ? db1.options() : db2.options();
+          return Future.succeededFuture(connectOptions);
+        }
+      })
+      .using(vertx)
+      .build();
     testLoadBalancing(ctx, pool);
   }
 
diff --git a/vertx-sql-client/src/main/java/io/vertx/sqlclient/Pool.java b/vertx-sql-client/src/main/java/io/vertx/sqlclient/Pool.java
@@ -22,10 +22,8 @@
 import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 
-import io.vertx.codegen.annotations.Fluent;
 import io.vertx.codegen.annotations.Nullable;
 import io.vertx.codegen.annotations.VertxGen;
-import io.vertx.core.Context;
 import io.vertx.core.Future;
 import io.vertx.core.Vertx;
 import io.vertx.core.impl.ContextInternal;
@@ -35,7 +33,6 @@
 import io.vertx.sqlclient.spi.Driver;
 
 import java.util.function.Function;
-import java.util.function.Supplier;
 
 import static io.vertx.sqlclient.impl.PoolImpl.startPropagatableConnection;
 
@@ -191,20 +188,6 @@ static Pool pool(Vertx vertx, SqlConnectOptions database, PoolOptions options) {
     return getConnection().flatMap(conn -> function.apply(conn).onComplete(ar -> conn.close()));
   }
 
-  /**
-   * Replace the default pool connection provider, the new {@code provider} returns a future connection for a
-   * given {@link Context}.
-   *
-   * <p> A {@link io.vertx.sqlclient.spi.ConnectionFactory} can be used as connection provider.
-   *
-   * @param provider the new connection provider
-   * @return a reference to this, so the API can be used fluently
-   * @deprecated instead use {@link ClientBuilder#connectingTo(Supplier)}
-   */
-  @Deprecated
-  @Fluent
-  Pool connectionProvider(Function<Context, Future<SqlConnection>> provider);
-
   /**
    * @return the current pool size approximation
    */
diff --git a/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/CloseablePool.java b/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/CloseablePool.java
@@ -16,7 +16,6 @@
 package io.vertx.sqlclient.impl;
 
 import io.vertx.codegen.annotations.Nullable;
-import io.vertx.core.Context;
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
 import io.vertx.core.impl.CloseFuture;
@@ -71,12 +70,6 @@ public PreparedQuery<RowSet<Row>> preparedQuery(String sql) {
     return delegate.withTransaction(txPropagation, function);
   }
 
-  @Override
-  public P connectionProvider(Function<Context, Future<SqlConnection>> provider) {
-    delegate.connectionProvider(provider);
-    return (P) this;
-  }
-
   @Override
   public int size() {
     return delegate.size();
diff --git a/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/PoolImpl.java b/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/PoolImpl.java
@@ -29,7 +29,6 @@
 import io.vertx.sqlclient.spi.Driver;
 
 import java.util.function.Function;
-import java.util.function.Supplier;
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 
@@ -49,7 +48,6 @@ public class PoolImpl extends SqlClientBase implements Pool, Closeable {
   private final boolean pipelined;
   private final Handler<SqlConnection> connectionInitializer;
   private long timerID;
-  private volatile Function<Context, Future<SqlConnection>> connectionProvider;
 
   public static final String PROPAGATABLE_CONNECTION = "propagatable_connection";
 
@@ -59,6 +57,7 @@ public PoolImpl(VertxInternal vertx,
                   PoolOptions poolOptions,
                   Function<Connection, Future<Void>> afterAcquire,
                   Function<Connection, Future<Void>> beforeRecycle,
+                  Function<Context, Future<SqlConnection>> connectionProvider,
                   Handler<SqlConnection> connectionInitializer,
                   CloseFuture closeFuture) {
     super(driver);
@@ -72,7 +71,7 @@ public PoolImpl(VertxInternal vertx,
     this.timerID = -1L;
     this.pipelined = pipelined;
     this.vertx = vertx;
-    this.pool = new SqlConnectionPool(ctx -> connectionProvider.apply(ctx), hook, afterAcquire, beforeRecycle, vertx, idleTimeout, maxLifetime, poolOptions.getMaxSize(), pipelined, poolOptions.getMaxWaitQueueSize(), poolOptions.getEventLoopSize());
+    this.pool = new SqlConnectionPool(connectionProvider, hook, afterAcquire, beforeRecycle, vertx, idleTimeout, maxLifetime, poolOptions.getMaxSize(), pipelined, poolOptions.getMaxWaitQueueSize(), poolOptions.getEventLoopSize());
     this.closeFuture = closeFuture;
     this.connectionInitializer = connectionInitializer;
   }
@@ -98,14 +97,6 @@ public Pool init() {
     return this;
   }
 
-  public Pool connectionProvider(Function<Context, Future<SqlConnection>> connectionProvider) {
-    if (connectionProvider == null) {
-      throw new NullPointerException();
-    }
-    this.connectionProvider = connectionProvider;
-    return this;
-  }
-
   private void runEviction() {
     synchronized (this) {
       if (timerID == -1) {
