com.lambdaworks.redis

Class RedisAsyncConnection<K,V>

java.lang.Object

io.netty.channel.ChannelHandlerAdapter

io.netty.channel.ChannelInboundHandlerAdapter

com.lambdaworks.redis.RedisAsyncConnection<K,V>

All Implemented Interfaces:

io.netty.channel.ChannelHandler, io.netty.channel.ChannelInboundHandler

Direct Known Subclasses:

RedisPubSubConnection

@ChannelHandler.Sharable
public class RedisAsyncConnection<K,V>
extends io.netty.channel.ChannelInboundHandlerAdapter

An asynchronous thread-safe connection to a redis server. Multiple threads may share one RedisAsyncConnection provided they avoid blocking and transactional operations such as blpop(long, K...) and multi()/exec(). A ConnectionWatchdog monitors each connection and reconnects automatically until close() is called. All pending commands will be (re)sent after successful reconnection.

Author:

Will Glozer

Nested Class Summary

Nested classes/interfaces inherited from interface io.netty.channel.ChannelHandler

io.netty.channel.ChannelHandler.Sharable

Field Summary

Fields

Modifier and Type	Field and Description
protected io.netty.channel.Channel	channel
protected RedisCodec<K,V>	codec
protected MultiOutput<K,V>	multi
protected BlockingQueue<Command<K,V,?>>	queue
protected long	timeout
protected TimeUnit	unit

Constructor Summary

Constructors

Constructor and Description
RedisAsyncConnection(RedisClient redisClient, BlockingQueue<Command<K,V,?>> queue, RedisCodec<K,V> codec, long timeout, TimeUnit unit, io.netty.channel.EventLoopGroup eventLoopGroup) Initialize a new connection.

Method Summary

Methods

