/** Close the connection. */
public synchronized void close() {
if (!closed && channel != null) {
ConnectionWatchdog watchdog = channel.getPipeline().get(ConnectionWatchdog.class);
watchdog.setReconnect(false);
closed = true;
channel.close();
}
}
@Test
public void reconnectIsActiveHandler() throws Exception {
RedisCommands<String, String> connection = client.connect().sync();
ConnectionWatchdog connectionWatchdog =
Connections.getConnectionWatchdog(connection.getStatefulConnection());
assertThat(connectionWatchdog).isNotNull();
assertThat(connectionWatchdog.isListenOnChannelInactive()).isTrue();
assertThat(connectionWatchdog.isReconnectSuspended()).isFalse();
connection.close();
}
@Test
public void commandRetriedChannelClosesWhileFlush() throws Exception {
assumeTrue(Version.identify().get("netty-transport").artifactVersion().startsWith("4.0.2"));
RedisCommands<String, String> connection = client.connect().sync();
RedisCommands<String, String> verificationConnection = client.connect().sync();
RedisChannelWriter<String, String> channelWriter =
getRedisChannelHandler(connection).getChannelWriter();
connection.set(key, "1");
assertThat(verificationConnection.get(key)).isEqualTo("1");
final CountDownLatch block = new CountDownLatch(1);
ConnectionWatchdog connectionWatchdog =
Connections.getConnectionWatchdog(connection.getStatefulConnection());
AsyncCommand<String, String, Object> command = getBlockOnEncodeCommand(block);
channelWriter.write(command);
connectionWatchdog.setReconnectSuspended(true);
Channel channel = getChannel(getRedisChannelHandler(connection));
channel.unsafe().disconnect(channel.newPromise());
assertThat(channel.isOpen()).isFalse();
assertThat(command.isCancelled()).isFalse();
assertThat(command.isDone()).isFalse();
block.countDown();
assertThat(command.await(2, TimeUnit.SECONDS)).isFalse();
connectionWatchdog.setReconnectSuspended(false);
connectionWatchdog.scheduleReconnect();
assertThat(command.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(command.isCancelled()).isFalse();
assertThat(command.isDone()).isTrue();
assertThat(verificationConnection.get(key)).isEqualTo("2");
assertThat(getQueue(getRedisChannelHandler(connection))).isEmpty();
assertThat(getCommandBuffer(getRedisChannelHandler(connection))).isEmpty();
connection.close();
verificationConnection.close();
}
private <K, V, T extends RedisAsyncConnection<K, V>> T connect(
CommandHandler<K, V> handler, T connection) {
try {
ConnectionWatchdog watchdog = new ConnectionWatchdog(bootstrap, channels, timer);
ChannelPipeline pipeline = Channels.pipeline(watchdog, handler, connection);
Channel channel = bootstrap.getFactory().newChannel(pipeline);
ChannelFuture future = channel.connect((SocketAddress) bootstrap.getOption("remoteAddress"));
future.await();
if (!future.isSuccess()) {
throw future.getCause();
}
watchdog.setReconnect(true);
return connection;
} catch (Throwable e) {
throw new RedisException("Unable to connect", e);
}
}
@Test
public void retryAfterConnectionIsDisconnected() throws Exception {
RedisAsyncConnection<String, String> connection = client.connectAsync();
RedisChannelHandler<String, String> redisChannelHandler =
(RedisChannelHandler) connection.getStatefulConnection();
RedisCommands<String, String> verificationConnection = client.connect().sync();
connection.set(key, "1").get();
ConnectionWatchdog connectionWatchdog =
Connections.getConnectionWatchdog(connection.getStatefulConnection());
connectionWatchdog.setListenOnChannelInactive(false);
connection.quit();
while (connection.isOpen()) {
Thread.sleep(100);
}
assertThat(connection.incr(key).await(1, TimeUnit.SECONDS)).isFalse();
assertThat(verificationConnection.get("key")).isEqualTo("1");
assertThat(getQueue(redisChannelHandler)).isEmpty();
assertThat(getCommandBuffer(redisChannelHandler).size()).isGreaterThan(0);
connectionWatchdog.setListenOnChannelInactive(true);
connectionWatchdog.scheduleReconnect();
while (!getCommandBuffer(redisChannelHandler).isEmpty()
|| !getQueue(redisChannelHandler).isEmpty()) {
Thread.sleep(10);
}
assertThat(connection.get(key).get()).isEqualTo("2");
assertThat(verificationConnection.get(key)).isEqualTo("2");
connection.close();
verificationConnection.close();
}
@Test
public void commandCancelledOverSyncAPIAfterConnectionIsDisconnected() throws Exception {
RedisCommands<String, String> connection = client.connect().sync();
RedisCommands<String, String> verificationConnection = client.connect().sync();
connection.set(key, "1");
ConnectionWatchdog connectionWatchdog =
Connections.getConnectionWatchdog(connection.getStatefulConnection());
connectionWatchdog.setListenOnChannelInactive(false);
connection.quit();
Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();
try {
connection.incr(key);
} catch (RedisException e) {
assertThat(e).isExactlyInstanceOf(RedisCommandTimeoutException.class);
}
assertThat(verificationConnection.get("key")).isEqualTo("1");
assertThat(getQueue(getRedisChannelHandler(connection))).isEmpty();
assertThat(getCommandBuffer(getRedisChannelHandler(connection)).size()).isGreaterThan(0);
connectionWatchdog.setListenOnChannelInactive(true);
connectionWatchdog.scheduleReconnect();
while (!getCommandBuffer(getRedisChannelHandler(connection)).isEmpty()
|| !getQueue(getRedisChannelHandler(connection)).isEmpty()) {
Thread.sleep(10);
}
assertThat(connection.get(key)).isEqualTo("1");
connection.close();
verificationConnection.close();
}