new params renamed

src/main/java/org/redisson/BaseConfig.java

@@ -54,6 +54,24 @@ class BaseConfig<T extends BaseConfig<T>> {
 
     private int retryInterval = 1000;
 
+    /**
+     * Redis server reconnection attempt timeout.
+     *
+     * On every such timeout event Redisson tries
+     * to connect to disconnected Redis server.
+     *
+     * @see #failedAttempts
+     *
+     */
+    private int reconnectionTimeout = 3000;
+
+    /**
+     * Redis server will be excluded from the list of available slave nodes
+     * when sequential unsuccessful execution attempts of any Redis command
+     * reaches <code>slaveFailedAttempts</code>.
+     */
+    private int failedAttempts = 3;
+
     @Deprecated
     private int closeConnectionAfterFailAttempts = -1;
 
@@ -92,6 +110,8 @@ class BaseConfig<T extends BaseConfig<T>> {
         setRefreshConnectionAfterFails(config.getRefreshConnectionAfterFails());
         setConnectTimeout(config.getConnectTimeout());
         setIdleConnectionTimeout(config.getIdleConnectionTimeout());
+        setFailedAttempts(config.getFailedAttempts());
+        setReconnectionTimeout(config.getReconnectionTimeout());
     }
 
     /**
@@ -257,5 +277,39 @@ class BaseConfig<T extends BaseConfig<T>> {
         return idleConnectionTimeout;
     }
 
+    /**
+     * Redis server reconnection attempt timeout.
+     *
+     * On every such timeout event Redisson tries
+     * to connect to disconnected Redis server.
+     *
+     * Default is 3000
+     *
+     * @see #failedAttempts
+     *
+     */
+
+    public T setReconnectionTimeout(int slaveRetryTimeout) {
+        this.reconnectionTimeout = slaveRetryTimeout;
+        return (T)this;
+    }
+    public int getReconnectionTimeout() {
+        return reconnectionTimeout;
+    }
+
+    /**
+     * Redis 'slave' server will be excluded from the list of available slave nodes
+     * when sequential unsuccessful execution attempts of any Redis command on slave node reaches <code>slaveFailedAttempts</code>.
+     *
+     * Default is 3
+     *
+     */
+    public T setFailedAttempts(int slaveFailedAttempts) {
+        this.failedAttempts = slaveFailedAttempts;
+        return (T)this;
+    }
+    public int getFailedAttempts() {
+        return failedAttempts;
+    }
 
 }

src/main/java/org/redisson/BaseMasterSlaveServersConfig.java

@@ -55,22 +55,6 @@ public class BaseMasterSlaveServersConfig<T extends BaseMasterSlaveServersConfig
      */
     private int masterConnectionPoolSize = 100;
 
-    /**
-     * Redis 'slave' server reconnection attempt timeout in milliseconds
-     * used then server excluded from the list of available slave nodes
-     * due to reach limit of sequential unsuccessful execution attempts
-     *
-     * @see #slaveFailedAttempts
-     *
-     */
-    private int slaveReconnectionTimeout = 3000;
-
-    /**
-     * Redis 'slave' server will be excluded from the list of available slave nodes
-     * when sequential unsuccessful execution attempts of any Redis command on slave node reaches <code>slaveFailedAttempts</code>
-     */
-    private int slaveFailedAttempts = 3;
-
     public BaseMasterSlaveServersConfig() {
     }
 
@@ -80,8 +64,6 @@ public class BaseMasterSlaveServersConfig<T extends BaseMasterSlaveServersConfig
         setMasterConnectionPoolSize(config.getMasterConnectionPoolSize());
         setSlaveConnectionPoolSize(config.getSlaveConnectionPoolSize());
         setSlaveSubscriptionConnectionPoolSize(config.getSlaveSubscriptionConnectionPoolSize());
