com.lambdaworks.redis.AbstractRedisAsyncCommands Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of lettuce Show documentation
Show all versions of lettuce 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.
/*
* Copyright 2011-2017 the original author or authors.
*
* 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
*
* http://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 com.lambdaworks.redis;
import static com.lambdaworks.redis.protocol.CommandType.*;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import com.lambdaworks.redis.GeoArgs.Unit;
import com.lambdaworks.redis.api.StatefulConnection;
import com.lambdaworks.redis.api.async.*;
import com.lambdaworks.redis.cluster.api.async.RedisClusterAsyncCommands;
import com.lambdaworks.redis.codec.RedisCodec;
import com.lambdaworks.redis.internal.LettuceAssert;
import com.lambdaworks.redis.output.*;
import com.lambdaworks.redis.protocol.*;
/**
* An asynchronous and thread-safe API for a Redis connection.
*
* @param Key type.
* @param Value type.
* @author Will Glozer
*/
public abstract class AbstractRedisAsyncCommands
implements RedisHashesAsyncConnection, RedisKeysAsyncConnection, RedisStringsAsyncConnection,
RedisListsAsyncConnection, RedisSetsAsyncConnection, RedisSortedSetsAsyncConnection,
RedisScriptingAsyncConnection, RedisServerAsyncConnection, RedisHLLAsyncConnection,
BaseRedisAsyncConnection, RedisClusterAsyncConnection, RedisGeoAsyncConnection,
RedisHashAsyncCommands, RedisKeyAsyncCommands, RedisStringAsyncCommands, RedisListAsyncCommands,
RedisSetAsyncCommands, RedisSortedSetAsyncCommands, RedisScriptingAsyncCommands,
RedisServerAsyncCommands, RedisHLLAsyncCommands, BaseRedisAsyncCommands,
RedisTransactionalAsyncCommands, RedisGeoAsyncCommands, RedisClusterAsyncCommands {
protected MultiOutput multi;
protected RedisCommandBuilder commandBuilder;
protected RedisCodec codec;
protected StatefulConnection connection;
/**
* Initialize a new instance.
*
* @param connection the connection to operate on
* @param codec the codec for command encoding
*/
public AbstractRedisAsyncCommands(StatefulConnection connection, RedisCodec codec) {
this.connection = connection;
this.codec = codec;
commandBuilder = new RedisCommandBuilder<>(codec);
}
@Override
public RedisFuture append(K key, V value) {
return dispatch(commandBuilder.append(key, value));
}
@Override
public String auth(String password) {
LettuceAssert.notNull(password, "Password must not be null");
AsyncCommand cmd = authAsync(password.toCharArray());
return LettuceFutures.awaitOrCancel(cmd, connection.getTimeout(), connection.getTimeoutUnit());
}
public AsyncCommand authAsync(char[] password) {
return dispatch(commandBuilder.auth(password));
}
@Override
public RedisFuture bgrewriteaof() {
return dispatch(commandBuilder.bgrewriteaof());
}
@Override
public RedisFuture bgsave() {
return dispatch(commandBuilder.bgsave());
}
@Override
public RedisFuture bitcount(K key) {
return dispatch(commandBuilder.bitcount(key));
}
@Override
public RedisFuture bitcount(K key, long start, long end) {
return dispatch(commandBuilder.bitcount(key, start, end));
}
@Override
public RedisFuture> bitfield(K key, BitFieldArgs bitFieldArgs) {
return dispatch(commandBuilder.bitfield(key, bitFieldArgs));
}
@Override
public RedisFuture bitpos(K key, boolean state) {
return dispatch(commandBuilder.bitpos(key, state));
}
@Override
public RedisFuture bitpos(K key, boolean state, long start, long end) {
return dispatch(commandBuilder.bitpos(key, state, start, end));
}
@Override
public RedisFuture bitopAnd(K destination, K... keys) {
return dispatch(commandBuilder.bitopAnd(destination, keys));
}
@Override
public RedisFuture bitopNot(K destination, K source) {
return dispatch(commandBuilder.bitopNot(destination, source));
}
@Override
public RedisFuture bitopOr(K destination, K... keys) {
return dispatch(commandBuilder.bitopOr(destination, keys));
}
@Override
public RedisFuture bitopXor(K destination, K... keys) {
return dispatch(commandBuilder.bitopXor(destination, keys));
}
@Override
public RedisFuture> blpop(long timeout, K... keys) {
return dispatch(commandBuilder.blpop(timeout, keys));
}
@Override
public RedisFuture> brpop(long timeout, K... keys) {
return dispatch(commandBuilder.brpop(timeout, keys));
}
@Override
public RedisFuture brpoplpush(long timeout, K source, K destination) {
return dispatch(commandBuilder.brpoplpush(timeout, source, destination));
}
@Override
public RedisFuture clientGetname() {
return dispatch(commandBuilder.clientGetname());
}
@Override
public RedisFuture clientSetname(K name) {
return dispatch(commandBuilder.clientSetname(name));
}
@Override
public RedisFuture clientKill(String addr) {
return dispatch(commandBuilder.clientKill(addr));
}
@Override
public RedisFuture clientKill(KillArgs killArgs) {
return dispatch(commandBuilder.clientKill(killArgs));
}
@Override
public RedisFuture clientPause(long timeout) {
return dispatch(commandBuilder.clientPause(timeout));
}
@Override
public RedisFuture clientList() {
return dispatch(commandBuilder.clientList());
}
@Override
public RedisFuture> command() {
return dispatch(commandBuilder.command());
}
@Override
public RedisFuture> commandInfo(String... commands) {
return dispatch(commandBuilder.commandInfo(commands));
}
@Override
public RedisFuture> commandInfo(CommandType... commands) {
String[] stringCommands = new String[commands.length];
for (int i = 0; i < commands.length; i++) {
stringCommands[i] = commands[i].name();
}
return commandInfo(stringCommands);
}
@Override
public RedisFuture commandCount() {
return dispatch(commandBuilder.commandCount());
}
@Override
public RedisFuture> configGet(String parameter) {
return dispatch(commandBuilder.configGet(parameter));
}
@Override
public RedisFuture configResetstat() {
return dispatch(commandBuilder.configResetstat());
}
@Override
public RedisFuture configSet(String parameter, String value) {
return dispatch(commandBuilder.configSet(parameter, value));
}
@Override
public RedisFuture configRewrite() {
return dispatch(commandBuilder.configRewrite());
}
@Override
public RedisFuture dbsize() {
return dispatch(commandBuilder.dbsize());
}
@Override
public RedisFuture debugCrashAndRecover(Long delay) {
return dispatch(commandBuilder.debugCrashAndRecover(delay));
}
@Override
public RedisFuture debugHtstats(int db) {
return dispatch(commandBuilder.debugHtstats(db));
}
@Override
public RedisFuture debugObject(K key) {
return dispatch(commandBuilder.debugObject(key));
}
@Override
public void debugOom() {
dispatch(commandBuilder.debugOom());
}
@Override
public RedisFuture debugReload() {
return dispatch(commandBuilder.debugReload());
}
@Override
public RedisFuture debugRestart(Long delay) {
return dispatch(commandBuilder.debugRestart(delay));
}
@Override
public RedisFuture debugSdslen(K key) {
return dispatch(commandBuilder.debugSdslen(key));
}
@Override
public void debugSegfault() {
dispatch(commandBuilder.debugSegfault());
}
@Override
public RedisFuture decr(K key) {
return dispatch(commandBuilder.decr(key));
}
@Override
public RedisFuture decrby(K key, long amount) {
return dispatch(commandBuilder.decrby(key, amount));
}
@Override
public RedisFuture del(K... keys) {
return dispatch(commandBuilder.del(keys));
}
public RedisFuture del(Iterable keys) {
return dispatch(commandBuilder.del(keys));
}
@Override
public RedisFuture unlink(K... keys) {
return dispatch(commandBuilder.unlink(keys));
}
public RedisFuture unlink(Iterable keys) {
return dispatch(commandBuilder.unlink(keys));
}
@Override
public RedisFuture discard() {
return dispatch(commandBuilder.discard());
}
@Override
public RedisFuture dump(K key) {
return dispatch(commandBuilder.dump(key));
}
@Override
public RedisFuture echo(V msg) {
return dispatch(commandBuilder.echo(msg));
}
@Override
@SuppressWarnings("unchecked")
public RedisFuture eval(String script, ScriptOutputType type, K... keys) {
return (RedisFuture) dispatch(commandBuilder.eval(script, type, keys));
}
@Override
@SuppressWarnings("unchecked")
public RedisFuture eval(String script, ScriptOutputType type, K[] keys, V... values) {
return (RedisFuture) dispatch(commandBuilder.eval(script, type, keys, values));
}
@Override
@SuppressWarnings("unchecked")
public RedisFuture evalsha(String digest, ScriptOutputType type, K... keys) {
return (RedisFuture) dispatch(commandBuilder.evalsha(digest, type, keys));
}
@Override
@SuppressWarnings("unchecked")
public RedisFuture evalsha(String digest, ScriptOutputType type, K[] keys, V... values) {
return (RedisFuture) dispatch(commandBuilder.evalsha(digest, type, keys, values));
}
@Override
public RedisFuture exists(K key) {
return dispatch(commandBuilder.exists(key));
}
@Override
public RedisFuture exists(K... keys) {
return dispatch(commandBuilder.exists(keys));
}
public RedisFuture exists(Iterable keys) {
return dispatch(commandBuilder.exists(keys));
}
@Override
public RedisFuture expire(K key, long seconds) {
return dispatch(commandBuilder.expire(key, seconds));
}
@Override
public RedisFuture expireat(K key, Date timestamp) {
return expireat(key, timestamp.getTime() / 1000);
}
@Override
public RedisFuture expireat(K key, long timestamp) {
return dispatch(commandBuilder.expireat(key, timestamp));
}
@Override
public RedisFuture> exec() {
return dispatch(EXEC, null);
}
@Override
public RedisFuture flushall() {
return dispatch(commandBuilder.flushall());
}
@Override
public RedisFuture flushallAsync() {
return dispatch(commandBuilder.flushallAsync());
}
@Override
public RedisFuture flushdb() {
return dispatch(commandBuilder.flushdb());
}
@Override
public RedisFuture flushdbAsync() {
return dispatch(commandBuilder.flushdbAsync());
}
@Override
public RedisFuture get(K key) {
return dispatch(commandBuilder.get(key));
}
@Override
public RedisFuture getbit(K key, long offset) {
return dispatch(commandBuilder.getbit(key, offset));
}
@Override
public RedisFuture getrange(K key, long start, long end) {
return dispatch(commandBuilder.getrange(key, start, end));
}
@Override
public RedisFuture getset(K key, V value) {
return dispatch(commandBuilder.getset(key, value));
}
@Override
public RedisFuture hdel(K key, K... fields) {
return dispatch(commandBuilder.hdel(key, fields));
}
@Override
public RedisFuture hexists(K key, K field) {
return dispatch(commandBuilder.hexists(key, field));
}
@Override
public RedisFuture hget(K key, K field) {
return dispatch(commandBuilder.hget(key, field));
}
@Override
public RedisFuture hincrby(K key, K field, long amount) {
return dispatch(commandBuilder.hincrby(key, field, amount));
}
@Override
public RedisFuture hincrbyfloat(K key, K field, double amount) {
return dispatch(commandBuilder.hincrbyfloat(key, field, amount));
}
@Override
public RedisFuture