Modifier and Type	Method and Description
io.netty.util.concurrent.Future<Long>	append(K key, V value)
String	auth(String password)
<T> T	await(io.netty.util.concurrent.Future<T> cmd, long timeout, TimeUnit unit)
boolean	awaitAll(io.netty.util.concurrent.Future<?>... futures) Wait until commands are complete or the connection timeout is reached.
boolean	awaitAll(long timeout, TimeUnit unit, io.netty.util.concurrent.Future<?>... futures) Wait until futures are complete or the supplied timeout is reached.
io.netty.util.concurrent.Future<String>	bgrewriteaof()
io.netty.util.concurrent.Future<String>	bgsave()
io.netty.util.concurrent.Future<Long>	bitcount(K key)
io.netty.util.concurrent.Future<Long>	bitcount(K key, long start, long end)
io.netty.util.concurrent.Future<Long>	bitopAnd(K destination, K... keys)
io.netty.util.concurrent.Future<Long>	bitopNot(K destination, K source)
io.netty.util.concurrent.Future<Long>	bitopOr(K destination, K... keys)
io.netty.util.concurrent.Future<Long>	bitopXor(K destination, K... keys)
io.netty.util.concurrent.Future<KeyValue<K,V>>	blpop(long timeout, K... keys)
io.netty.util.concurrent.Future<KeyValue<K,V>>	brpop(long timeout, K... keys)
io.netty.util.concurrent.Future<V>	brpoplpush(long timeout, K source, K destination)
void	channelActive(io.netty.channel.ChannelHandlerContext ctx)
void	channelInactive(io.netty.channel.ChannelHandlerContext ctx)
io.netty.util.concurrent.Future<K>	clientGetname()
io.netty.util.concurrent.Future<String>	clientKill(String addr)
io.netty.util.concurrent.Future<String>	clientList()
io.netty.util.concurrent.Future<String>	clientSetname(K name)
void	close() Close the connection.
io.netty.util.concurrent.Future<List<String>>	configGet(String parameter)
io.netty.util.concurrent.Future<String>	configResetstat()
io.netty.util.concurrent.Future<String>	configSet(String parameter, String value)
io.netty.util.concurrent.Future<Long>	dbsize()
io.netty.util.concurrent.Future<String>	debugObject(K key)
io.netty.util.concurrent.Future<Long>	decr(K key)
io.netty.util.concurrent.Future<Long>	decrby(K key, long amount)
io.netty.util.concurrent.Future<Long>	del(K... keys)
String	digest(V script)
io.netty.util.concurrent.Future<String>	discard()
<T> io.netty.util.concurrent.Future<T>	dispatch(CommandType type, CommandOutput<K,V,T> output)
<T> io.netty.util.concurrent.Future<T>	dispatch(CommandType type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)
<T> io.netty.util.concurrent.Future<T>	dispatch(CommandType type, CommandOutput<K,V,T> output, K key)
<T> io.netty.util.concurrent.Future<T>	dispatch(CommandType type, CommandOutput<K,V,T> output, K key, V value)
<T> io.netty.util.concurrent.Future<T>	dispatch(CommandType type, CommandOutput<K,V,T> output, K key, V[] values)
io.netty.util.concurrent.Future<byte[]>	dump(K key)
io.netty.util.concurrent.Future<V>	echo(V msg)
<T> io.netty.util.concurrent.Future<T>	eval(V script, ScriptOutputType type, K[] keys, V... values)
<T> io.netty.util.concurrent.Future<T>	evalsha(String digest, ScriptOutputType type, K[] keys, V... values)
io.netty.util.concurrent.Future<List<Object>>	exec()
io.netty.util.concurrent.Future<Boolean>	exists(K key)
io.netty.util.concurrent.Future<Boolean>	expire(K key, long seconds)
io.netty.util.concurrent.Future<Boolean>	expireat(K key, Date timestamp)
io.netty.util.concurrent.Future<Boolean>	expireat(K key, long timestamp)
io.netty.util.concurrent.Future<String>	flushall()
io.netty.util.concurrent.Future<String>	flushdb()
io.netty.util.concurrent.Future<V>	get(K key)
io.netty.util.concurrent.Future<Long>	getbit(K key, long offset)
io.netty.util.concurrent.Future<List<V>>	getMasterAddrByKey(K name)
io.netty.util.concurrent.Future<V>	getrange(K key, long start, long end)
RedisClient	getRedisClient()
io.netty.util.concurrent.Future<V>	getset(K key, V value)
io.netty.util.concurrent.Future<Long>	hdel(K key, K... fields)
io.netty.util.concurrent.Future<Boolean>	hexists(K key, K field)
io.netty.util.concurrent.Future<V>	hget(K key, K field)
io.netty.util.concurrent.Future<Map<K,V>>	hgetall(K key)
io.netty.util.concurrent.Future<Long>	hincrby(K key, K field, long amount)
io.netty.util.concurrent.Future<Double>	hincrbyfloat(K key, K field, double amount)
io.netty.util.concurrent.Future<Set<K>>	hkeys(K key)
io.netty.util.concurrent.Future<Long>	hlen(K key)
io.netty.util.concurrent.Future<List<V>>	hmget(K key, K... fields)
io.netty.util.concurrent.Future<String>	hmset(K key, Map<K,V> map)
io.netty.util.concurrent.Future<Boolean>	hset(K key, K field, V value)
io.netty.util.concurrent.Future<Boolean>	hsetnx(K key, K field, V value)
io.netty.util.concurrent.Future<List<V>>	hvals(K key)
io.netty.util.concurrent.Future<Long>	incr(K key)
io.netty.util.concurrent.Future<Long>	incrby(K key, long amount)
io.netty.util.concurrent.Future<Double>	incrbyfloat(K key, double amount)
io.netty.util.concurrent.Future<String>	info()
io.netty.util.concurrent.Future<String>	info(String section)
boolean	isMultiMode()
io.netty.util.concurrent.Future<List<K>>	keys(K pattern)
io.netty.util.concurrent.Future<Date>	lastsave()
io.netty.util.concurrent.Future<V>	lindex(K key, long index)
io.netty.util.concurrent.Future<Long>	linsert(K key, boolean before, V pivot, V value)
io.netty.util.concurrent.Future<Long>	llen(K key)
io.netty.util.concurrent.Future<V>	lpop(K key)
io.netty.util.concurrent.Future<Long>	lpush(K key, V... values)
io.netty.util.concurrent.Future<Long>	lpushx(K key, V value)
io.netty.util.concurrent.Future<List<V>>	lrange(K key, long start, long stop)
io.netty.util.concurrent.Future<Long>	lrem(K key, long count, V value)
io.netty.util.concurrent.Future<String>	lset(K key, long index, V value)
io.netty.util.concurrent.Future<String>	ltrim(K key, long start, long stop)
io.netty.util.concurrent.Future<List<V>>	mget(K... keys)
io.netty.util.concurrent.Future<String>	migrate(String host, int port, K key, int db, long timeout)
io.netty.util.concurrent.Future<Boolean>	move(K key, int db)
io.netty.util.concurrent.Future<String>	mset(Map<K,V> map)
io.netty.util.concurrent.Future<Boolean>	msetnx(Map<K,V> map)
io.netty.util.concurrent.Future<String>	multi()
protected <K,V,T> CommandOutput<K,V,T>	newScriptOutput(RedisCodec<K,V> codec, ScriptOutputType type)
io.netty.util.concurrent.Future<String>	objectEncoding(K key)
io.netty.util.concurrent.Future<Long>	objectIdletime(K key)
io.netty.util.concurrent.Future<Long>	objectRefcount(K key)
io.netty.util.concurrent.Future<Boolean>	persist(K key)
io.netty.util.concurrent.Future<Boolean>	pexpire(K key, long milliseconds)
io.netty.util.concurrent.Future<Boolean>	pexpireat(K key, Date timestamp)
io.netty.util.concurrent.Future<Boolean>	pexpireat(K key, long timestamp)
io.netty.util.concurrent.Future<Long>	pfadd(K key, V... values)
io.netty.util.concurrent.Future<Long>	pfcount(K key, K... keys)
io.netty.util.concurrent.Future<Long>	pfmerge(K destkey, K... sourceKeys)
io.netty.util.concurrent.Future<String>	ping()
io.netty.util.concurrent.Future<Long>	pttl(K key)
io.netty.util.concurrent.Future<Long>	publish(K channel, V message)
io.netty.util.concurrent.Future<String>	quit()
io.netty.util.concurrent.Future<V>	randomkey()
io.netty.util.concurrent.Future<String>	rename(K key, K newKey)
io.netty.util.concurrent.Future<Boolean>	renamenx(K key, K newKey)
io.netty.util.concurrent.Future<String>	restore(K key, long ttl, byte[] value)
io.netty.util.concurrent.Future<V>	rpop(K key)
io.netty.util.concurrent.Future<V>	rpoplpush(K source, K destination)
io.netty.util.concurrent.Future<Long>	rpush(K key, V... values)
io.netty.util.concurrent.Future<Long>	rpushx(K key, V value)
io.netty.util.concurrent.Future<Long>	sadd(K key, V... members)
io.netty.util.concurrent.Future<String>	save()
io.netty.util.concurrent.Future<Long>	scard(K key)
io.netty.util.concurrent.Future<List<Boolean>>	scriptExists(String... digests)
io.netty.util.concurrent.Future<String>	scriptFlush()
io.netty.util.concurrent.Future<String>	scriptKill()
io.netty.util.concurrent.Future<String>	scriptLoad(V script)
io.netty.util.concurrent.Future<Set<V>>	sdiff(K... keys)
io.netty.util.concurrent.Future<Long>	sdiffstore(K destination, K... keys)
String	select(int db)
io.netty.util.concurrent.Future<String>	set(K key, V value)
io.netty.util.concurrent.Future<Long>	setbit(K key, long offset, int value)
io.netty.util.concurrent.Future<String>	setex(K key, long seconds, V value)
io.netty.util.concurrent.Future<Boolean>	setnx(K key, V value)
io.netty.util.concurrent.Future<Long>	setrange(K key, long offset, V value)
void	setTimeout(long timeout, TimeUnit unit) Set the command timeout for this connection.
void	shutdown() Deprecated.
void	shutdown(boolean save)
io.netty.util.concurrent.Future<Set<V>>	sinter(K... keys)
io.netty.util.concurrent.Future<Long>	sinterstore(K destination, K... keys)
io.netty.util.concurrent.Future<Boolean>	sismember(K key, V member)
io.netty.util.concurrent.Future<String>	slaveof(String host, int port)
io.netty.util.concurrent.Future<String>	slaveofNoOne()
io.netty.util.concurrent.Future<List<Map<K,V>>>	slaves(K key)
io.netty.util.concurrent.Future<List<Object>>	slowlogGet()
io.netty.util.concurrent.Future<List<Object>>	slowlogGet(int count)
io.netty.util.concurrent.Future<Long>	slowlogLen()
io.netty.util.concurrent.Future<String>	slowlogReset()
io.netty.util.concurrent.Future<Set<V>>	smembers(K key)
io.netty.util.concurrent.Future<Boolean>	smove(K source, K destination, V member)
io.netty.util.concurrent.Future<List<V>>	sort(K key)
io.netty.util.concurrent.Future<List<V>>	sort(K key, SortArgs sortArgs)
io.netty.util.concurrent.Future<Long>	sortStore(K key, SortArgs sortArgs, K destination)
io.netty.util.concurrent.Future<V>	spop(K key)
io.netty.util.concurrent.Future<V>	srandmember(K key)
io.netty.util.concurrent.Future<Set<V>>	srandmember(K key, long count)
io.netty.util.concurrent.Future<Long>	srem(K key, V... members)
io.netty.util.concurrent.Future<ScanResult<V>>	sscan(K key, long startValue)
String	string(double n)
io.netty.util.concurrent.Future<Long>	strlen(K key)
io.netty.util.concurrent.Future<Set<V>>	sunion(K... keys)
io.netty.util.concurrent.Future<Long>	sunionstore(K destination, K... keys)
io.netty.util.concurrent.Future<String>	sync()
io.netty.util.concurrent.Future<Long>	ttl(K key)
io.netty.util.concurrent.Future<String>	type(K key)
io.netty.util.concurrent.Future<String>	unwatch()
io.netty.util.concurrent.Future<String>	watch(K... keys)
io.netty.util.concurrent.Future<Long>	zadd(K key, double score, V member)
io.netty.util.concurrent.Future<Long>	zadd(K key, Object... scoresAndValues)
io.netty.util.concurrent.Future<Long>	zcard(K key)
io.netty.util.concurrent.Future<Long>	zcount(K key, double min, double max)
io.netty.util.concurrent.Future<Long>	zcount(K key, String min, String max)
io.netty.util.concurrent.Future<Double>	zincrby(K key, double amount, K member)
io.netty.util.concurrent.Future<Long>	zinterstore(K destination, K... keys)
io.netty.util.concurrent.Future<Long>	zinterstore(K destination, ZStoreArgs storeArgs, K... keys)
io.netty.util.concurrent.Future<List<V>>	zrange(K key, long start, long stop)
io.netty.util.concurrent.Future<List<V>>	zrangebyscore(K key, double min, double max)
io.netty.util.concurrent.Future<List<V>>	zrangebyscore(K key, double min, double max, long offset, long count)
io.netty.util.concurrent.Future<List<V>>	zrangebyscore(K key, String min, String max)
io.netty.util.concurrent.Future<List<V>>	zrangebyscore(K key, String min, String max, long offset, long count)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrangebyscoreWithScores(K key, double min, double max)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrangebyscoreWithScores(K key, double min, double max, long offset, long count)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrangebyscoreWithScores(K key, String min, String max)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrangebyscoreWithScores(K key, String min, String max, long offset, long count)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrangeWithScores(K key, long start, long stop)
io.netty.util.concurrent.Future<Long>	zrank(K key, V member)
io.netty.util.concurrent.Future<Long>	zrem(K key, V... members)
io.netty.util.concurrent.Future<Long>	zremrangebyrank(K key, long start, long stop)
io.netty.util.concurrent.Future<Long>	zremrangebyscore(K key, double min, double max)
io.netty.util.concurrent.Future<Long>	zremrangebyscore(K key, String min, String max)
io.netty.util.concurrent.Future<List<V>>	zrevrange(K key, long start, long stop)
io.netty.util.concurrent.Future<List<V>>	zrevrangebyscore(K key, double max, double min)
io.netty.util.concurrent.Future<List<V>>	zrevrangebyscore(K key, double max, double min, long offset, long count)
io.netty.util.concurrent.Future<List<V>>	zrevrangebyscore(K key, String max, String min)
io.netty.util.concurrent.Future<List<V>>	zrevrangebyscore(K key, String max, String min, long offset, long count)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrevrangebyscoreWithScores(K key, double max, double min)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrevrangebyscoreWithScores(K key, String max, String min)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count)
io.netty.util.concurrent.Future<List<ScoredValue<V>>>	zrevrangeWithScores(K key, long start, long stop)
io.netty.util.concurrent.Future<Long>	zrevrank(K key, V member)
io.netty.util.concurrent.Future<ScanResult<V>>	zscan(K key, long startValue)
io.netty.util.concurrent.Future<Double>	zscore(K key, V member)
io.netty.util.concurrent.Future<Long>	zunionstore(K destination, K... keys)
io.netty.util.concurrent.Future<Long>	zunionstore(K destination, ZStoreArgs storeArgs, K... keys)

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter

