public RedisPubSubConnection nextPubSubConnection() {
clientsEmpty.awaitUninterruptibly();
List<SubscribesConnectionEntry> clientsCopy =
new ArrayList<SubscribesConnectionEntry>(clients.values());
while (true) {
if (clientsCopy.isEmpty()) {
throw new RedisConnectionException("Slave subscribe-connection pool gets exhausted!");
}
int index = getIndex(clientsCopy);
SubscribesConnectionEntry entry = clientsCopy.get(index);
if (entry.isFreezed() || !entry.getSubscribeConnectionsSemaphore().tryAcquire()) {
clientsCopy.remove(index);
} else {
try {
RedisPubSubConnection conn = entry.pollFreeSubscribeConnection();
if (conn != null) {
return conn;
}
return entry.connectPubSub(config);
} catch (RedisConnectionException e) {
entry.getSubscribeConnectionsSemaphore().release();
// TODO connection scoring
log.warn("Can't connect to {}, trying next connection!", entry.getClient().getAddr());
clientsCopy.remove(index);
}
}
}
}
public synchronized Collection<RedisPubSubConnection> freeze(String host, int port) {
InetSocketAddress addr = new InetSocketAddress(host, port);
for (SubscribesConnectionEntry connectionEntry : clients.values()) {
if (connectionEntry.isFreezed() || !connectionEntry.getClient().getAddr().equals(addr)) {
continue;
}
log.debug("{} freezed", addr);
connectionEntry.setFreezed(true);
// close all connections
while (true) {
RedisConnection connection = connectionEntry.getConnections().poll();
if (connection == null) {
break;
}
connection.closeAsync();
}
// close all pub/sub connections
while (true) {
RedisPubSubConnection connection = connectionEntry.pollFreeSubscribeConnection();
if (connection == null) {
break;
}
connection.closeAsync();
}
boolean allFreezed = true;
for (SubscribesConnectionEntry entry : clients.values()) {
if (!entry.isFreezed()) {
allFreezed = false;
break;
}
}
if (allFreezed) {
clientsEmpty.close();
}
List<RedisPubSubConnection> list =
new ArrayList<RedisPubSubConnection>(connectionEntry.getAllSubscribeConnections());
connectionEntry.getAllSubscribeConnections().clear();
return list;
}
return Collections.emptyList();
}
public int getAvailableClients() {
int count = 0;
for (SubscribesConnectionEntry connectionEntry : clients.values()) {
if (!connectionEntry.isFreezed()) {
count++;
}
}
return count;
}
public void returnConnection(RedisConnection connection) {
SubscribesConnectionEntry entry = clients.get(connection.getRedisClient());
if (entry.isFreezed()) {
connection.closeAsync();
} else {
entry.getConnections().add(connection);
}
entry.getConnectionsSemaphore().release();
}
private RedisConnection retrieveConnection(SubscribesConnectionEntry entry) {
if (entry.isFreezed() || !entry.getConnectionsSemaphore().tryAcquire()) {
return null;
} else {
RedisConnection conn = entry.getConnections().poll();
if (conn != null) {
return conn;
}
try {
return entry.connect(config);
} catch (RedisException e) {
entry.getConnectionsSemaphore().release();
// TODO connection scoring
log.warn("Can't connect to {}, trying next connection!", entry.getClient().getAddr());
return null;
}
}
}
public synchronized void add(SubscribesConnectionEntry entry) {
clients.put(entry.getClient(), entry);
if (!entry.isFreezed()) {
clientsEmpty.open();
}
}