-        setSlaveFailedAttempts(config.getSlaveFailedAttempts());
-        setSlaveReconnectionTimeout(config.getSlaveReconnectionTimeout());
         setMasterConnectionMinimumIdleSize(config.getMasterConnectionMinimumIdleSize());
         setSlaveConnectionMinimumIdleSize(config.getSlaveConnectionMinimumIdleSize());
         setSlaveSubscriptionConnectionMinimumIdleSize(config.getSlaveSubscriptionConnectionMinimumIdleSize());
@@ -149,39 +131,6 @@ public class BaseMasterSlaveServersConfig<T extends BaseMasterSlaveServersConfig
         return slaveSubscriptionConnectionPoolSize;
     }
 
-    /**
-     * Redis 'slave' server reconnection attempt timeout in milliseconds
-     * used then server excluded from the list of available slave nodes
-     * due to reach limit of sequential unsuccessful execution attempts.
-     *
-     * Default is 3000
-     *
-     * @see #slaveFailedAttempts
-     *
-     */
-    public T setSlaveReconnectionTimeout(int slaveRetryTimeout) {
-        this.slaveReconnectionTimeout = slaveRetryTimeout;
-        return (T)this;
-    }
-    public int getSlaveReconnectionTimeout() {
-        return slaveReconnectionTimeout;
-    }
-
-    /**
-     * Redis 'slave' server will be excluded from the list of available slave nodes
-     * when sequential unsuccessful execution attempts of any Redis command on slave node reaches <code>slaveFailedAttempts</code>.
-     *
-     * Default is 3
-     *
-     */
-    public T setSlaveFailedAttempts(int slaveFailedAttempts) {
-        this.slaveFailedAttempts = slaveFailedAttempts;
-        return (T)this;
-    }
-    public int getSlaveFailedAttempts() {
-        return slaveFailedAttempts;
-    }
-
     /**
      * Redis 'slave' node minimum idle connection amount for <b>each</b> slave node
      *

src/main/java/org/redisson/cluster/ClusterConnectionManager.java

@@ -397,8 +397,8 @@ public class ClusterConnectionManager extends MasterSlaveConnectionManager {
         c.setConnectTimeout(cfg.getConnectTimeout());
         c.setIdleConnectionTimeout(cfg.getIdleConnectionTimeout());
 
-        c.setSlaveFailedAttempts(cfg.getSlaveFailedAttempts());
+        c.setFailedAttempts(cfg.getFailedAttempts());
-        c.setSlaveReconnectionTimeout(cfg.getSlaveReconnectionTimeout());
+        c.setReconnectionTimeout(cfg.getReconnectionTimeout());
         c.setMasterConnectionMinimumIdleSize(cfg.getMasterConnectionMinimumIdleSize());
         c.setSlaveConnectionMinimumIdleSize(cfg.getSlaveConnectionMinimumIdleSize());
         c.setSlaveSubscriptionConnectionMinimumIdleSize(cfg.getSlaveSubscriptionConnectionMinimumIdleSize());

src/main/java/org/redisson/connection/ElasticacheConnectionManager.java

@@ -162,8 +162,8 @@ public class ElasticacheConnectionManager extends MasterSlaveConnectionManager {
         c.setConnectTimeout(cfg.getConnectTimeout());
         c.setIdleConnectionTimeout(cfg.getIdleConnectionTimeout());
 
-        c.setSlaveFailedAttempts(cfg.getSlaveFailedAttempts());
+        c.setFailedAttempts(cfg.getFailedAttempts());
-        c.setSlaveReconnectionTimeout(cfg.getSlaveReconnectionTimeout());
+        c.setReconnectionTimeout(cfg.getReconnectionTimeout());
         c.setMasterConnectionMinimumIdleSize(cfg.getMasterConnectionMinimumIdleSize());
         c.setSlaveConnectionMinimumIdleSize(cfg.getSlaveConnectionMinimumIdleSize());
         c.setSlaveSubscriptionConnectionMinimumIdleSize(cfg.getSlaveSubscriptionConnectionMinimumIdleSize());

src/main/java/org/redisson/connection/MasterSlaveConnectionManager.java

@@ -151,7 +151,7 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
     protected void init(MasterSlaveServersConfig config) {
         this.config = config;
 
-        int[] timeouts = new int[] {config.getRetryInterval(), config.getTimeout(), config.getSlaveReconnectionTimeout()};
+        int[] timeouts = new int[] {config.getRetryInterval(), config.getTimeout(), config.getReconnectionTimeout()};
         Arrays.sort(timeouts);
         int minTimeout = timeouts[0];
         if (minTimeout % 100 != 0) {

src/main/java/org/redisson/connection/SentinelConnectionManager.java

@@ -70,8 +70,8 @@ public class SentinelConnectionManager extends MasterSlaveConnectionManager {
         c.setConnectTimeout(cfg.getConnectTimeout());
         c.setIdleConnectionTimeout(cfg.getIdleConnectionTimeout());
 
-        c.setSlaveFailedAttempts(cfg.getSlaveFailedAttempts());
+        c.setFailedAttempts(cfg.getFailedAttempts());
-        c.setSlaveReconnectionTimeout(cfg.getSlaveReconnectionTimeout());
+        c.setReconnectionTimeout(cfg.getReconnectionTimeout());
         c.setMasterConnectionMinimumIdleSize(cfg.getMasterConnectionMinimumIdleSize());
         c.setSlaveConnectionMinimumIdleSize(cfg.getSlaveConnectionMinimumIdleSize());
         c.setSlaveSubscriptionConnectionMinimumIdleSize(cfg.getSlaveSubscriptionConnectionMinimumIdleSize());

src/main/java/org/redisson/misc/ConnectionPool.java

@@ -147,7 +147,7 @@ public class ConnectionPool<T extends RedisConnection> {
     }
 
     protected boolean tryAcquireConnection(ClientConnectionsEntry entry) {
-        return entry.getFailedAttempts() < config.getSlaveFailedAttempts() && entry.tryAcquireConnection();
+        return entry.getFailedAttempts() < config.getFailedAttempts() && entry.tryAcquireConnection();
     }
 
     protected T poll(ClientConnectionsEntry entry) {
@@ -201,7 +201,7 @@ public class ConnectionPool<T extends RedisConnection> {
     }
 
     private void promiseFailure(ClientConnectionsEntry entry, Promise<T> promise, Throwable cause) {
-        if (entry.incFailedAttempts() == config.getSlaveFailedAttempts()) {
+        if (entry.incFailedAttempts() == config.getFailedAttempts()) {
             if (entry.getNodeType() == NodeType.SLAVE) {
                 connectionManager.slaveDown(masterSlaveEntry, entry.getClient().getAddr().getHostName(),
                         entry.getClient().getAddr().getPort(), FreezeReason.RECONNECT);
@@ -223,7 +223,7 @@ public class ConnectionPool<T extends RedisConnection> {
 
     private void promiseFailure(ClientConnectionsEntry entry, Promise<T> promise, T conn) {
         int attempts = entry.incFailedAttempts();
-        if (attempts == config.getSlaveFailedAttempts()) {
+        if (attempts == config.getFailedAttempts()) {
             if (entry.getNodeType() == NodeType.SLAVE) {
                 connectionManager.slaveDown(masterSlaveEntry, entry.getClient().getAddr().getHostName(),
                         entry.getClient().getAddr().getPort(), FreezeReason.RECONNECT);
@@ -231,7 +231,7 @@ public class ConnectionPool<T extends RedisConnection> {
             } else {
                 freezeMaster(entry);
             }
-        } else if (attempts < config.getSlaveFailedAttempts()) {
+        } else if (attempts < config.getFailedAttempts()) {
             releaseConnection(entry, conn);
         }
 
@@ -312,7 +312,7 @@ public class ConnectionPool<T extends RedisConnection> {
                     }
                 });
             }
-        }, config.getSlaveReconnectionTimeout(), TimeUnit.MILLISECONDS);
+        }, config.getReconnectionTimeout(), TimeUnit.MILLISECONDS);
     }
 
     public void returnConnection(ClientConnectionsEntry entry, T connection) {