channelRead, channelReadComplete, channelRegistered, channelUnregistered, channelWritabilityChanged, exceptionCaught, userEventTriggered

Methods inherited from class io.netty.channel.ChannelHandlerAdapter

handlerAdded, handlerRemoved, isSharable

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.netty.channel.ChannelHandler

handlerAdded, handlerRemoved

Field Detail

queue

protected BlockingQueue<Command<K,V,?>> queue

codec

protected RedisCodec<K,V> codec

channel

protected io.netty.channel.Channel channel

timeout

protected long timeout

unit

protected TimeUnit unit

multi

protected MultiOutput<K,V> multi

Constructor Detail

RedisAsyncConnection

public RedisAsyncConnection(RedisClient redisClient,
                    BlockingQueue<Command<K,V,?>> queue,
                    RedisCodec<K,V> codec,
                    long timeout,
                    TimeUnit unit,
                    io.netty.channel.EventLoopGroup eventLoopGroup)

Initialize a new connection.

Parameters:

queue - Command queue.

codec - Codec used to encode/decode keys and values.

timeout - Maximum time to wait for a response.

unit - Unit of time for the timeout.

eventLoopGroup -

Method Detail

setTimeout

public void setTimeout(long timeout,
              TimeUnit unit)

Set the command timeout for this connection.

