io.lettuce.core.sentinel.RedisSentinelReactiveCommandsImpl 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!
/*
 * Copyright 2011-Present, Redis Ltd. and Contributors
 * All rights reserved.
 *
 * Licensed under the MIT License.
 *
 * This file contains contributions from third-party contributors
 * licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.lettuce.core.sentinel;

import java.net.SocketAddress;
import java.util.Map;

import io.lettuce.core.AbstractRedisReactiveCommands;
import io.lettuce.core.ClientListArgs;
import io.lettuce.core.KillArgs;
import io.lettuce.core.api.StatefulConnection;
import io.lettuce.core.codec.RedisCodec;
import io.lettuce.core.internal.LettuceAssert;
import io.lettuce.core.json.JsonParser;
import io.lettuce.core.output.CommandOutput;
import io.lettuce.core.protocol.Command;
import io.lettuce.core.protocol.CommandArgs;
import io.lettuce.core.protocol.ProtocolKeyword;
import io.lettuce.core.sentinel.api.StatefulRedisSentinelConnection;
import io.lettuce.core.sentinel.api.reactive.RedisSentinelReactiveCommands;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * A reactive and thread-safe API for a Redis Sentinel connection.
 *
 * @param  Key type.
 * @param  Value type.
 * @author Mark Paluch
 * @since 3.0
 */
public class RedisSentinelReactiveCommandsImpl extends AbstractRedisReactiveCommands
        implements RedisSentinelReactiveCommands {

    private final SentinelCommandBuilder commandBuilder;

    public RedisSentinelReactiveCommandsImpl(StatefulConnection connection, RedisCodec codec,
            Mono parser) {
        super(connection, codec, parser);
        commandBuilder = new SentinelCommandBuilder(codec);
    }

    @Override
    public Mono getMasterAddrByName(K key) {
        return createMono(() -> commandBuilder.getMasterAddrByKey(key));
    }

    @Override
    public Flux> masters() {
        return createDissolvingFlux(commandBuilder::masters);
    }

    @Override
    public Mono> master(K key) {
        return createMono(() -> commandBuilder.master(key));
    }

    @Override
    public Flux> slaves(K key) {
        return createDissolvingFlux(() -> commandBuilder.slaves(key));
    }

    @Override
    public Flux> replicas(K key) {
        return createDissolvingFlux(() -> commandBuilder.replicas(key));
    }

    @Override
    public Mono reset(K key) {
        return createMono(() -> commandBuilder.reset(key));
    }

    @Override
    public Mono failover(K key) {
        return createMono(() -> commandBuilder.failover(key));
    }

    @Override
    public Mono monitor(K key, String ip, int port, int quorum) {
        return createMono(() -> commandBuilder.monitor(key, ip, port, quorum));
    }

    @Override
    public Mono set(K key, String option, V value) {
        return createMono(() -> commandBuilder.set(key, option, value));
    }

    @Override
    public Mono remove(K key) {
        return createMono(() -> commandBuilder.remove(key));
    }

    @Override
    public Mono ping() {
        return createMono(commandBuilder::ping);
    }

    @Override
    public Mono clientGetname() {
        return createMono(commandBuilder::clientGetname);
    }

    @Override
    public Mono clientSetname(K name) {
        return createMono(() -> commandBuilder.clientSetname(name));
    }

    @Override
    public Mono clientSetinfo(String key, String value) {
        return createMono(() -> commandBuilder.clientSetinfo(key, value));
    }

    @Override
    public Mono clientKill(String addr) {
        return createMono(() -> commandBuilder.clientKill(addr));
    }

    @Override
    public Mono clientKill(KillArgs killArgs) {
        return createMono(() -> commandBuilder.clientKill(killArgs));
    }

    @Override
    public Mono clientPause(long timeout) {
        return createMono(() -> commandBuilder.clientPause(timeout));
    }

    @Override
    public Mono clientList() {
        return createMono(commandBuilder::clientList);
    }

    @Override
    public Mono clientList(ClientListArgs clientListArgs) {
        return createMono(() -> commandBuilder.clientList(clientListArgs));
    }

    @Override
    public Mono clientInfo() {
        return createMono(commandBuilder::clientInfo);
    }

    @Override
    public Mono info() {
        return createMono(commandBuilder::info);
    }

    @Override
    public Mono info(String section) {
        return createMono(() -> commandBuilder.info(section));
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public  Flux dispatch(ProtocolKeyword type, CommandOutput output) {

        LettuceAssert.notNull(type, "Command type must not be null");
        LettuceAssert.notNull(output, "CommandOutput type must not be null");

        return (Flux) createFlux(() -> new Command<>(type, output));
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public  Flux dispatch(ProtocolKeyword type, CommandOutput output, CommandArgs args) {

        LettuceAssert.notNull(type, "Command type must not be null");
        LettuceAssert.notNull(output, "CommandOutput type must not be null");
        LettuceAssert.notNull(args, "CommandArgs type must not be null");

        return (Flux) createFlux(() -> new Command<>(type, output, args));
    }

    @Override
    public void close() {
        getStatefulConnection().close();
    }

    @Override
    public boolean isOpen() {
        return getStatefulConnection().isOpen();
    }

    @Override
    public StatefulRedisSentinelConnection getStatefulConnection() {
        return (StatefulRedisSentinelConnection) super.getConnection();
    }

}