Update documentation

Author: vietj

vertx-db2-client/src/main/java/examples/SqlClientExamples.java

@@ -407,15 +407,11 @@ public static void poolSharing3(Vertx vertx, DB2ConnectOptions database, int max
       .setEventLoopSize(4));
   }
 
-  public void dynamicPoolConfig(Vertx vertx, DB2Pool pool) {
-    pool.connectionProvider(ctx -> {
-      Future<DB2ConnectOptions> fut = retrieveOptions();
-      return fut.compose(connectOptions -> {
-        // Do not forget to close later
-        ConnectionFactory factory = DB2Driver.INSTANCE.createConnectionFactory(vertx, connectOptions);
-        return factory.connect(ctx);
-      });
-    });
+  public void dynamicPoolConfig(Vertx vertx, PoolOptions poolOptions) {
+    DB2Pool pool = DB2Pool.pool(vertx, () -> {
+      Future<DB2ConnectOptions> connectOptions = retrieveOptions();
+      return connectOptions;
+    }, poolOptions);
   }
 
   private Future<DB2ConnectOptions> retrieveOptions() {

vertx-db2-client/src/main/java/io/vertx/db2client/DB2Pool.java

@@ -16,6 +16,7 @@
 package io.vertx.db2client;
 
 import io.vertx.codegen.annotations.Fluent;
+import io.vertx.codegen.annotations.GenIgnore;
 import io.vertx.codegen.annotations.VertxGen;
 import io.vertx.core.Context;
 import io.vertx.core.Future;
@@ -31,6 +32,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 import static io.vertx.db2client.DB2ConnectOptions.fromUri;
 
@@ -109,6 +111,28 @@ static DB2Pool pool(Vertx vertx, List<DB2ConnectOptions> databases, PoolOptions
     return (DB2Pool) DB2Driver.INSTANCE.createPool(vertx, databases, options);
   }
 
+  /**
+   * Create a connection pool to the DB2 {@code databases}. The supplier is called
+   * to provide the options when a new connection is created by the pool.
+   *
+   * @param databases the databases supplier
+   * @param poolOptions the options for creating the pool
+   * @return the connection pool
+   */
+  @GenIgnore
+  static DB2Pool pool(Supplier<Future<DB2ConnectOptions>> databases, PoolOptions poolOptions) {
+    return pool(null, databases, poolOptions);
+  }
+
+
+  /**
+   * Like {@link #pool(Supplier, PoolOptions)} with a specific {@link Vertx} instance.
+   */
+  @GenIgnore
+  static DB2Pool pool(Vertx vertx, Supplier<Future<DB2ConnectOptions>> databases, PoolOptions poolOptions) {
+    return (DB2Pool) DB2Driver.INSTANCE.createPool(vertx, databases, poolOptions);
+  }
+
   /**
    * Like {@link #client(String, PoolOptions)} with default options.
    */

vertx-mssql-client/src/main/java/examples/SqlClientExamples.java

@@ -416,15 +416,11 @@ public static void poolSharing3(Vertx vertx, MSSQLConnectOptions database, int m
       .setEventLoopSize(4));
   }
 
-  public void dynamicPoolConfig(Vertx vertx, MSSQLPool pool) {
-    pool.connectionProvider(ctx -> {
-      Future<MSSQLConnectOptions> fut = retrieveOptions();
-      return fut.compose(connectOptions -> {
-        // Do not forget to close later
-        ConnectionFactory factory = MSSQLDriver.INSTANCE.createConnectionFactory(vertx, connectOptions);
-        return factory.connect(ctx);
-      });
-    });
+  public void dynamicPoolConfig(Vertx vertx, PoolOptions poolOptions) {
+    MSSQLPool pool = MSSQLPool.pool(vertx, () -> {
+      Future<MSSQLConnectOptions> connectOptions = retrieveOptions();
+      return connectOptions;
+    }, poolOptions);
   }
 
   private Future<MSSQLConnectOptions> retrieveOptions() {

vertx-mysql-client/src/main/java/examples/SqlClientExamples.java

@@ -387,15 +387,11 @@ public static void poolSharing3(Vertx vertx, MySQLConnectOptions database, int m
       .setEventLoopSize(4));
   }
 
-  public void dynamicPoolConfig(Vertx vertx, MySQLPool pool) {
-    pool.connectionProvider(ctx -> {
-      Future<MySQLConnectOptions> fut = retrieveOptions();
-      return fut.compose(connectOptions -> {
-        // Do not forget to close later
-        ConnectionFactory factory = MySQLDriver.INSTANCE.createConnectionFactory(vertx, connectOptions);
-        return factory.connect(ctx);
-      });
-    });
+  public void dynamicPoolConfig(Vertx vertx, PoolOptions poolOptions) {
+    MySQLPool pool = MySQLPool.pool(vertx, () -> {
+      Future<MySQLConnectOptions> connectOptions = retrieveOptions();
+      return connectOptions;
+    }, poolOptions);
   }
 
   private Future<MySQLConnectOptions> retrieveOptions() {

vertx-oracle-client/src/main/java/examples/SqlClientExamples.java

@@ -22,9 +22,7 @@
 import io.vertx.docgen.Source;
 import io.vertx.oracleclient.OracleConnectOptions;
 import io.vertx.oracleclient.OraclePool;
-import io.vertx.oracleclient.spi.OracleDriver;
 import io.vertx.sqlclient.*;
-import io.vertx.sqlclient.spi.ConnectionFactory;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -338,15 +336,11 @@ public void tracing01(OracleConnectOptions options) {
     options.setTracingPolicy(TracingPolicy.ALWAYS);
   }
 
-  public void dynamicPoolConfig(Vertx vertx, OraclePool pool) {
-    pool.connectionProvider(ctx -> {
-      Future<OracleConnectOptions> fut = retrieveOptions();
-      return fut.compose(connectOptions -> {
-        // Do not forget to close later
-        ConnectionFactory factory = OracleDriver.INSTANCE.createConnectionFactory(vertx, connectOptions);
-        return factory.connect(ctx);
-      });
-    });
+  public void dynamicPoolConfig(Vertx vertx, PoolOptions poolOptions) {
+    OraclePool pool = OraclePool.pool(vertx, () -> {
+      Future<OracleConnectOptions> connectOptions = retrieveOptions();
+      return connectOptions;
+    }, poolOptions);
   }
 
   private Future<OracleConnectOptions> retrieveOptions() {

vertx-oracle-client/src/main/java/io/vertx/oracleclient/OraclePool.java

@@ -10,6 +10,7 @@
  */
 package io.vertx.oracleclient;
 
+import io.vertx.codegen.annotations.GenIgnore;
 import io.vertx.codegen.annotations.VertxGen;
 import io.vertx.core.Context;
 import io.vertx.core.Future;
@@ -22,6 +23,7 @@
 
 import java.util.Collections;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 /**
  * Represents a pool of connection to interact with an Oracle database.
@@ -54,6 +56,28 @@ static OraclePool pool(Vertx vertx, String connectionUri, PoolOptions poolOption
     return pool(vertx, OracleConnectOptions.fromUri(connectionUri), poolOptions);
   }
 
+  /**
+   * Create a connection pool to the Oracle {@code databases}. The supplier is called
+   * to provide the options when a new connection is created by the pool.
+   *
+   * @param databases the databases supplier
+   * @param poolOptions the options for creating the pool
+   * @return the connection pool
+   */
+  @GenIgnore
+  static OraclePool pool(Supplier<Future<OracleConnectOptions>> databases, PoolOptions poolOptions) {
+    return pool(null, databases, poolOptions);
+  }
+
+
+  /**
+   * Like {@link #pool(Supplier, PoolOptions)} with a specific {@link Vertx} instance.
+   */
+  @GenIgnore
+  static OraclePool pool(Vertx vertx, Supplier<Future<OracleConnectOptions>> databases, PoolOptions poolOptions) {
+    return (OraclePool) OracleDriver.INSTANCE.createPool(vertx, databases, poolOptions);
+  }
+
   @Override
   OraclePool connectHandler(Handler<SqlConnection> handler);
 

vertx-pg-client/src/main/java/examples/SqlClientExamples.java

@@ -411,15 +411,11 @@ public static void poolSharing3(Vertx vertx, PgConnectOptions database, int maxS
       .setEventLoopSize(4));
   }
 
-  public void dynamicPoolConfig(Vertx vertx, PgPool pool) {
-    pool.connectionProvider(ctx -> {
-      Future<PgConnectOptions> fut = retrieveOptions();
-      return fut.compose(connectOptions -> {
-        // Do not forget to close later
-        ConnectionFactory factory = PgDriver.INSTANCE.createConnectionFactory(vertx, connectOptions);
-        return factory.connect(ctx);
-      });
-    });
+  public void dynamicPoolConfig(Vertx vertx, PoolOptions poolOptions) {
+    PgPool pool = PgPool.pool(vertx, () -> {
+      Future<PgConnectOptions> connectOptions = retrieveOptions();
+      return connectOptions;
+    }, poolOptions);
   }
 
   private Future<PgConnectOptions> retrieveOptions() {

vertx-sql-client/src/main/asciidoc/pool_config.adoc

@@ -23,17 +23,13 @@ has been created and before it is inserted in the pool.
 
 Once you are done with the connection, you should simply close it to signal the pool to use it.
 
-=== Dynamic connection provider
+=== Dynamic connection configuration
 
-By default, the pool create connections using {@link io.vertx.sqlclient.spi.ConnectionFactory#connect ConnectionFactory#connect}.
+You can configure the pool connection details using a Java supplier instead of an instance of `SqlConnectOptions`.
 
-But you can provide your own implementation in {@link io.vertx.sqlclient.Pool#connectionProvider Pool#connectionProvider}.
-
-Since the provider is asynchronous, it can be used to provide dynamic pool configuration (e.g. password rotation).
+Since the supplier is asynchronous, it can be used to provide dynamic pool configuration (e.g. password rotation).
 
 [source,$lang]
 ----
 {@link examples.SqlClientExamples#dynamicPoolConfig}
 ----
-
-CAUTION: When the connection factory becomes useless (e.g. because of a new configuration) it must be closed to release its resources.

vertx-sql-client/src/main/java/examples/SqlClientExamples.java

@@ -22,7 +22,6 @@
 import io.vertx.core.Vertx;
 import io.vertx.core.tracing.TracingPolicy;
 import io.vertx.sqlclient.*;
-import io.vertx.sqlclient.spi.ConnectionFactory;
 import io.vertx.sqlclient.spi.Driver;
 
 import java.util.ArrayList;
@@ -458,17 +457,5 @@ public static void poolSharing3(Vertx vertx, SqlConnectOptions database, int max
 
 
   public void dynamicPoolConfig(Vertx vertx, Pool pool, Driver driver) {
-    pool.connectionProvider(ctx -> {
-      Future<SqlConnectOptions> fut = retrieveOptions();
-      return fut.compose(connectOptions -> {
-        // Do not forget to close later
-        ConnectionFactory factory = driver.createConnectionFactory(vertx, connectOptions);
-        return factory.connect(ctx);
-      });
-    });
-  }
-
-  private Future<SqlConnectOptions> retrieveOptions() {
-    return null;
   }
 }