Parameters:

timeout - Command timeout.

unit - Unit of time for the timeout.

append

public io.netty.util.concurrent.Future<Long> append(K key,
                                           V value)

auth

public String auth(String password)

bgrewriteaof

public io.netty.util.concurrent.Future<String> bgrewriteaof()

bgsave

public io.netty.util.concurrent.Future<String> bgsave()

bitcount

public io.netty.util.concurrent.Future<Long> bitcount(K key)

bitcount

public io.netty.util.concurrent.Future<Long> bitcount(K key,
                                             long start,
                                             long end)

bitopAnd

public io.netty.util.concurrent.Future<Long> bitopAnd(K destination,
                                             K... keys)

bitopNot

public io.netty.util.concurrent.Future<Long> bitopNot(K destination,
                                             K source)

bitopOr

public io.netty.util.concurrent.Future<Long> bitopOr(K destination,
                                            K... keys)

bitopXor

public io.netty.util.concurrent.Future<Long> bitopXor(K destination,
                                             K... keys)

blpop

public io.netty.util.concurrent.Future<KeyValue<K,V>> blpop(long timeout,
                                                   K... keys)

brpop

public io.netty.util.concurrent.Future<KeyValue<K,V>> brpop(long timeout,
                                                   K... keys)

brpoplpush

