Rename MultiDb classes

  - MultiClusterPooledConnectionProvider -> MultiDatabaseConnectionProvider
    - Cluster -> Database
  - MultiClusterClientConfig -> MultiDatabaseConfig
    - ClusterConfig -> DatabaseConfig

Author: ggivo

pom.xml

@@ -488,7 +488,7 @@
 						<include>**/Health*.java</include>
 						<include>**/*IT.java</include>
 						<include>**/scenario/RestEndpointUtil.java</include>
-						<include>src/main/java/redis/clients/jedis/MultiClusterClientConfig.java</include>
+						<include>src/main/java/redis/clients/jedis/MultiDatabaseConfig.java</include>
 						<include>src/main/java/redis/clients/jedis/HostAndPort.java</include>
 						<include>**/builders/*.java</include>
 						<include>**/MultiDb*.java</include>

src/main/java/redis/clients/jedis/MultiClusterClientConfig.java renamed to src/main/java/redis/clients/jedis/MultiDatabaseConfig.java

@@ -1,6 +1,6 @@
 package redis.clients.jedis;
 
-import redis.clients.jedis.MultiClusterClientConfig.ClusterConfig;
+import redis.clients.jedis.MultiDatabaseConfig.DatabaseConfig;
 import redis.clients.jedis.annots.Experimental;
 import redis.clients.jedis.builders.MultiDbClientBuilder;
 import redis.clients.jedis.csc.Cache;
@@ -9,7 +9,7 @@
 import redis.clients.jedis.mcf.MultiClusterPipeline;
 import redis.clients.jedis.mcf.MultiClusterTransaction;
 import redis.clients.jedis.providers.ConnectionProvider;
-import redis.clients.jedis.mcf.MultiClusterPooledConnectionProvider;
+import redis.clients.jedis.mcf.MultiDatabaseConnectionProvider;
 
 import java.util.Set;
 
