io.lettuce.core.masterreplica.Requests Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of lettuce-core Show documentation

Advanced and thread-safe Java Redis client for synchronous, asynchronous, and reactive usage. Supports Cluster, Sentinel, Pipelining, Auto-Reconnect, Codecs and much more.

The newest version!

package io.lettuce.core.masterreplica;

import static io.lettuce.core.masterreplica.ReplicaUtils.findNodeByUri;
import static io.lettuce.core.masterreplica.TopologyComparators.LatencyComparator;

import java.util.*;

import reactor.util.function.Tuple2;
import reactor.util.function.Tuples;
import io.lettuce.core.RedisURI;
import io.lettuce.core.masterreplica.TopologyComparators.SortAction;
import io.lettuce.core.models.role.RedisNodeDescription;

/**
 * Encapsulates asynchronously executed commands to multiple {@link RedisURI nodes}.
 *
 * @author Mark Paluch
 */
class Requests extends
        CompletableEventLatchSupport>, List> {

    private final Map> rawViews = new TreeMap<>(
            ReplicaUtils.RedisURIComparator.INSTANCE);

    private final List nodes;

    public Requests(int expectedCount, List nodes) {
        super(expectedCount);
        this.nodes = nodes;
    }

    protected void addRequest(RedisURI redisURI, TimedAsyncCommand command) {

        rawViews.put(redisURI, command);
        command.onComplete((s, throwable) -> {

            if (throwable != null) {
                accept(throwable);
            } else {
                accept(Tuples.of(redisURI, command));
            }
        });
    }

    @Override
    protected void onEmit(Emission> emission) {

        List result = new ArrayList<>();

        Map latencies = new HashMap<>();

        for (RedisNodeDescription node : nodes) {

            TimedAsyncCommand future = getRequest(node.getUri());

            if (future == null || !future.isDone()) {
                continue;
            }

            RedisNodeDescription redisNodeDescription = findNodeByUri(nodes, node.getUri());
            latencies.put(redisNodeDescription, future.duration());
            result.add(redisNodeDescription);
        }

        SortAction sortAction = SortAction.getSortAction();
        sortAction.sort(result, new LatencyComparator(latencies));

        emission.success(result);
    }

    protected Set nodes() {
        return rawViews.keySet();
    }

    protected TimedAsyncCommand getRequest(RedisURI redisURI) {
        return rawViews.get(redisURI);
    }

}