org.springframework.data.redis.connection.RedisClusterNode Java Examples

@Test
public void invokingClusterAddSlots() {
  commandCreatesNewSpan(RedisCommand.CLUSTER_ADDSLOTS,
      () -> getConnection().clusterAddSlots(mockRedisClusterNode, 0));
  verify(mockRedisClusterConnection).clusterAddSlots(mockRedisClusterNode, 0);

  RedisClusterNode.SlotRange range = new RedisClusterNode.SlotRange(0, 1);
  commandCreatesNewSpan(RedisCommand.CLUSTER_ADDSLOTS,
      () -> getConnection().clusterAddSlots(mockRedisClusterNode, range));
  verify(mockRedisConnection()).clusterAddSlots(mockRedisClusterNode, range);
}
 

@Override
public Properties getConfig(RedisClusterNode node, String pattern) {
    MasterSlaveEntry entry = getEntry(node);
    RFuture<List<String>> f = executorService.writeAsync(entry, StringCodec.INSTANCE, RedisCommands.CONFIG_GET, pattern);
    List<String> r = syncFuture(f);
    if (r != null) {
        return Converters.toProperties(r);
    }
    return null;
}
 

@Test
public void invokingClusterDeleteSlotsInRange() {
  RedisClusterNode.SlotRange range = RedisClusterNode.SlotRange.empty();
  commandCreatesNewSpan(RedisCommand.CLUSTER_DELSLOTS,
      () -> getConnection().clusterDeleteSlotsInRange(mockRedisClusterNode, range));
  verify(mockRedisConnection()).clusterDeleteSlotsInRange(mockRedisClusterNode, range);
}
 

@Override
public RedisClusterNode clusterGetNodeForSlot(int slot) {
    Iterable<RedisClusterNode> res = clusterGetNodes();
    for (RedisClusterNode redisClusterNode : res) {
        if (redisClusterNode.isMaster() && redisClusterNode.getSlotRange().contains(slot)) {
            return redisClusterNode;
        }
    }
    return null;
}
 

@Override
public List<RedisClientInfo> getClientList(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    RFuture<List<String>> f = executorService.readAsync(entry, StringCodec.INSTANCE, RedisCommands.CLIENT_LIST);
    List<String> list = syncFuture(f);
    return CONVERTER.convert(list.toArray(new String[list.size()]));
}
 

@Test
public void testClusterGetMasterSlaveMap() {
    Map<RedisClusterNode, Collection<RedisClusterNode>> map = connection.clusterGetMasterSlaveMap();
    assertThat(map).hasSize(3);
    for (Collection<RedisClusterNode> slaves : map.values()) {
        assertThat(slaves).hasSize(1);
    }
}
 

@Override
public Flux<RedisClientInfo> getClientList(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    Mono<List<String>> m = executorService.reactive(() -> {
        return executorService.readAsync(entry, StringCodec.INSTANCE, RedisCommands.CLIENT_LIST);
    });
    return m.flatMapMany(s -> Flux.fromIterable(CONVERTER.convert(s.toArray(new String[s.size()]))));
}
 

@Override
public Flux<RedisClientInfo> getClientList(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    Mono<List<String>> m = executorService.reactive(() -> {
        return executorService.readAsync(entry, StringCodec.INSTANCE, RedisCommands.CLIENT_LIST);
    });
    return m.flatMapMany(s -> Flux.fromIterable(CONVERTER.convert(s.toArray(new String[s.size()]))));
}
 

@Override
public void clusterDeleteSlots(RedisClusterNode node, int... slots) {
    MasterSlaveEntry entry = getEntry(node);
    List<Integer> params = convert(slots);
    RFuture<Long> f = executorService.writeAsync(entry, StringCodec.INSTANCE, RedisCommands.CLUSTER_DELSLOTS, params.toArray());
    syncFuture(f);
}
 

@Override
public Mono<ByteBuffer> randomKey(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    Mono<byte[]> m = executorService.reactive(() -> {
        return executorService.readRandomAsync(entry, ByteArrayCodec.INSTANCE, RedisCommands.RANDOM_KEY);
    });
    return m.map(v -> ByteBuffer.wrap(v));
}
 

@Override
public void clusterMeet(RedisClusterNode node) {
    Assert.notNull(node, "Cluster node must not be null for CLUSTER MEET command!");
    Assert.hasText(node.getHost(), "Node to meet cluster must have a host!");
    Assert.isTrue(node.getPort() > 0, "Node to meet cluster must have a port greater 0!");
    
    RFuture<Void> f = executorService.writeAsync((String)null, StringCodec.INSTANCE, RedisCommands.CLUSTER_MEET, node.getHost(), node.getPort());
    syncFuture(f);
}
 

