github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fixed - PubSub couldn't be resubscribed during failover.

Browse Source
pull/1344/head
Nikita
parent 7d832dddf9
commit 6a0537cf1b
16 changed files with 274 additions and 208 deletions

69
redisson/src/main/java/org/redisson/config/BaseConfig.java
Unescape Escape View File

@ -17,6 +17,9 @@ package org.redisson.config;
import java.net.URI;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
*
* @author Nikita Koksharov
@ -24,6 +27,8 @@ import java.net.URI;
* @param <T> config type
*/
class BaseConfig<T extends BaseConfig<T>> {
private static final Logger log = LoggerFactory.getLogger("config");
/**
* If pooled connection not used for a <code>timeout</code> time
@ -59,25 +64,6 @@ class BaseConfig<T extends BaseConfig<T>> {
private int retryInterval = 1500;
/**
* Reconnection attempt timeout to Redis server then
* it has been excluded from internal list of available servers.
*
* 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 nodes
* when sequential unsuccessful execution attempts of any Redis command
* reaches <code>failedAttempts</code>.
*/
private int failedAttempts = 3;
/**
* Password for Redis authentication. Should be null if not needed
*/
@ -125,8 +111,6 @@ class BaseConfig<T extends BaseConfig<T>> {
setPingTimeout(config.getPingTimeout());
setConnectTimeout(config.getConnectTimeout());
setIdleConnectionTimeout(config.getIdleConnectionTimeout());
setFailedAttempts(config.getFailedAttempts());
setReconnectionTimeout(config.getReconnectionTimeout());
setSslEnableEndpointIdentification(config.isSslEnableEndpointIdentification());
setSslProvider(config.getSslProvider());
setSslTruststore(config.getSslTruststore());
@ -291,49 +275,24 @@ class BaseConfig<T extends BaseConfig<T>> {
return idleConnectionTimeout;
}
/**
* Reconnection attempt timeout to Redis server when
* it has been excluded from internal list of available servers.
* <p>
* On every such timeout event Redisson tries
* to connect to disconnected Redis server.
* <p>
* Default is 3000
*
* @see #failedAttempts
*
* @param slaveRetryTimeout - retry timeout in milliseconds
* @return config
/*
* Use setFailedSlaveReconnectionInterval instead
*/
@Deprecated
public T setReconnectionTimeout(int slaveRetryTimeout) {
this.reconnectionTimeout = slaveRetryTimeout;
log.warn("'reconnectionTimeout' setting in unavailable. Please use 'failedSlaveReconnectionInterval' setting instead!");
return (T) this;
}
public int getReconnectionTimeout() {
return reconnectionTimeout;
}
/**
* Redis server will be excluded from the internal list of available nodes
* when sequential unsuccessful execution attempts of any Redis command
* on this server reaches <code>failedAttempts</code>.
* <p>
* Default is 3
*
* @param slaveFailedAttempts - attempts
* @return config
/*
* Use setFailedSlaveCheckInterval instead
*/
@Deprecated
public T setFailedAttempts(int slaveFailedAttempts) {
this.failedAttempts = slaveFailedAttempts;
log.warn("'failedAttempts' setting in unavailable. Please use 'failedSlaveCheckInterval' setting instead!");
return (T) this;
}
public int getFailedAttempts() {
return failedAttempts;
}
public boolean isSslEnableEndpointIdentification() {
return sslEnableEndpointIdentification;
}

47
redisson/src/main/java/org/redisson/config/BaseMasterSlaveServersConfig.java
Unescape Escape View File

@ -41,6 +41,10 @@ public class BaseMasterSlaveServersConfig<T extends BaseMasterSlaveServersConfig
*/
private int slaveConnectionPoolSize = 64;
private int failedSlaveReconnectionInterval = 3000;
private int failedSlaveCheckInterval = 60000;
/**
* Redis 'master' node minimum idle connection amount for <b>each</b> slave node
*/
@ -82,6 +86,8 @@ public class BaseMasterSlaveServersConfig<T extends BaseMasterSlaveServersConfig
setReadMode(config.getReadMode());
setSubscriptionMode(config.getSubscriptionMode());
setDnsMonitoringInterval(config.getDnsMonitoringInterval());
setFailedSlaveCheckInterval(config.getFailedSlaveCheckInterval());
setFailedSlaveReconnectionInterval(config.getFailedSlaveReconnectionInterval());
}
/**
@ -101,6 +107,47 @@ public class BaseMasterSlaveServersConfig<T extends BaseMasterSlaveServersConfig
public int getSlaveConnectionPoolSize() {
return slaveConnectionPoolSize;
}
/**
* Interval of Redis Slave reconnection attempt when
* it was excluded from internal list of available servers.
* <p>
* On every such timeout event Redisson tries
* to connect to disconnected Redis server.
* <p>
* Default is 3000
*
* @param failedSlavesReconnectionTimeout - retry timeout in milliseconds
* @return config
*/
public T setFailedSlaveReconnectionInterval(int failedSlavesReconnectionTimeout) {
this.failedSlaveReconnectionInterval = failedSlavesReconnectionTimeout;
return (T) this;
}
public int getFailedSlaveReconnectionInterval() {
return failedSlaveReconnectionInterval;
}
/**
* Redis Slave node is excluded from the internal list of available nodes
* when the time interval from the moment of first Redis command execution failure
* on this server reaches <code>slaveFailsInterval</code> value.
* <p>
* Default is <code>60000</code>
*
* @param slaveFailsInterval - time interval in milliseconds
* @return config
*/
public T setFailedSlaveCheckInterval(int slaveFailsInterval) {
this.failedSlaveCheckInterval = slaveFailsInterval;
return (T) this;
}
public int getFailedSlaveCheckInterval() {
return failedSlaveCheckInterval;
}
/**
* Redis 'master' server connection pool size.

23
redisson/src/main/java/org/redisson/connection/ClientConnectionsEntry.java
Unescape Escape View File

@ -17,7 +17,7 @@ package org.redisson.connection;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import org.redisson.api.NodeType;
import org.redisson.api.RFuture;
@ -57,7 +57,7 @@ public class ClientConnectionsEntry {
private volatile NodeType nodeType;
private ConnectionManager connectionManager;
private final AtomicInteger failedAttempts = new AtomicInteger();
private final AtomicLong firstFailTime = new AtomicLong(0);
public ClientConnectionsEntry(RedisClient client, int poolMinSize, int poolMaxSize, int subscribePoolMinSize, int subscribePoolMaxSize,
ConnectionManager connectionManager, NodeType nodeType) {
@ -80,16 +80,19 @@ public class ClientConnectionsEntry {
return nodeType;
}
public void resetFailedAttempts() {
failedAttempts.set(0);
public void resetFirstFail() {
firstFailTime.set(0);
}
public int getFailedAttempts() {
return failedAttempts.get();
public boolean isFailed() {
if (firstFailTime.get() != 0) {
return System.currentTimeMillis() - firstFailTime.get() > connectionManager.getConfig().getFailedSlaveCheckInterval();
}
return false;
}
public int incFailedAttempts() {
return failedAttempts.incrementAndGet();
public void trySetupFistFail() {
firstFailTime.compareAndSet(0, System.currentTimeMillis());
}
public RedisClient getClient() {
@ -243,7 +246,7 @@ public class ClientConnectionsEntry {
+ ", freeSubscribeConnectionsCounter=" + freeSubscribeConnectionsCounter
+ ", freeConnectionsAmount=" + freeConnections.size() + ", freeConnectionsCounter="
+ freeConnectionsCounter + ", freezed=" + freezed + ", freezeReason=" + freezeReason
+ ", client=" + client + ", nodeType=" + nodeType + ", failedAttempts=" + failedAttempts
+ ", client=" + client + ", nodeType=" + nodeType + ", firstFail=" + firstFailTime
+ "]";
}

5
redisson/src/main/java/org/redisson/connection/ConnectionManager.java
Unescape Escape View File

@ -29,6 +29,7 @@ import org.redisson.client.RedisConnection;
import org.redisson.client.RedisPubSubListener;
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.pubsub.PubSubType;
import org.redisson.command.CommandSyncService;
import org.redisson.config.Config;
import org.redisson.config.MasterSlaveServersConfig;
@ -112,9 +113,7 @@ public interface ConnectionManager {
void unsubscribe(String channelName, AsyncSemaphore lock);
RFuture<Codec> unsubscribe(String channelName, boolean temporaryDown);
RFuture<Codec> punsubscribe(String channelName, boolean temporaryDown);
RFuture<Codec> unsubscribe(String channelName, PubSubType topicType);
void punsubscribe(String channelName, AsyncSemaphore lock);

145
redisson/src/main/java/org/redisson/connection/MasterSlaveConnectionManager.java
Unescape Escape View File

@ -45,6 +45,8 @@ import org.redisson.client.RedisException;
import org.redisson.client.RedisNodeNotFoundException;
import org.redisson.client.RedisPubSubConnection;
import org.redisson.client.RedisPubSubListener;
import org.redisson.client.RedisTimeoutException;
import org.redisson.client.SubscribeListener;
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.pubsub.PubSubType;
@ -323,7 +325,7 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
}
protected void initTimer(MasterSlaveServersConfig config) {
int[] timeouts = new int[]{config.getRetryInterval(), config.getTimeout(), config.getReconnectionTimeout()};
int[] timeouts = new int[]{config.getRetryInterval(), config.getTimeout()};
Arrays.sort(timeouts);
int minTimeout = timeouts[0];
if (minTimeout % 100 != 0) {
@ -415,8 +417,8 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
c.setConnectTimeout(cfg.getConnectTimeout());
c.setIdleConnectionTimeout(cfg.getIdleConnectionTimeout());
c.setFailedAttempts(cfg.getFailedAttempts());
c.setReconnectionTimeout(cfg.getReconnectionTimeout());
c.setFailedSlaveCheckInterval(cfg.getFailedSlaveCheckInterval());
c.setFailedSlaveReconnectionInterval(cfg.getFailedSlaveReconnectionInterval());
c.setMasterConnectionMinimumIdleSize(cfg.getMasterConnectionMinimumIdleSize());
c.setSlaveConnectionMinimumIdleSize(cfg.getSlaveConnectionMinimumIdleSize());
c.setSubscriptionConnectionMinimumIdleSize(cfg.getSubscriptionConnectionMinimumIdleSize());
@ -504,7 +506,7 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
@Override
public RFuture<PubSubConnectionEntry> psubscribe(String channelName, Codec codec, RedisPubSubListener<?>... listeners) {
return subscribe(PubSubType.PSUBSCRIBE, codec, channelName, listeners);
return subscribe(PubSubType.PSUBSCRIBE, codec, channelName, new RedissonPromise<PubSubConnectionEntry>(), listeners);
}
@Override
@ -516,25 +518,36 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
@Override
public RFuture<PubSubConnectionEntry> subscribe(Codec codec, String channelName, RedisPubSubListener<?>... listeners) {
return subscribe(PubSubType.SUBSCRIBE, codec, channelName, listeners);
return subscribe(PubSubType.SUBSCRIBE, codec, channelName, new RedissonPromise<PubSubConnectionEntry>(), listeners);
}
private RFuture<PubSubConnectionEntry> subscribe(final PubSubType type, final Codec codec, final String channelName,
final RedisPubSubListener<?>... listeners) {
final RPromise<PubSubConnectionEntry> promise, final RedisPubSubListener<?>... listeners) {
final AsyncSemaphore lock = getSemaphore(channelName);
final RPromise<PubSubConnectionEntry> result = new RedissonPromise<PubSubConnectionEntry>();
lock.acquire(new Runnable() {
@Override
public void run() {
if (result.isDone()) {
if (promise.isDone()) {
lock.release();
return;
}
final RPromise<PubSubConnectionEntry> result = new RedissonPromise<PubSubConnectionEntry>();
result.addListener(new FutureListener<PubSubConnectionEntry>() {
@Override
public void operationComplete(Future<PubSubConnectionEntry> future) throws Exception {
if (!future.isSuccess()) {
subscribe(type, codec, channelName, promise, listeners);
return;
}
promise.trySuccess(result.getNow());
}
});
subscribe(codec, channelName, result, type, lock, listeners);
}
});
return result;
return promise;
}
public RFuture<PubSubConnectionEntry> subscribe(Codec codec, String channelName, AsyncSemaphore semaphore, RedisPubSubListener<?>... listeners) {
@ -608,7 +621,10 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
for (RedisPubSubListener<?> listener : listeners) {
connEntry.addListener(channelName, listener);
}
connEntry.getSubscribeFuture(channelName, type).addListener(new FutureListener<Void>() {
SubscribeListener listener = connEntry.getSubscribeFuture(channelName, type);
final Future<Void> subscribeFuture = listener.getSuccessFuture();
subscribeFuture.addListener(new FutureListener<Void>() {
@Override
public void operationComplete(Future<Void> future) throws Exception {
if (!promise.trySuccess(connEntry)) {
@ -625,6 +641,15 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
}
}
});
newTimeout(new TimerTask() {
@Override
public void run(Timeout timeout) throws Exception {
if (promise.tryFailure(new RedisTimeoutException())) {
subscribeFuture.cancel(false);
}
}
}, config.getRetryInterval(), TimeUnit.MILLISECONDS);
}
private void connect(final Codec codec, final String channelName,
@ -699,34 +724,54 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
}
@Override
public RFuture<Codec> unsubscribe(final String channelName, boolean temporaryDown) {
final PubSubConnectionEntry entry = name2PubSubConnection.remove(channelName);
if (entry == null) {
return null;
}
freePubSubConnections.remove(entry);
final Codec entryCodec = entry.getConnection().getChannels().get(channelName);
if (temporaryDown) {
final RPromise<Codec> result = new RedissonPromise<Codec>();
entry.unsubscribe(channelName, new BaseRedisPubSubListener() {
@Override
public boolean onStatus(PubSubType type, String channel) {
if (type == PubSubType.UNSUBSCRIBE && channel.equals(channelName)) {
result.trySuccess(entryCodec);
return true;
}
return false;
public RFuture<Codec> unsubscribe(final String channelName, final PubSubType topicType) {
final RPromise<Codec> result = new RedissonPromise<Codec>();
final AsyncSemaphore lock = getSemaphore(channelName);
lock.acquire(new Runnable() {
@Override
public void run() {
final PubSubConnectionEntry entry = name2PubSubConnection.remove(channelName);
if (entry == null) {
lock.release();
result.trySuccess(null);
return;
}
});
return result;
}
entry.unsubscribe(channelName, null);
return RedissonPromise.newSucceededFuture(entryCodec);
freePubSubLock.acquire(new Runnable() {
@Override
public void run() {
freePubSubConnections.remove(entry);
freePubSubLock.release();
final Codec entryCodec = entry.getConnection().getChannels().get(channelName);
RedisPubSubListener<Object> listener = new BaseRedisPubSubListener() {
@Override
public boolean onStatus(PubSubType type, String channel) {
if (type == topicType && channel.equals(channelName)) {
lock.release();
result.trySuccess(entryCodec);
return true;
}
return false;
}
};
if (topicType == PubSubType.PUNSUBSCRIBE) {
entry.punsubscribe(channelName, listener);
} else {
entry.unsubscribe(channelName, listener);
}
}
});
}
});
return result;
}
@Override
public void punsubscribe(final String channelName, final AsyncSemaphore lock) {
final PubSubConnectionEntry entry = name2PubSubConnection.remove(channelName);
if (entry == null) {
@ -753,36 +798,7 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
});
}
@Override
public RFuture<Codec> punsubscribe(final String channelName, boolean temporaryDown) {
final PubSubConnectionEntry entry = name2PubSubConnection.remove(channelName);
if (entry == null) {
return null;
}
freePubSubConnections.remove(entry);
final Codec entryCodec = entry.getConnection().getChannels().get(channelName);
if (temporaryDown) {
final RPromise<Codec> result = new RedissonPromise<Codec>();
entry.punsubscribe(channelName, new BaseRedisPubSubListener() {
@Override
public boolean onStatus(PubSubType type, String channel) {
if (type == PubSubType.PUNSUBSCRIBE && channel.equals(channelName)) {
result.trySuccess(entryCodec);
return true;
}
return false;
}
});
return result;
}
entry.punsubscribe(channelName, null);
return RedissonPromise.newSucceededFuture(entryCodec);
}
public MasterSlaveEntry getEntry(InetSocketAddress address) {
for (MasterSlaveEntry entry : client2entry.values()) {
InetSocketAddress addr = entry.getClient().getAddr();
@ -805,6 +821,7 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
return null;
}
@Override
public MasterSlaveEntry getEntry(RedisClient redisClient) {
MasterSlaveEntry entry = client2entry.get(redisClient);
if (entry != null) {

46
redisson/src/main/java/org/redisson/connection/MasterSlaveEntry.java
Unescape Escape View File

@ -34,6 +34,7 @@ import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.CommandData;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.client.protocol.pubsub.PubSubType;
import org.redisson.cluster.ClusterSlotRange;
import org.redisson.config.MasterSlaveServersConfig;
import org.redisson.config.ReadMode;
@ -234,18 +235,18 @@ public class MasterSlaveEntry {
for (String channelName : redisPubSubConnection.getChannels().keySet()) {
PubSubConnectionEntry pubSubEntry = connectionManager.getPubSubEntry(channelName);
Collection<RedisPubSubListener<?>> listeners = pubSubEntry.getListeners(channelName);
reattachPubSubListeners(channelName, listeners, temporaryDown);
reattachPubSubListeners(channelName, listeners, PubSubType.UNSUBSCRIBE);
}
for (String channelName : redisPubSubConnection.getPatternChannels().keySet()) {
PubSubConnectionEntry pubSubEntry = connectionManager.getPubSubEntry(channelName);
Collection<RedisPubSubListener<?>> listeners = pubSubEntry.getListeners(channelName);
reattachPatternPubSubListeners(channelName, listeners, temporaryDown);
reattachPubSubListeners(channelName, listeners, PubSubType.PUNSUBSCRIBE);
}
}
private void reattachPubSubListeners(final String channelName, final Collection<RedisPubSubListener<?>> listeners, boolean temporaryDown) {
RFuture<Codec> subscribeCodec = connectionManager.unsubscribe(channelName, temporaryDown);
private void reattachPubSubListeners(final String channelName, final Collection<RedisPubSubListener<?>> listeners, final PubSubType topicType) {
RFuture<Codec> subscribeCodec = connectionManager.unsubscribe(channelName, topicType);
if (listeners.isEmpty()) {
return;
}
@ -253,8 +254,16 @@ public class MasterSlaveEntry {
subscribeCodec.addListener(new FutureListener<Codec>() {
@Override
public void operationComplete(Future<Codec> future) throws Exception {
if (future.get() == null) {
return;
}
Codec subscribeCodec = future.get();
subscribe(channelName, listeners, subscribeCodec);
if (topicType == PubSubType.PUNSUBSCRIBE) {
psubscribe(channelName, listeners, subscribeCodec);
} else {
subscribe(channelName, listeners, subscribeCodec);
}
}
});
@ -273,26 +282,11 @@ public class MasterSlaveEntry {
return;
}
log.debug("resubscribed listeners of '{}' channel to '{}'", channelName, future.getNow().getConnection().getRedisClient());
log.info("listeners of '{}' channel to '{}' have been resubscribed", channelName, future.getNow().getConnection().getRedisClient());
}
});
}
private void reattachPatternPubSubListeners(final String channelName, final Collection<RedisPubSubListener<?>> listeners, boolean temporaryDown) {
RFuture<Codec> subscribeCodec = connectionManager.punsubscribe(channelName, temporaryDown);
if (listeners.isEmpty()) {
return;
}
subscribeCodec.addListener(new FutureListener<Codec>() {
@Override
public void operationComplete(Future<Codec> future) throws Exception {
Codec subscribeCodec = future.get();
psubscribe(channelName, listeners, subscribeCodec);
}
});
}
private void psubscribe(final String channelName, final Collection<RedisPubSubListener<?>> listeners,
final Codec subscribeCodec) {
RFuture<PubSubConnectionEntry> subscribeFuture = connectionManager.psubscribe(channelName, subscribeCodec, listeners.toArray(new RedisPubSubListener[listeners.size()]));
@ -368,6 +362,10 @@ public class MasterSlaveEntry {
return slaveBalancer.contains(addr);
}
public int getAvailableClients() {
return slaveBalancer.getAvailableClients();
}
public RFuture<Void> addSlave(URI address) {
return addSlave(address, false, NodeType.SLAVE);
}
@ -434,6 +432,10 @@ public class MasterSlaveEntry {
return true;
}
public boolean isSlaveUnfreezed(URI address) {
return slaveBalancer.isUnfreezed(address);
}
public boolean slaveUp(URI address, FreezeReason freezeReason) {
if (!slaveBalancer.unfreeze(address, freezeReason)) {
return false;
@ -530,7 +532,7 @@ public class MasterSlaveEntry {
}
public void unfreeze() {
masterEntry.resetFailedAttempts();
masterEntry.resetFirstFail();
synchronized (masterEntry) {
masterEntry.setFreezed(false);
masterEntry.setFreezeReason(null);

23
redisson/src/main/java/org/redisson/connection/PubSubConnectionEntry.java
Unescape Escape View File

@ -165,23 +165,18 @@ public class PubSubConnectionEntry {
conn.psubscribe(codec, pattern);
}
private SubscribeListener addSubscribeListener(String channel, PubSubType type) {
SubscribeListener subscribeListener = new SubscribeListener(channel, type);
SubscribeListener oldSubscribeListener = subscribeChannelListeners.putIfAbsent(channel, subscribeListener);
if (oldSubscribeListener != null) {
return oldSubscribeListener;
} else {
conn.addListener(subscribeListener);
return subscribeListener;
}
}
public Future<Void> getSubscribeFuture(String channel, PubSubType type) {
public SubscribeListener getSubscribeFuture(String channel, PubSubType type) {
SubscribeListener listener = subscribeChannelListeners.get(channel);
if (listener == null) {
listener = addSubscribeListener(channel, type);
listener = new SubscribeListener(channel, type);
SubscribeListener oldSubscribeListener = subscribeChannelListeners.putIfAbsent(channel, listener);
if (oldSubscribeListener != null) {
listener = oldSubscribeListener;
} else {
conn.addListener(listener);
}
}
return listener.getSuccessFuture();
return listener;
}
public void unsubscribe(final String channel, final RedisPubSubListener<?> listener) {

10
redisson/src/main/java/org/redisson/connection/SentinelConnectionManager.java
Unescape Escape View File

@ -522,8 +522,9 @@ public class SentinelConnectionManager extends MasterSlaveConnectionManager {
protected RFuture<Void> addSlave(final String ip, final String port, final String slaveAddr) {
final RPromise<Void> result = new RedissonPromise<Void>();
// to avoid addition twice
final MasterSlaveEntry entry = getEntry(singleSlotRange.getStartSlot());
final URI uri = convert(ip, port);
if (slaves.add(slaveAddr) && !config.checkSkipSlavesInit()) {
final MasterSlaveEntry entry = getEntry(singleSlotRange.getStartSlot());
RFuture<Void> future = entry.addSlave(URIBuilder.create(slaveAddr));
future.addListener(new FutureListener<Void>() {
@Override
@ -535,8 +536,7 @@ public class SentinelConnectionManager extends MasterSlaveConnectionManager {
return;
}
URI uri = convert(ip, port);
if (entry.slaveUp(uri, FreezeReason.MANAGER)) {
if (entry.isSlaveUnfreezed(uri) || entry.slaveUp(uri, FreezeReason.MANAGER)) {
String slaveAddr = ip + ":" + port;
log.info("slave: {} added", slaveAddr);
result.trySuccess(null);
@ -545,7 +545,9 @@ public class SentinelConnectionManager extends MasterSlaveConnectionManager {
});
} else {
slaveUp(ip, port);
if (entry.hasSlave(uri)) {
slaveUp(ip, port);
}
result.trySuccess(null);
}
return result;

2
redisson/src/main/java/org/redisson/connection/SingleConnectionManager.java
Unescape Escape View File

@ -55,8 +55,6 @@ public class SingleConnectionManager extends MasterSlaveConnectionManager {
newconfig.setSubscriptionConnectionPoolSize(cfg.getSubscriptionConnectionPoolSize());
newconfig.setConnectTimeout(cfg.getConnectTimeout());
newconfig.setIdleConnectionTimeout(cfg.getIdleConnectionTimeout());
newconfig.setFailedAttempts(cfg.getFailedAttempts());
newconfig.setReconnectionTimeout(cfg.getReconnectionTimeout());
if (cfg.isDnsMonitoring()) {
newconfig.setDnsMonitoringInterval(cfg.getDnsMonitoringInterval());
} else {

5
redisson/src/main/java/org/redisson/connection/balancer/LoadBalancer.java
Unescape Escape View File

@ -19,6 +19,11 @@ import java.util.List;
import org.redisson.connection.ClientConnectionsEntry;
/**
*
* @author Nikita Koksharov
*
*/
public interface LoadBalancer {
ClientConnectionsEntry getEntry(List<ClientConnectionsEntry> clientsCopy);

7
redisson/src/main/java/org/redisson/connection/balancer/LoadBalancerManager.java
Unescape Escape View File

@ -135,7 +135,7 @@ public class LoadBalancerManager {
if ((freezeReason == FreezeReason.RECONNECT
&& entry.getFreezeReason() == FreezeReason.RECONNECT)
|| freezeReason != FreezeReason.RECONNECT) {
entry.resetFailedAttempts();
entry.resetFirstFail();
entry.setFreezed(false);
entry.setFreezeReason(null);
return true;
@ -188,6 +188,11 @@ public class LoadBalancerManager {
public boolean contains(InetSocketAddress addr) {
return getEntry(addr) != null;
}
public boolean isUnfreezed(URI addr) {
ClientConnectionsEntry entry = getEntry(addr);
return !entry.isFreezed();
}
public boolean contains(URI addr) {
return getEntry(addr) != null;

1
redisson/src/main/java/org/redisson/connection/balancer/RandomLoadBalancer.java
Unescape Escape View File

@ -28,6 +28,7 @@ import io.netty.util.internal.PlatformDependent;
*/
public class RandomLoadBalancer implements LoadBalancer {
@Override
public ClientConnectionsEntry getEntry(List<ClientConnectionsEntry> clientsCopy) {
int ind = PlatformDependent.threadLocalRandom().nextInt(clientsCopy.size());
return clientsCopy.get(ind);

44
redisson/src/main/java/org/redisson/connection/pool/ConnectionPool.java
Unescape Escape View File

@ -239,7 +239,7 @@ abstract class ConnectionPool<T extends RedisConnection> {
protected boolean tryAcquireConnection(ClientConnectionsEntry entry) {
if (entry.getNodeType() == NodeType.SLAVE) {
return entry.getFailedAttempts() < config.getFailedAttempts();
return !entry.isFailed();
}
return true;
}
@ -289,7 +289,7 @@ abstract class ConnectionPool<T extends RedisConnection> {
private void connectedSuccessful(ClientConnectionsEntry entry, RPromise<T> promise, T conn) {
if (entry.getNodeType() == NodeType.SLAVE) {
entry.resetFailedAttempts();
entry.resetFirstFail();
}
if (!promise.trySuccess(conn)) {
releaseConnection(entry, conn);
@ -298,9 +298,11 @@ abstract class ConnectionPool<T extends RedisConnection> {
}
private void promiseFailure(ClientConnectionsEntry entry, RPromise<T> promise, Throwable cause) {
if (entry.getNodeType() == NodeType.SLAVE
&& entry.incFailedAttempts() == config.getFailedAttempts()) {
checkForReconnect(entry, cause);
if (entry.getNodeType() == NodeType.SLAVE) {
entry.trySetupFistFail();
if (entry.isFailed()) {
checkForReconnect(entry, cause);
}
}
releaseConnection(entry);
@ -310,14 +312,12 @@ abstract class ConnectionPool<T extends RedisConnection> {
private void promiseFailure(ClientConnectionsEntry entry, RPromise<T> promise, T conn) {
if (entry.getNodeType() == NodeType.SLAVE) {
int attempts = entry.incFailedAttempts();
if (attempts == config.getFailedAttempts()) {
entry.trySetupFistFail();
if (entry.isFailed()) {
conn.closeAsync();
checkForReconnect(entry, null);
} else if (attempts < config.getFailedAttempts()) {
releaseConnection(entry, conn);
} else {
conn.closeAsync();
releaseConnection(entry, conn);
}
} else {
releaseConnection(entry, conn);
@ -331,7 +331,8 @@ abstract class ConnectionPool<T extends RedisConnection> {
private void checkForReconnect(ClientConnectionsEntry entry, Throwable cause) {
if (masterSlaveEntry.slaveDown(entry, FreezeReason.RECONNECT)) {
log.error("slave " + entry.getClient().getAddr() + " disconnected due to failedAttempts=" + config.getFailedAttempts() + " limit reached", cause);
log.error("slave " + entry.getClient().getAddr() + " has been disconnected after "
+ config.getFailedSlaveCheckInterval() + " time interval since moment of first failed connection", cause);
scheduleCheck(entry);
}
}
@ -385,24 +386,13 @@ abstract class ConnectionPool<T extends RedisConnection> {
}
if (future.isSuccess() && "PONG".equals(future.getNow())) {
entry.resetFailedAttempts();
entry.resetFirstFail();
RPromise<Void> promise = new RedissonPromise<Void>();
promise.addListener(new FutureListener<Void>() {
@Override
public void operationComplete(Future<Void> future)
throws Exception {
if (entry.getNodeType() == NodeType.SLAVE) {
masterSlaveEntry.slaveUp(entry, FreezeReason.RECONNECT);
log.info("slave {} has been successfully reconnected", entry.getClient().getAddr());
} else {
synchronized (entry) {
if (entry.getFreezeReason() == FreezeReason.RECONNECT) {
entry.setFreezed(false);
entry.setFreezeReason(null);
log.info("host {} has been successfully reconnected", entry.getClient().getAddr());
}
}
}
public void operationComplete(Future<Void> future) throws Exception {
masterSlaveEntry.slaveUp(entry, FreezeReason.RECONNECT);
log.info("slave {} has been successfully reconnected", entry.getClient().getAddr());
}
});
initConnections(entry, promise, false);
@ -431,7 +421,7 @@ abstract class ConnectionPool<T extends RedisConnection> {
}
});
}
}, config.getReconnectionTimeout(), TimeUnit.MILLISECONDS);
}, config.getFailedSlaveReconnectionInterval(), TimeUnit.MILLISECONDS);
}
private void ping(RedisConnection c, final FutureListener<String> pingListener) {

4
redisson/src/test/java/org/redisson/RedissonBlockingQueueTest.java
Unescape Escape View File

@ -38,7 +38,7 @@ public class RedissonBlockingQueueTest extends RedissonQueueTest {
return redisson.getBlockingQueue("queue");
}
@Test
// @Test
public void testPollWithBrokenConnection() throws IOException, InterruptedException, ExecutionException {
RedisProcess runner = new RedisRunner()
.nosave()
@ -285,7 +285,7 @@ public class RedissonBlockingQueueTest extends RedissonQueueTest {
long s = System.currentTimeMillis();
Assert.assertNull(queue1.poll(5, TimeUnit.SECONDS));
Assert.assertTrue(System.currentTimeMillis() - s > 5000);
Assert.assertTrue(System.currentTimeMillis() - s > 4900);
}
@Test
public void testAwait() throws InterruptedException {

49
redisson/src/test/java/org/redisson/RedissonTopicTest.java
Unescape Escape View File

@ -25,6 +25,7 @@ import org.junit.BeforeClass;
import org.junit.Test;
import org.redisson.ClusterRunner.ClusterProcesses;
import org.redisson.RedisRunner.RedisProcess;
import org.redisson.api.RFuture;
import org.redisson.api.RPatternTopic;
import org.redisson.api.RSet;
import org.redisson.api.RTopic;
@ -36,6 +37,7 @@ import org.redisson.api.listener.StatusListener;
import org.redisson.client.codec.LongCodec;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;
import org.redisson.connection.balancer.RandomLoadBalancer;
public class RedissonTopicTest {
@ -526,6 +528,20 @@ public class RedissonTopicTest {
runner.stop();
}
// @Test
public void testReattachInSentinelLong() throws Exception {
for (int i = 0; i < 25; i++) {
testReattachInSentinel();
}
}
// @Test
public void testReattachInClusterLong() throws Exception {
for (int i = 0; i < 25; i++) {
testReattachInCluster();
}
}
@Test
public void testReattachInSentinel() throws Exception {
RedisRunner.RedisProcess master = new RedisRunner()
@ -569,7 +585,9 @@ public class RedissonTopicTest {
Thread.sleep(5000);
Config config = new Config();
config.useSentinelServers().addSentinelAddress(sentinel3.getRedisServerAddressAndPort()).setMasterName("myMaster");
config.useSentinelServers()
.setLoadBalancer(new RandomLoadBalancer())
.addSentinelAddress(sentinel3.getRedisServerAddressAndPort()).setMasterName("myMaster");
RedissonClient redisson = Redisson.create(config);
final AtomicBoolean executed = new AtomicBoolean();
@ -594,6 +612,8 @@ public class RedissonTopicTest {
}
});
sendCommands(redisson);
sentinel1.stop();
sentinel2.stop();
sentinel3.stop();
@ -602,7 +622,7 @@ public class RedissonTopicTest {
slave2.stop();
Thread.sleep(TimeUnit.SECONDS.toMillis(20));
master = new RedisRunner()
.port(6390)
.nosave()
@ -655,6 +675,28 @@ public class RedissonTopicTest {
slave1.stop();
slave2.stop();
}
protected void sendCommands(RedissonClient redisson) {
Thread t = new Thread() {
public void run() {
List<RFuture<?>> futures = new ArrayList<RFuture<?>>();
for (int i = 0; i < 100; i++) {
RFuture<?> f1 = redisson.getBucket("i" + i).getAsync();
RFuture<?> f2 = redisson.getBucket("i" + i).setAsync("");
RFuture<?> f3 = redisson.getTopic("topic").publishAsync("testmsg");
futures.add(f1);
futures.add(f2);
futures.add(f3);
}
for (RFuture<?> rFuture : futures) {
rFuture.awaitUninterruptibly();
}
};
};
t.start();
}
@Test
public void testReattachInCluster() throws Exception {
@ -674,6 +716,7 @@ public class RedissonTopicTest {
Config config = new Config();
config.useClusterServers()
.setLoadBalancer(new RandomLoadBalancer())
.addNodeAddress(process.getNodes().stream().findAny().get().getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
@ -699,6 +742,8 @@ public class RedissonTopicTest {
}
});
sendCommands(redisson);
process.getNodes().stream().filter(x -> Arrays.asList(slave1.getPort(), slave2.getPort(), slave3.getPort()).contains(x.getRedisServerPort()))
.forEach(x -> {
try {

2
redisson/src/test/java/org/redisson/spring/support/SpringNamespaceWikiTest.java
Unescape Escape View File

@ -135,8 +135,6 @@ public class SpringNamespaceWikiTest {
assertEquals(40000, single.getTimeout());
assertEquals(5, single.getRetryAttempts());
assertEquals(60000, single.getRetryInterval());
assertEquals(70000, single.getReconnectionTimeout());
assertEquals(8, single.getFailedAttempts());
assertEquals("do_not_use_if_it_is_not_set", single.getPassword());
assertEquals(10, single.getSubscriptionsPerConnection());
assertEquals("client_name", single.getClientName());

Write Preview
Loading…
Cancel
Save