@@ -43,14 +43,14 @@
  *
  * MultiDbClient client = MultiDbClient.builder()
  *                 .multiDbConfig(
- *                         MultiClusterClientConfig.builder()
+ *                         MultiDatabaseConfig.builder()
  *                                 .endpoint(
- *                                         ClusterConfig.builder(
+ *                                         DatabaseConfig.builder(
  *                                                         primary,
  *                                                         DefaultJedisClientConfig.builder().build())
  *                                                 .weight(100.0f)
  *                                                 .build())
- *                                 .endpoint(ClusterConfig.builder(
+ *                                 .endpoint(DatabaseConfig.builder(
  *                                                 secondary,
  *                                                 DefaultJedisClientConfig.builder().build())
  *                                         .weight(50.0f).build())
@@ -76,9 +76,9 @@
  * </p>
  * @author Ivo Gaydazhiev
  * @since 5.2.0
- * @see MultiClusterPooledConnectionProvider
+ * @see MultiDatabaseConnectionProvider
  * @see CircuitBreakerCommandExecutor
- * @see MultiClusterClientConfig
+ * @see MultiDatabaseConfig
  */
 @Experimental
 public class MultiDbClient extends UnifiedJedis {
@@ -91,8 +91,7 @@ public class MultiDbClient extends UnifiedJedis {
    * {@link #builder()} to create instances.
    * </p>
    * @param commandExecutor the command executor (typically CircuitBreakerCommandExecutor)
-   * @param connectionProvider the connection provider (typically
-   *          MultiClusterPooledConnectionProvider)
+   * @param connectionProvider the connection provider (typically MultiDatabaseConnectionProvider)
    * @param commandObjects the command objects
    * @param redisProtocol the Redis protocol version
    * @param cache the client-side cache (may be null)
@@ -103,16 +102,16 @@ public class MultiDbClient extends UnifiedJedis {
   }
 
   /**
-   * Returns the underlying MultiClusterPooledConnectionProvider.
+   * Returns the underlying MultiDatabaseConnectionProvider.
    * <p>
    * This provides access to multi-cluster specific operations like manual failover, health status
    * monitoring, and cluster switch event handling.
    * </p>
    * @return the multi-cluster connection provider
-   * @throws ClassCastException if the provider is not a MultiClusterPooledConnectionProvider
+   * @throws ClassCastException if the provider is not a MultiDatabaseConnectionProvider
    */
-  private MultiClusterPooledConnectionProvider getMultiClusterProvider() {
-    return (MultiClusterPooledConnectionProvider) this.provider;
+  private MultiDatabaseConnectionProvider getMultiDatabaseConnectionProvider() {
+    return (MultiDatabaseConnectionProvider) this.provider;
   }
 
   /**
@@ -124,20 +123,20 @@ private MultiClusterPooledConnectionProvider getMultiClusterProvider() {
    * @param endpoint the endpoint to switch to
    */
   public void setActiveDatabase(Endpoint endpoint) {
-    getMultiClusterProvider().setActiveCluster(endpoint);
+    getMultiDatabaseConnectionProvider().setActiveDatabase(endpoint);
   }
 
   /**
    * Adds a pre-configured cluster configuration.
    * <p>
-   * This method allows adding a fully configured ClusterConfig instance, providing maximum
+   * This method allows adding a fully configured DatabaseConfig instance, providing maximum
    * flexibility for advanced configurations including custom health check strategies, connection
    * pool settings, etc.
    * </p>
-   * @param clusterConfig the pre-configured cluster configuration
+   * @param databaseConfig the pre-configured database configuration
    */
-  public void addEndpoint(ClusterConfig clusterConfig) {
-    getMultiClusterProvider().add(clusterConfig);
+  public void addEndpoint(DatabaseConfig databaseConfig) {
+    getMultiDatabaseConnectionProvider().add(databaseConfig);
   }
 
   /**
@@ -153,10 +152,10 @@ public void addEndpoint(ClusterConfig clusterConfig) {
    * @throws redis.clients.jedis.exceptions.JedisValidationException if the endpoint already exists
    */
   public void addEndpoint(Endpoint endpoint, float weight, JedisClientConfig clientConfig) {
-    ClusterConfig clusterConfig = ClusterConfig.builder(endpoint, clientConfig).weight(weight)
+    DatabaseConfig databaseConfig = DatabaseConfig.builder(endpoint, clientConfig).weight(weight)
         .build();
 
-    getMultiClusterProvider().add(clusterConfig);
+    getMultiDatabaseConnectionProvider().add(databaseConfig);
   }
 
   /**
@@ -167,7 +166,7 @@ public void addEndpoint(Endpoint endpoint, float weight, JedisClientConfig clien
    * @return the set of all configured endpoints
    */
   public Set<Endpoint> getEndpoints() {
-    return getMultiClusterProvider().getEndpoints();
+    return getMultiDatabaseConnectionProvider().getEndpoints();
   }
 
   /**
@@ -179,7 +178,7 @@ public Set<Endpoint> getEndpoints() {
    * @return the health status of the endpoint
    */
   public boolean isHealthy(Endpoint endpoint) {
-    return getMultiClusterProvider().isHealthy(endpoint);
+    return getMultiDatabaseConnectionProvider().isHealthy(endpoint);
   }
 
   /**
@@ -195,7 +194,7 @@ public boolean isHealthy(Endpoint endpoint) {
    *           healthy clusters available
    */
   public void removeEndpoint(Endpoint endpoint) {
-    getMultiClusterProvider().remove(endpoint);
+    getMultiDatabaseConnectionProvider().remove(endpoint);
   }
 
   /**
@@ -211,7 +210,7 @@ public void removeEndpoint(Endpoint endpoint) {
    *           or doesn't exist
    */
   public void forceActiveEndpoint(Endpoint endpoint, long forcedActiveDurationMs) {
-    getMultiClusterProvider().forceActiveCluster(endpoint, forcedActiveDurationMs);
+    getMultiDatabaseConnectionProvider().forceActiveDatabase(endpoint, forcedActiveDurationMs);
   }
 
   /**
@@ -224,7 +223,7 @@ public void forceActiveEndpoint(Endpoint endpoint, long forcedActiveDurationMs)
    */
   @Override
   public MultiClusterPipeline pipelined() {
-    return new MultiClusterPipeline(getMultiClusterProvider(), commandObjects);
+    return new MultiClusterPipeline(getMultiDatabaseConnectionProvider(), commandObjects);
   }
 
   /**
@@ -237,7 +236,7 @@ public MultiClusterPipeline pipelined() {
    */
   @Override
   public MultiClusterTransaction multi() {
-    return new MultiClusterTransaction((MultiClusterPooledConnectionProvider) provider, true,
+    return new MultiClusterTransaction((MultiDatabaseConnectionProvider) provider, true,
         commandObjects);
   }
 
@@ -252,11 +251,12 @@ public MultiClusterTransaction transaction(boolean doMulti) {
           "It is not allowed to create Transaction from this " + getClass());
     }
 
-    return new MultiClusterTransaction(getMultiClusterProvider(), doMulti, commandObjects);
+    return new MultiClusterTransaction(getMultiDatabaseConnectionProvider(), doMulti,
+        commandObjects);
   }
 
   public Endpoint getActiveEndpoint() {
-    return getMultiClusterProvider().getCluster().getEndpoint();
+    return getMultiDatabaseConnectionProvider().getDatabase().getEndpoint();
   }
 
   /**

src/main/java/redis/clients/jedis/MultiDbClient.java

@@ -34,7 +34,7 @@
 import redis.clients.jedis.json.JsonObjectMapper;
 import redis.clients.jedis.mcf.CircuitBreakerCommandExecutor;
 import redis.clients.jedis.mcf.MultiClusterPipeline;
-import redis.clients.jedis.mcf.MultiClusterPooledConnectionProvider;
+import redis.clients.jedis.mcf.MultiDatabaseConnectionProvider;
 import redis.clients.jedis.mcf.MultiClusterTransaction;
 import redis.clients.jedis.params.*;
 import redis.clients.jedis.providers.*;
@@ -240,7 +240,7 @@ public UnifiedJedis(ConnectionProvider provider, int maxAttempts, Duration maxTo
    * <p>
    */
   @Experimental
-  public UnifiedJedis(MultiClusterPooledConnectionProvider provider) {
+  public UnifiedJedis(MultiDatabaseConnectionProvider provider) {
     this(new CircuitBreakerCommandExecutor(provider), provider);
   }
 
@@ -5099,8 +5099,8 @@ public List<Double> tdigestByRevRank(String key, long... ranks) {
   public PipelineBase pipelined() {
     if (provider == null) {
       throw new IllegalStateException("It is not allowed to create Pipeline from this " + getClass());
-    } else if (provider instanceof MultiClusterPooledConnectionProvider) {
-      return new MultiClusterPipeline((MultiClusterPooledConnectionProvider) provider, commandObjects);
+    } else if (provider instanceof MultiDatabaseConnectionProvider) {
+      return new MultiClusterPipeline((MultiDatabaseConnectionProvider) provider, commandObjects);
     } else {
       return new Pipeline(provider.getConnection(), true, commandObjects);
     }
@@ -5120,8 +5120,8 @@ public AbstractTransaction multi() {
   public AbstractTransaction transaction(boolean doMulti) {
     if (provider == null) {
       throw new IllegalStateException("It is not allowed to create Transaction from this " + getClass());
-    } else if (provider instanceof MultiClusterPooledConnectionProvider) {
-      return new MultiClusterTransaction((MultiClusterPooledConnectionProvider) provider, doMulti, commandObjects);
+    } else if (provider instanceof MultiDatabaseConnectionProvider) {
+      return new MultiClusterTransaction((MultiDatabaseConnectionProvider) provider, doMulti, commandObjects);
     } else {
       return new Transaction(provider.getConnection(), doMulti, true, commandObjects);
     }

src/main/java/redis/clients/jedis/UnifiedJedis.java

@@ -2,12 +2,12 @@
 
 import java.util.function.Consumer;
 
-import redis.clients.jedis.MultiClusterClientConfig;
+import redis.clients.jedis.MultiDatabaseConfig;
 import redis.clients.jedis.annots.Experimental;
 import redis.clients.jedis.executors.CommandExecutor;
 import redis.clients.jedis.mcf.CircuitBreakerCommandExecutor;
 import redis.clients.jedis.mcf.ClusterSwitchEventArgs;
-import redis.clients.jedis.mcf.MultiClusterPooledConnectionProvider;
+import redis.clients.jedis.mcf.MultiDatabaseConnectionProvider;
 import redis.clients.jedis.providers.ConnectionProvider;
 
 /**
@@ -38,14 +38,14 @@
  * <pre>
  * MultiDbClient client = MultiDbClient.builder()
  *                 .multiDbConfig(
- *                         MultiClusterClientConfig.builder()
+ *                         MultiDatabaseConfig.builder()
  *                                 .endpoint(
- *                                         ClusterConfig.builder(
+ *                                         DatabaseConfig.builder(
  *                                                         east,
  *                                                         DefaultJedisClientConfig.builder().credentials(credentialsEast).build())
  *                                                 .weight(100.0f)
  *                                                 .build())
- *                                 .endpoint(ClusterConfig.builder(
+ *                                 .endpoint(DatabaseConfig.builder(
  *                                                 west,
  *                                                 DefaultJedisClientConfig.builder().credentials(credentialsWest).build())
  *                                         .weight(50.0f).build())
@@ -67,7 +67,7 @@ public abstract class MultiDbClientBuilder<C>
     extends AbstractClientBuilder<MultiDbClientBuilder<C>, C> {
 
   // Multi-db specific configuration fields
-  private MultiClusterClientConfig multiDbConfig = null;
+  private MultiDatabaseConfig multiDbConfig = null;
   private Consumer<ClusterSwitchEventArgs> databaseSwitchListener = null;
 
   /**
@@ -79,7 +79,7 @@ public abstract class MultiDbClientBuilder<C>
    * @param config the multi-database configuration
    * @return this builder
    */
-  public MultiDbClientBuilder<C> multiDbConfig(MultiClusterClientConfig config) {
+  public MultiDbClientBuilder<C> multiDbConfig(MultiDatabaseConfig config) {
     this.multiDbConfig = config;
     return this;
   }
@@ -107,18 +107,17 @@ protected MultiDbClientBuilder<C> self() {
   @Override
   protected ConnectionProvider createDefaultConnectionProvider() {
 
-    if (this.multiDbConfig == null || this.multiDbConfig.getClusterConfigs() == null
-        || this.multiDbConfig.getClusterConfigs().length < 1) {
+    if (this.multiDbConfig == null || this.multiDbConfig.getDatabaseConfigs() == null
+        || this.multiDbConfig.getDatabaseConfigs().length < 1) {
       throw new IllegalArgumentException("At least one endpoint must be specified");
     }
 
     // Create the multi-cluster connection provider
-    MultiClusterPooledConnectionProvider provider = new MultiClusterPooledConnectionProvider(
-        multiDbConfig);
+    MultiDatabaseConnectionProvider provider = new MultiDatabaseConnectionProvider(multiDbConfig);
 
     // Set database switch listener if provided
     if (this.databaseSwitchListener != null) {
-      provider.setClusterSwitchListener(this.databaseSwitchListener);
+      provider.setDatabaseSwitchListener(this.databaseSwitchListener);
     }
 
     return provider;
@@ -128,7 +127,7 @@ protected ConnectionProvider createDefaultConnectionProvider() {
   protected CommandExecutor createDefaultCommandExecutor() {
     // For multi-db clients, we always use CircuitBreakerCommandExecutor
     return new CircuitBreakerCommandExecutor(
-        (MultiClusterPooledConnectionProvider) this.connectionProvider);
+        (MultiDatabaseConnectionProvider) this.connectionProvider);
   }
 
   @Override

src/main/java/redis/clients/jedis/builders/MultiDbClientBuilder.java

@@ -9,7 +9,7 @@
 import redis.clients.jedis.annots.Experimental;
 import redis.clients.jedis.exceptions.JedisConnectionException;
 import redis.clients.jedis.executors.CommandExecutor;
-import redis.clients.jedis.mcf.MultiClusterPooledConnectionProvider.Cluster;
+import redis.clients.jedis.mcf.MultiDatabaseConnectionProvider.Database;
 
 /**
  * @author Allen Terleto (aterleto)
@@ -24,26 +24,26 @@
 public class CircuitBreakerCommandExecutor extends CircuitBreakerFailoverBase
     implements CommandExecutor {
 
-  public CircuitBreakerCommandExecutor(MultiClusterPooledConnectionProvider provider) {
+  public CircuitBreakerCommandExecutor(MultiDatabaseConnectionProvider provider) {
     super(provider);
   }
 
   @Override
   public <T> T executeCommand(CommandObject<T> commandObject) {
-    Cluster cluster = provider.getCluster(); // Pass this by reference for thread safety
+    Database database = provider.getDatabase(); // Pass this by reference for thread safety
 
     DecorateSupplier<T> supplier = Decorators
-        .ofSupplier(() -> this.handleExecuteCommand(commandObject, cluster));
+        .ofSupplier(() -> this.handleExecuteCommand(commandObject, database));
 
-    supplier.withCircuitBreaker(cluster.getCircuitBreaker());
-    supplier.withRetry(cluster.getRetry());
+    supplier.withCircuitBreaker(database.getCircuitBreaker());
+    supplier.withRetry(database.getRetry());
     supplier.withFallback(provider.getFallbackExceptionList(),
-      e -> this.handleClusterFailover(commandObject, cluster));
+      e -> this.handleClusterFailover(commandObject, database));
     try {
       return supplier.decorate().get();
     } catch (Exception e) {
-      if (cluster.getCircuitBreaker().getState() == State.OPEN && isActiveCluster(cluster)) {
-        clusterFailover(cluster);
+      if (database.getCircuitBreaker().getState() == State.OPEN && isActiveDatabase(database)) {
+        clusterFailover(database);
       }
       throw e;
     }
@@ -52,7 +52,7 @@ public <T> T executeCommand(CommandObject<T> commandObject) {
   /**
    * Functional interface wrapped in retry and circuit breaker logic to handle happy path scenarios
    */
-  private <T> T handleExecuteCommand(CommandObject<T> commandObject, Cluster cluster) {
+  private <T> T handleExecuteCommand(CommandObject<T> commandObject, Database cluster) {
     Connection connection;
     try {
       connection = cluster.getConnection();
@@ -63,7 +63,7 @@ private <T> T handleExecuteCommand(CommandObject<T> commandObject, Cluster clust
     try {
       return connection.executeCommand(commandObject);
     } catch (Exception e) {
-      if (cluster.retryOnFailover() && !isActiveCluster(cluster)
+      if (cluster.retryOnFailover() && !isActiveDatabase(cluster)
           && isCircuitBreakerTrackedException(e, cluster)) {
         throw new ConnectionFailoverException(
             "Command failed during failover: " + cluster.getCircuitBreaker().getName(), e);
@@ -78,7 +78,7 @@ && isCircuitBreakerTrackedException(e, cluster)) {
    * Functional interface wrapped in retry and circuit breaker logic to handle open circuit breaker
    * failure scenarios
    */
-  private <T> T handleClusterFailover(CommandObject<T> commandObject, Cluster cluster) {
+  private <T> T handleClusterFailover(CommandObject<T> commandObject, Database cluster) {
 
     clusterFailover(cluster);