public io.netty.util.concurrent.Future<V> brpoplpush(long timeout,
                                            K source,
                                            K destination)

clientGetname

public io.netty.util.concurrent.Future<K> clientGetname()

clientSetname

public io.netty.util.concurrent.Future<String> clientSetname(K name)

clientKill

public io.netty.util.concurrent.Future<String> clientKill(String addr)

clientList

public io.netty.util.concurrent.Future<String> clientList()

configGet

public io.netty.util.concurrent.Future<List<String>> configGet(String parameter)

configResetstat

public io.netty.util.concurrent.Future<String> configResetstat()

configSet

public io.netty.util.concurrent.Future<String> configSet(String parameter,
                                                String value)

dbsize

public io.netty.util.concurrent.Future<Long> dbsize()

debugObject

public io.netty.util.concurrent.Future<String> debugObject(K key)

decr

public io.netty.util.concurrent.Future<Long> decr(K key)

decrby

public io.netty.util.concurrent.Future<Long> decrby(K key,
                                           long amount)

del

public io.netty.util.concurrent.Future<Long> del(K... keys)

discard

public io.netty.util.concurrent.Future<String> discard()

dump

public io.netty.util.concurrent.Future<byte[]> dump(K key)

echo

public io.netty.util.concurrent.Future<V> echo(V msg)

eval

public <T> io.netty.util.concurrent.Future<T> eval(V script,
                                          ScriptOutputType type,
                                          K[] keys,
                                          V... values)

evalsha

public <T> io.netty.util.concurrent.Future<T> evalsha(String digest,
                                             ScriptOutputType type,
                                             K[] keys,
                                             V... values)

exists

public io.netty.util.concurrent.Future<Boolean> exists(K key)

expire

public io.netty.util.concurrent.Future<Boolean> expire(K key,
                                              long seconds)

expireat

public io.netty.util.concurrent.Future<Boolean> expireat(K key,
                                                Date timestamp)

expireat

public io.netty.util.concurrent.Future<Boolean> expireat(K key,
                                                long timestamp)

exec

public io.netty.util.concurrent.Future<List<Object>> exec()

flushall

public io.netty.util.concurrent.Future<String> flushall()

flushdb

public io.netty.util.concurrent.Future<String> flushdb()

get

public io.netty.util.concurrent.Future<V> get(K key)

getbit

public io.netty.util.concurrent.Future<Long> getbit(K key,
                                           long offset)

getrange

public io.netty.util.concurrent.Future<V> getrange(K key,
                                          long start,
                                          long end)

getset

public io.netty.util.concurrent.Future<V> getset(K key,
                                        V value)

hdel

public io.netty.util.concurrent.Future<Long> hdel(K key,
                                         K... fields)

hexists

public io.netty.util.concurrent.Future<Boolean> hexists(K key,
                                               K field)

hget

public io.netty.util.concurrent.Future<V> hget(K key,
                                      K field)

hincrby

public io.netty.util.concurrent.Future<Long> hincrby(K key,
                                            K field,
                                            long amount)

hincrbyfloat

public io.netty.util.concurrent.Future<Double> hincrbyfloat(K key,
                                                   K field,
                                                   double amount)

hgetall

public io.netty.util.concurrent.Future<Map<K,V>> hgetall(K key)

hkeys

public io.netty.util.concurrent.Future<Set<K>> hkeys(K key)

hlen

public io.netty.util.concurrent.Future<Long> hlen(K key)

hmget

public io.netty.util.concurrent.Future<List<V>> hmget(K key,
                                             K... fields)

hmset

public io.netty.util.concurrent.Future<String> hmset(K key,
                                            Map<K,V> map)

hset

public io.netty.util.concurrent.Future<Boolean> hset(K key,
                                            K field,
                                            V value)

hsetnx

public io.netty.util.concurrent.Future<Boolean> hsetnx(K key,
                                              K field,
                                              V value)

hvals

public io.netty.util.concurrent.Future<List<V>> hvals(K key)

incr

public io.netty.util.concurrent.Future<Long> incr(K key)

incrby

public io.netty.util.concurrent.Future<Long> incrby(K key,
                                           long amount)

incrbyfloat

public io.netty.util.concurrent.Future<Double> incrbyfloat(K key,
                                                  double amount)

info

public io.netty.util.concurrent.Future<String> info()

info

public io.netty.util.concurrent.Future<String> info(String section)

keys

public io.netty.util.concurrent.Future<List<K>> keys(K pattern)

lastsave

public io.netty.util.concurrent.Future<Date> lastsave()

lindex

public io.netty.util.concurrent.Future<V> lindex(K key,
                                        long index)

linsert

public io.netty.util.concurrent.Future<Long> linsert(K key,
                                            boolean before,
                                            V pivot,
                                            V value)

