Examples with RedisURI org.redisson.misc.RedisURI used on opensource projects

Example 16 with RedisURI

use of org.redisson.misc.RedisURI in project redisson by redisson.

the class ClusterConnectionManager method addRemoveSlaves.

private Set<RedisURI> addRemoveSlaves(MasterSlaveEntry entry, ClusterPartition currentPart, ClusterPartition newPart) {
    Set<RedisURI> removedSlaves = new HashSet<>(currentPart.getSlaveAddresses());
    removedSlaves.removeAll(newPart.getSlaveAddresses());
    for (RedisURI uri : removedSlaves) {
        currentPart.removeSlaveAddress(uri);
        if (entry.slaveDown(uri, FreezeReason.MANAGER)) {
            log.info("slave {} removed for slot ranges: {}", uri, currentPart.getSlotRanges());
        }
    }
    Set<RedisURI> addedSlaves = new HashSet<>(newPart.getSlaveAddresses());
    addedSlaves.removeAll(currentPart.getSlaveAddresses());
    for (RedisURI uri : addedSlaves) {
        ClientConnectionsEntry slaveEntry = entry.getEntry(uri);
        if (slaveEntry != null) {
            currentPart.addSlaveAddress(uri);
            entry.slaveUp(uri, FreezeReason.MANAGER);
            log.info("slave: {} added for slot ranges: {}", uri, currentPart.getSlotRanges());
            continue;
        }
        CompletableFuture<Void> future = entry.addSlave(uri, false, NodeType.SLAVE, configEndpointHostName);
        future.whenComplete((res, ex) -> {
            if (ex != null) {
                log.error("Can't add slave: " + uri, ex);
                return;
            }
            currentPart.addSlaveAddress(uri);
            entry.slaveUp(uri, FreezeReason.MANAGER);
            log.info("slave: {} added for slot ranges: {}", uri, currentPart.getSlotRanges());
        });
    }
    return addedSlaves;
}

Example 17 with RedisURI

use of org.redisson.misc.RedisURI in project redisson by redisson.

the class ClusterConnectionManager method checkMasterNodesChange.

private CompletableFuture<Void> checkMasterNodesChange(ClusterServersConfig cfg, Collection<ClusterPartition> newPartitions) {
    Map<RedisURI, ClusterPartition> lastPartitions = getLastPartitonsByURI();
    Map<RedisURI, ClusterPartition> addedPartitions = new HashMap<>();
    Set<RedisURI> mastersElected = new HashSet<>();
    for (ClusterPartition newPart : newPartitions) {
        if (newPart.getSlotsAmount() == 0) {
            continue;
        }
        ClusterPartition currentPart = lastPartitions.get(newPart.getMasterAddress());
        boolean masterFound = currentPart != null;
        if (masterFound && newPart.isMasterFail()) {
            for (Integer slot : currentPart.getSlots()) {
                ClusterPartition newMasterPart = find(newPartitions, slot);
                // does partition has a new master?
                if (!Objects.equals(newMasterPart.getMasterAddress(), currentPart.getMasterAddress())) {
                    RedisURI newUri = newMasterPart.getMasterAddress();
                    RedisURI oldUri = currentPart.getMasterAddress();
                    mastersElected.add(newUri);
                    CompletableFuture<RedisClient> future = changeMaster(slot, newUri);
                    currentPart.setMasterAddress(newUri);
                    future.whenComplete((res, e) -> {
                        if (e != null) {
                            currentPart.setMasterAddress(oldUri);
                        } else {
                            disconnectNode(oldUri);
                        }
                    });
                }
            }
        }
        if (!masterFound && !newPart.isMasterFail()) {
            addedPartitions.put(newPart.getMasterAddress(), newPart);
        }
    }
    addedPartitions.keySet().removeAll(mastersElected);
    if (addedPartitions.isEmpty()) {
        return CompletableFuture.completedFuture(null);
    }
    List<CompletableFuture<?>> futures = new ArrayList<>();
    for (ClusterPartition newPart : addedPartitions.values()) {
        CompletableFuture<Void> future = addMasterEntry(newPart, cfg);
        futures.add(future);
    }
    return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).exceptionally(e -> null);
}

Example 18 with RedisURI

use of org.redisson.misc.RedisURI in project redisson by redisson.

the class ClusterConnectionManager method scheduleClusterChangeCheck.