@Override
public RedisClusterNode clusterGetNodeForSlot(int slot) {
    Iterable<RedisClusterNode> res = clusterGetNodes();
    for (RedisClusterNode redisClusterNode : res) {
        if (redisClusterNode.isMaster() && redisClusterNode.getSlotRange().contains(slot)) {
            return redisClusterNode;
        }
    }
    return null;
}
 

@Override
public RedisClusterNode clusterGetNodeForSlot(int slot) {
    Iterable<RedisClusterNode> res = clusterGetNodes();
    for (RedisClusterNode redisClusterNode : res) {
        if (redisClusterNode.isMaster() && redisClusterNode.getSlotRange().contains(slot)) {
            return redisClusterNode;
        }
    }
    return null;
}
 

@Test
public void testClusterGetNodesMaster() {
    Iterable<RedisClusterNode> nodes = connection.clusterGetNodes();
    for (RedisClusterNode redisClusterNode : nodes) {
        if (redisClusterNode.getType() == NodeType.MASTER) {
            Collection<RedisClusterNode> slaves = connection.clusterGetSlaves(redisClusterNode);
            assertThat(slaves).hasSize(1);
        }
    }
}
 

@Test
public void testClusterGetMasterSlaveMap() {
    Map<RedisClusterNode, Collection<RedisClusterNode>> map = connection.clusterGetMasterSlaveMap();
    assertThat(map).hasSize(3);
    for (Collection<RedisClusterNode> slaves : map.values()) {
        assertThat(slaves).hasSize(1);
    }
}
 

@Override
public void clusterDeleteSlots(RedisClusterNode node, int... slots) {
    MasterSlaveEntry entry = getEntry(node);
    List<Integer> params = convert(slots);
    RFuture<Long> f = executorService.writeAsync(entry, StringCodec.INSTANCE, RedisCommands.CLUSTER_DELSLOTS, params.toArray());
    syncFuture(f);
}
 

@Test
public void testClusterAddRemoveSlots() {
    RedisClusterNode master = getFirstMaster();
    Integer slot = master.getSlotRange().getSlots().iterator().next();
    connection.clusterDeleteSlots(master, slot);
    connection.clusterAddSlots(master, slot);
}
 

@Override
public void clusterSetSlot(RedisClusterNode node, int slot, AddSlots mode) {
    MasterSlaveEntry entry = getEntry(node);
    RFuture<Map<String, String>> f = executorService.writeAsync(entry, StringCodec.INSTANCE, RedisCommands.CLUSTER_SETSLOT, slot, mode);
    syncFuture(f);
}
 

@Override
public void clusterDeleteSlotsInRange(RedisClusterNode node, SlotRange range) {
  helper.doInScope(CLUSTER_DELSLOTS, () -> connection.clusterDeleteSlotsInRange(node, range));
}
 

@Override
public void bgReWriteAof(RedisClusterNode node) {
    execute(node, RedisCommands.BGREWRITEAOF);
}
 

@Override
public void clusterMeet(RedisClusterNode node) {
  helper.doInScope(CLUSTER_MEET, () -> connection.clusterMeet(node));
}
 

protected RedisClusterNode getFirstMaster() {
    Map<RedisClusterNode, Collection<RedisClusterNode>> map = connection.clusterGetMasterSlaveMap();
    RedisClusterNode master = map.keySet().iterator().next();
    return master;
}
 

@Override
public Long dbSize(RedisClusterNode node) {
    return execute(node, RedisCommands.DBSIZE);
}
 

@Override
public Long dbSize(RedisClusterNode node) {
    return execute(node, RedisCommands.DBSIZE);
}
 

@Test
public void testGetClientList() {
    RedisClusterNode master = getFirstMaster();
    List<RedisClientInfo> list = connection.getClientList(master);
    assertThat(list.size()).isGreaterThan(10);
}
 

@Override
public void clusterAddSlots(RedisClusterNode node, SlotRange range) {
    clusterAddSlots(node, range.getSlotsArray());
}
 

@Test
public void testDbSize() {
    RedisClusterNode master = getFirstMaster();
    Long size = connection.dbSize(master);
    assertThat(size).isZero();
}
 

@Override
public void clusterReplicate(RedisClusterNode master, RedisClusterNode slave) {
    MasterSlaveEntry entry = getEntry(master);
    RFuture<Long> f = executorService.writeAsync(entry, StringCodec.INSTANCE, RedisCommands.CLUSTER_REPLICATE, slave.getId());
    syncFuture(f);
}
 

@Override
public Long time(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    RFuture<Long> f = executorService.readAsync(entry, LongCodec.INSTANCE, RedisCommands.TIME_LONG);
    return syncFuture(f);
}
 

@Override
public Long dbSize(RedisClusterNode node) {
    return execute(node, RedisCommands.DBSIZE);
}