llen

public io.netty.util.concurrent.Future<Long> llen(K key)

lpop

public io.netty.util.concurrent.Future<V> lpop(K key)

lpush

public io.netty.util.concurrent.Future<Long> lpush(K key,
                                          V... values)

lpushx

public io.netty.util.concurrent.Future<Long> lpushx(K key,
                                           V value)

lrange

public io.netty.util.concurrent.Future<List<V>> lrange(K key,
                                              long start,
                                              long stop)

lrem

public io.netty.util.concurrent.Future<Long> lrem(K key,
                                         long count,
                                         V value)

lset

public io.netty.util.concurrent.Future<String> lset(K key,
                                           long index,
                                           V value)

ltrim

public io.netty.util.concurrent.Future<String> ltrim(K key,
                                            long start,
                                            long stop)

migrate

public io.netty.util.concurrent.Future<String> migrate(String host,
                                              int port,
                                              K key,
                                              int db,
                                              long timeout)

mget

public io.netty.util.concurrent.Future<List<V>> mget(K... keys)

move

public io.netty.util.concurrent.Future<Boolean> move(K key,
                                            int db)

isMultiMode

public boolean isMultiMode()

multi

public io.netty.util.concurrent.Future<String> multi()

mset

public io.netty.util.concurrent.Future<String> mset(Map<K,V> map)

msetnx

public io.netty.util.concurrent.Future<Boolean> msetnx(Map<K,V> map)

objectEncoding

public io.netty.util.concurrent.Future<String> objectEncoding(K key)

objectIdletime

public io.netty.util.concurrent.Future<Long> objectIdletime(K key)

objectRefcount

public io.netty.util.concurrent.Future<Long> objectRefcount(K key)

persist

public io.netty.util.concurrent.Future<Boolean> persist(K key)

pexpire

public io.netty.util.concurrent.Future<Boolean> pexpire(K key,
                                               long milliseconds)

pexpireat

public io.netty.util.concurrent.Future<Boolean> pexpireat(K key,
                                                 Date timestamp)

pexpireat

public io.netty.util.concurrent.Future<Boolean> pexpireat(K key,
                                                 long timestamp)

ping

public io.netty.util.concurrent.Future<String> ping()

pttl

public io.netty.util.concurrent.Future<Long> pttl(K key)

publish

public io.netty.util.concurrent.Future<Long> publish(K channel,
                                            V message)

quit

public io.netty.util.concurrent.Future<String> quit()

randomkey

public io.netty.util.concurrent.Future<V> randomkey()

rename

public io.netty.util.concurrent.Future<String> rename(K key,
                                             K newKey)

renamenx

public io.netty.util.concurrent.Future<Boolean> renamenx(K key,
                                                K newKey)

restore

public io.netty.util.concurrent.Future<String> restore(K key,
                                              long ttl,
                                              byte[] value)

rpop

public io.netty.util.concurrent.Future<V> rpop(K key)

rpoplpush

public io.netty.util.concurrent.Future<V> rpoplpush(K source,
                                           K destination)

rpush

public io.netty.util.concurrent.Future<Long> rpush(K key,
                                          V... values)

rpushx

public io.netty.util.concurrent.Future<Long> rpushx(K key,
                                           V value)

sadd

public io.netty.util.concurrent.Future<Long> sadd(K key,
                                         V... members)

save

public io.netty.util.concurrent.Future<String> save()

scard

public io.netty.util.concurrent.Future<Long> scard(K key)

scriptExists

public io.netty.util.concurrent.Future<List<Boolean>> scriptExists(String... digests)

scriptFlush

public io.netty.util.concurrent.Future<String> scriptFlush()

scriptKill

public io.netty.util.concurrent.Future<String> scriptKill()

scriptLoad

public io.netty.util.concurrent.Future<String> scriptLoad(V script)

sdiff

public io.netty.util.concurrent.Future<Set<V>> sdiff(K... keys)

sdiffstore

public io.netty.util.concurrent.Future<Long> sdiffstore(K destination,
                                               K... keys)

select

public String select(int db)

set

public io.netty.util.concurrent.Future<String> set(K key,
                                          V value)

setbit

public io.netty.util.concurrent.Future<Long> setbit(K key,
                                           long offset,
                                           int value)

setex

public io.netty.util.concurrent.Future<String> setex(K key,
                                            long seconds,
                                            V value)

setnx

public io.netty.util.concurrent.Future<Boolean> setnx(K key,
                                             V value)

setrange

public io.netty.util.concurrent.Future<Long> setrange(K key,
                                             long offset,
                                             V value)

shutdown

@Deprecated
public void shutdown()

Deprecated.

shutdown

public void shutdown(boolean save)

sinter

public io.netty.util.concurrent.Future<Set<V>> sinter(K... keys)

sinterstore

public io.netty.util.concurrent.Future<Long> sinterstore(K destination,
                                                K... keys)

sismember

public io.netty.util.concurrent.Future<Boolean> sismember(K key,
                                                 V member)