private void scheduleClusterChangeCheck(ClusterServersConfig cfg) {
    monitorFuture = group.schedule(new Runnable() {

        @Override
        public void run() {
            if (configEndpointHostName != null) {
                String address = cfg.getNodeAddresses().iterator().next();
                RedisURI uri = new RedisURI(address);
                AddressResolver<InetSocketAddress> resolver = resolverGroup.getResolver(getGroup().next());
                Future<List<InetSocketAddress>> allNodes = resolver.resolveAll(InetSocketAddress.createUnresolved(uri.getHost(), uri.getPort()));
                allNodes.addListener(new FutureListener<List<InetSocketAddress>>() {

                    @Override
                    public void operationComplete(Future<List<InetSocketAddress>> future) throws Exception {
                        AtomicReference<Throwable> lastException = new AtomicReference<Throwable>(future.cause());
                        if (!future.isSuccess()) {
                            checkClusterState(cfg, Collections.emptyIterator(), lastException);
                            return;
                        }
                        List<RedisURI> nodes = new ArrayList<>();
                        for (InetSocketAddress addr : future.getNow()) {
                            RedisURI address = toURI(uri.getScheme(), addr.getAddress().getHostAddress(), "" + addr.getPort());
                            nodes.add(address);
                        }
                        Iterator<RedisURI> nodesIterator = nodes.iterator();
                        checkClusterState(cfg, nodesIterator, lastException);
                    }
                });
            } else {
                AtomicReference<Throwable> lastException = new AtomicReference<Throwable>();
                List<RedisURI> nodes = new ArrayList<>();
                List<RedisURI> slaves = new ArrayList<>();
                for (ClusterPartition partition : getLastPartitions()) {
                    if (!partition.isMasterFail()) {
                        nodes.add(partition.getMasterAddress());
                    }
                    Set<RedisURI> partitionSlaves = new HashSet<>(partition.getSlaveAddresses());
                    partitionSlaves.removeAll(partition.getFailedSlaveAddresses());
                    slaves.addAll(partitionSlaves);
                }
                Collections.shuffle(nodes);
                Collections.shuffle(slaves);
                // master nodes first
                nodes.addAll(slaves);
                Iterator<RedisURI> nodesIterator = nodes.iterator();
                checkClusterState(cfg, nodesIterator, lastException);
            }
        }
    }, cfg.getScanInterval(), TimeUnit.MILLISECONDS);
}

Example 19 with RedisURI

use of org.redisson.misc.RedisURI in project redisson by redisson.

the class MasterSlaveConnectionManager method connectToNode.

protected final CompletionStage<RedisConnection> connectToNode(NodeType type, BaseConfig<?> cfg, RedisURI addr, String sslHostname) {
    RedisConnection conn = nodeConnections.get(addr);
    if (conn != null) {
        if (!conn.isActive()) {
            closeNodeConnection(conn);
        } else {
            return CompletableFuture.completedFuture(conn);
        }
    }
    RedisClient client = createClient(type, addr, cfg.getConnectTimeout(), cfg.getTimeout(), sslHostname);
    CompletionStage<RedisConnection> future = client.connectAsync();
    return future.thenCompose(connection -> {
        if (connection.isActive()) {
            if (!addr.isIP()) {
                RedisURI address = new RedisURI(addr.getScheme() + "://" + connection.getRedisClient().getAddr().getAddress().getHostAddress() + ":" + connection.getRedisClient().getAddr().getPort());
                nodeConnections.put(address, connection);
            }
            nodeConnections.put(addr, connection);
            return CompletableFuture.completedFuture(connection);
        } else {
            connection.closeAsync();
            CompletableFuture<RedisConnection> f = new CompletableFuture<>();
            f.completeExceptionally(new RedisException("Connection to " + connection.getRedisClient().getAddr() + " is not active!"));
            return f;
        }
    });
}

Example 20 with RedisURI

use of org.redisson.misc.RedisURI in project redisson by redisson.

the class MasterSlaveConnectionManager method resolveIP.

protected CompletableFuture<RedisURI> resolveIP(String scheme, RedisURI address) {
    if (address.isIP()) {
        RedisURI addr = applyNatMap(address);
        return CompletableFuture.completedFuture(addr);
    }
    CompletableFuture<RedisURI> result = new CompletableFuture<>();
    AddressResolver<InetSocketAddress> resolver = resolverGroup.getResolver(getGroup().next());
    InetSocketAddress addr = InetSocketAddress.createUnresolved(address.getHost(), address.getPort());
    Future<InetSocketAddress> future = resolver.resolve(addr);
    future.addListener((FutureListener<InetSocketAddress>) f -> {
        if (!f.isSuccess()) {
            log.error("Unable to resolve " + address, f.cause());
            result.completeExceptionally(f.cause());
            return;
        }
        InetSocketAddress s = f.getNow();
        RedisURI uri = toURI(scheme, s.getAddress().getHostAddress(), "" + address.getPort());
        result.complete(uri);
    });
    return result;
}