コード例 #1
0
  @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();
  }
コード例 #2
0
  @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();
  }
コード例 #3
0
  @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();
  }
コード例 #4
0
  @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();
  }