smove

public io.netty.util.concurrent.Future<Boolean> smove(K source,
                                             K destination,
                                             V member)

slaveof

public io.netty.util.concurrent.Future<String> slaveof(String host,
                                              int port)

slaveofNoOne

public io.netty.util.concurrent.Future<String> slaveofNoOne()

slowlogGet

public io.netty.util.concurrent.Future<List<Object>> slowlogGet()

slowlogGet

public io.netty.util.concurrent.Future<List<Object>> slowlogGet(int count)

slowlogLen

public io.netty.util.concurrent.Future<Long> slowlogLen()

slowlogReset

public io.netty.util.concurrent.Future<String> slowlogReset()

smembers

public io.netty.util.concurrent.Future<Set<V>> smembers(K key)

sort

public io.netty.util.concurrent.Future<List<V>> sort(K key)

sort

public io.netty.util.concurrent.Future<List<V>> sort(K key,
                                            SortArgs sortArgs)

sortStore

public io.netty.util.concurrent.Future<Long> sortStore(K key,
                                              SortArgs sortArgs,
                                              K destination)

spop

public io.netty.util.concurrent.Future<V> spop(K key)

srandmember

public io.netty.util.concurrent.Future<V> srandmember(K key)

srandmember

public io.netty.util.concurrent.Future<Set<V>> srandmember(K key,
                                                  long count)

srem

public io.netty.util.concurrent.Future<Long> srem(K key,
                                         V... members)

sunion

public io.netty.util.concurrent.Future<Set<V>> sunion(K... keys)

sunionstore

public io.netty.util.concurrent.Future<Long> sunionstore(K destination,
                                                K... keys)

sync

public io.netty.util.concurrent.Future<String> sync()

strlen

public io.netty.util.concurrent.Future<Long> strlen(K key)

ttl

public io.netty.util.concurrent.Future<Long> ttl(K key)

type

public io.netty.util.concurrent.Future<String> type(K key)

watch

public io.netty.util.concurrent.Future<String> watch(K... keys)

unwatch

public io.netty.util.concurrent.Future<String> unwatch()

zadd

public io.netty.util.concurrent.Future<Long> zadd(K key,
                                         double score,
                                         V member)

zadd

public io.netty.util.concurrent.Future<Long> zadd(K key,
                                         Object... scoresAndValues)

zcard

public io.netty.util.concurrent.Future<Long> zcard(K key)

zcount

public io.netty.util.concurrent.Future<Long> zcount(K key,
                                           double min,
                                           double max)

zcount

public io.netty.util.concurrent.Future<Long> zcount(K key,
                                           String min,
                                           String max)

zincrby

public io.netty.util.concurrent.Future<Double> zincrby(K key,
                                              double amount,
                                              K member)

zinterstore

public io.netty.util.concurrent.Future<Long> zinterstore(K destination,
                                                K... keys)

zinterstore

public io.netty.util.concurrent.Future<Long> zinterstore(K destination,
                                                ZStoreArgs storeArgs,
                                                K... keys)

zrange

public io.netty.util.concurrent.Future<List<V>> zrange(K key,
                                              long start,
                                              long stop)

zrangeWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrangeWithScores(K key,
                                                                     long start,
                                                                     long stop)

zrangebyscore

public io.netty.util.concurrent.Future<List<V>> zrangebyscore(K key,
                                                     double min,
                                                     double max)

zrangebyscore

public io.netty.util.concurrent.Future<List<V>> zrangebyscore(K key,
                                                     String min,
                                                     String max)

zrangebyscore

public io.netty.util.concurrent.Future<List<V>> zrangebyscore(K key,
                                                     double min,
                                                     double max,
                                                     long offset,
                                                     long count)

zrangebyscore

public io.netty.util.concurrent.Future<List<V>> zrangebyscore(K key,
                                                     String min,
                                                     String max,
                                                     long offset,
                                                     long count)

zrangebyscoreWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                            double min,
                                                                            double max)

zrangebyscoreWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                            String min,
                                                                            String max)

zrangebyscoreWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                            double min,
                                                                            double max,
                                                                            long offset,
                                                                            long count)

zrangebyscoreWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                            String min,
                                                                            String max,
                                                                            long offset,
                                                                            long count)

zrank

public io.netty.util.concurrent.Future<Long> zrank(K key,
                                          V member)

zrem

public io.netty.util.concurrent.Future<Long> zrem(K key,
                                         V... members)

zremrangebyrank

public io.netty.util.concurrent.Future<Long> zremrangebyrank(K key,
                                                    long start,
                                                    long stop)

zremrangebyscore

public io.netty.util.concurrent.Future<Long> zremrangebyscore(K key,
                                                     double min,
                                                     double max)

zremrangebyscore

public io.netty.util.concurrent.Future<Long> zremrangebyscore(K key,
                                                     String min,
                                                     String max)

zrevrange

public io.netty.util.concurrent.Future<List<V>> zrevrange(K key,
                                                 long start,
                                                 long stop)

zrevrangeWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrevrangeWithScores(K key,
                                                                        long start,
                                                                        long stop)

zrevrangebyscore

public io.netty.util.concurrent.Future<List<V>> zrevrangebyscore(K key,
                                                        double max,
                                                        double min)

zrevrangebyscore

public io.netty.util.concurrent.Future<List<V>> zrevrangebyscore(K key,
                                                        String max,
                                                        String min)

zrevrangebyscore

public io.netty.util.concurrent.Future<List<V>> zrevrangebyscore(K key,
                                                        double max,
                                                        double min,
                                                        long offset,
                                                        long count)

zrevrangebyscore

public io.netty.util.concurrent.Future<List<V>> zrevrangebyscore(K key,
                                                        String max,
                                                        String min,
                                                        long offset,
                                                        long count)

zrevrangebyscoreWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                                               double max,
                                                                               double min)

zrevrangebyscoreWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                                               String max,
                                                                               String min)

zrevrangebyscoreWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                                               double max,
                                                                               double min,
                                                                               long offset,
                                                                               long count)

zrevrangebyscoreWithScores

public io.netty.util.concurrent.Future<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                                               String max,
                                                                               String min,
                                                                               long offset,
                                                                               long count)

zrevrank

public io.netty.util.concurrent.Future<Long> zrevrank(K key,
                                             V member)

zscore

public io.netty.util.concurrent.Future<Double> zscore(K key,
                                             V member)

zunionstore

public io.netty.util.concurrent.Future<Long> zunionstore(K destination,
                                                K... keys)

zunionstore

public io.netty.util.concurrent.Future<Long> zunionstore(K destination,
                                                ZStoreArgs storeArgs,
                                                K... keys)

pfadd

public io.netty.util.concurrent.Future<Long> pfadd(K key,
                                          V... values)

pfcount

public io.netty.util.concurrent.Future<Long> pfcount(K key,
                                            K... keys)

pfmerge

public io.netty.util.concurrent.Future<Long> pfmerge(K destkey,
                                            K... sourceKeys)

getMasterAddrByKey

public io.netty.util.concurrent.Future<List<V>> getMasterAddrByKey(K name)

slaves

public io.netty.util.concurrent.Future<List<Map<K,V>>> slaves(K key)

sscan

public io.netty.util.concurrent.Future<ScanResult<V>> sscan(K key,
                                                   long startValue)

zscan

public io.netty.util.concurrent.Future<ScanResult<V>> zscan(K key,
                                                   long startValue)

awaitAll

public boolean awaitAll(io.netty.util.concurrent.Future<?>... futures)

Wait until commands are complete or the connection timeout is reached.

Parameters:

futures - Futures to wait for.

Returns:

True if all futures complete in time.

awaitAll

public boolean awaitAll(long timeout,
               TimeUnit unit,
               io.netty.util.concurrent.Future<?>... futures)

Wait until futures are complete or the supplied timeout is reached.

Parameters:

timeout - Maximum time to wait for futures to complete.

unit - Unit of time for the timeout.

futures - Futures to wait for.

Returns:

True if all futures complete in time.

close

public void close()

Close the connection.

digest

public String digest(V script)

channelActive

public void channelActive(io.netty.channel.ChannelHandlerContext ctx)
                   throws Exception

Specified by:

channelActive in interface io.netty.channel.ChannelInboundHandler

Overrides:

channelActive in class io.netty.channel.ChannelInboundHandlerAdapter

Throws:

Exception

channelInactive

public void channelInactive(io.netty.channel.ChannelHandlerContext ctx)
                     throws Exception

Specified by:

channelInactive in interface io.netty.channel.ChannelInboundHandler

Overrides:

channelInactive in class io.netty.channel.ChannelInboundHandlerAdapter

Throws:

Exception

dispatch

public <T> io.netty.util.concurrent.Future<T> dispatch(CommandType type,
                                              CommandOutput<K,V,T> output)

dispatch

public <T> io.netty.util.concurrent.Future<T> dispatch(CommandType type,
                                              CommandOutput<K,V,T> output,
                                              K key)

dispatch

public <T> io.netty.util.concurrent.Future<T> dispatch(CommandType type,
                                              CommandOutput<K,V,T> output,
                                              K key,
                                              V value)

dispatch

public <T> io.netty.util.concurrent.Future<T> dispatch(CommandType type,
                                              CommandOutput<K,V,T> output,
                                              K key,
                                              V[] values)

dispatch

public <T> io.netty.util.concurrent.Future<T> dispatch(CommandType type,
                                              CommandOutput<K,V,T> output,
                                              CommandArgs<K,V> args)

await

public <T> T await(io.netty.util.concurrent.Future<T> cmd,
          long timeout,
          TimeUnit unit)

getRedisClient

public RedisClient getRedisClient()

newScriptOutput

protected <K,V,T> CommandOutput<K,V,T> newScriptOutput(RedisCodec<K,V> codec,
                                           ScriptOutputType type)

string

public String string(double n)