com.lambdaworks.redis.protocol

Class CommandHandler<K,V>

java.lang.Object

io.netty.channel.ChannelHandlerAdapter

io.netty.channel.ChannelInboundHandlerAdapter

io.netty.channel.ChannelDuplexHandler

com.lambdaworks.redis.protocol.CommandHandler<K,V>

Type Parameters:

K - Key type.

V - Value type.

All Implemented Interfaces:

RedisChannelWriter<K,V>, ChannelHandler, ChannelInboundHandler, ChannelOutboundHandler, Closeable, AutoCloseable

Direct Known Subclasses:

PubSubCommandHandler

@ChannelHandler.Sharable
public class CommandHandler<K,V>
extends ChannelDuplexHandler
implements RedisChannelWriter<K,V>

A netty ChannelHandler responsible for writing redis commands and reading responses from the server.

Author:

Will Glozer

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	CommandHandler.LifecycleState

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

ChannelHandler.Sharable

Field Summary

Fields

Modifier and Type	Field and Description
protected ByteBuf	buffer
protected Channel	channel
protected ClientOptions	clientOptions
protected ClientResources	clientResources
protected Queue<RedisCommand<K,V,?>>	commandBuffer
protected Queue<RedisCommand<K,V,?>>	queue
protected RedisStateMachine<K,V>	rsm
protected ReentrantLock	writeLock

Constructor Summary

Constructors

Constructor and Description
CommandHandler(ClientOptions clientOptions, ClientResources clientResources, Queue<RedisCommand<K,V,?>> queue) Initialize a new instance that handles commands from the supplied queue.

Method Summary

Modifier and Type	Method and Description
void	channelActive(ChannelHandlerContext ctx)
void	channelInactive(ChannelHandlerContext ctx)
void	channelRead(ChannelHandlerContext ctx, Object msg)
void	channelRegistered(ChannelHandlerContext ctx)
void	channelUnregistered(ChannelHandlerContext ctx)
void	close() Close the connection.
protected void	decode(ChannelHandlerContext ctx, ByteBuf buffer)
void	exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
protected void	executeQueuedCommands(ChannelHandlerContext ctx)
void	flushCommands() Flush pending commands.
protected CommandHandler.LifecycleState	getState()
boolean	isClosed()
protected String	logPrefix()
void	reset() Reset the writer state.
void	setAutoFlushCommands(boolean autoFlush) Disable or enable auto-flush behavior.
void	setRedisChannelHandler(RedisChannelHandler<K,V> redisChannelHandler) Set the corresponding connection instance in order to notify it about channel active/inactive state.
protected void	setState(CommandHandler.LifecycleState lifecycleState)
protected void	setStateIfNotClosed(CommandHandler.LifecycleState lifecycleState)
void	write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
<T> RedisCommand<K,V,T>	write(RedisCommand<K,V,T> command) Write a command on the channel.

Methods inherited from class io.netty.channel.ChannelDuplexHandler

bind, close, connect, deregister, disconnect, flush, read

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter

channelReadComplete, channelWritabilityChanged, 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

clientOptions

protected final ClientOptions clientOptions

clientResources

protected final ClientResources clientResources

queue

protected final Queue<RedisCommand<K,V,?>> queue

writeLock

protected final ReentrantLock writeLock

commandBuffer

protected Queue<RedisCommand<K,V,?>> commandBuffer

buffer

protected ByteBuf buffer

rsm

protected RedisStateMachine<K,V> rsm

channel

protected Channel channel

Constructor Detail

CommandHandler

public CommandHandler(ClientOptions clientOptions,
                      ClientResources clientResources,
                      Queue<RedisCommand<K,V,?>> queue)

Initialize a new instance that handles commands from the supplied queue.

Parameters:

clientOptions - client options for this connection, must not be null

clientResources - client resources for this connection, must not be null

queue - The command queue, must not be null

Method Detail

channelRegistered

public void channelRegistered(ChannelHandlerContext ctx)
                       throws Exception

Specified by:

channelRegistered in interface ChannelInboundHandler

Overrides:

channelRegistered in class ChannelInboundHandlerAdapter

Throws:

Exception

See Also:

ChannelInboundHandlerAdapter.channelRegistered(io.netty.channel.ChannelHandlerContext)

channelUnregistered

public void channelUnregistered(ChannelHandlerContext ctx)
                         throws Exception

Specified by:

channelUnregistered in interface ChannelInboundHandler

Overrides:

channelUnregistered in class ChannelInboundHandlerAdapter

Throws:

Exception

channelRead

public void channelRead(ChannelHandlerContext ctx,
                        Object msg)
                 throws Exception

Specified by:

channelRead in interface ChannelInboundHandler

Overrides:

channelRead in class ChannelInboundHandlerAdapter

Throws:

Exception

See Also:

ChannelInboundHandlerAdapter.channelRead(io.netty.channel.ChannelHandlerContext, java.lang.Object)

decode

protected void decode(ChannelHandlerContext ctx,
                      ByteBuf buffer)
               throws InterruptedException

Throws:

InterruptedException

write

public <T> RedisCommand<K,V,T> write(RedisCommand<K,V,T> command)

Description copied from interface: RedisChannelWriter

Write a command on the channel. The command may be changed/wrapped during write and the written instance is returned after the call.

Specified by:

write in interface RedisChannelWriter<K,V>

Type Parameters:

T - result type

Parameters:

command - the redis command

Returns:

the written redis command

flushCommands

public void flushCommands()

Description copied from interface: RedisChannelWriter

Flush pending commands. This commands forces a flush on the channel and can be used to buffer ("pipeline") commands to achieve batching. No-op if channel is not connected.

Specified by:

flushCommands in interface RedisChannelWriter<K,V>

write

public void write(ChannelHandlerContext ctx,
                  Object msg,
                  ChannelPromise promise)
           throws Exception

Specified by:

write in interface ChannelOutboundHandler

Overrides:

write in class ChannelDuplexHandler

Throws:

Exception

See Also:

ChannelDuplexHandler.write(io.netty.channel.ChannelHandlerContext, java.lang.Object, io.netty.channel.ChannelPromise)

channelActive

public void channelActive(ChannelHandlerContext ctx)
                   throws Exception

Specified by:

channelActive in interface ChannelInboundHandler

Overrides:

channelActive in class ChannelInboundHandlerAdapter

Throws:

Exception

executeQueuedCommands

protected void executeQueuedCommands(ChannelHandlerContext ctx)

channelInactive

public void channelInactive(ChannelHandlerContext ctx)
                     throws Exception

Specified by:

channelInactive in interface ChannelInboundHandler

Overrides:

channelInactive in class ChannelInboundHandlerAdapter

Throws:

Exception

See Also:

ChannelInboundHandlerAdapter.channelInactive(io.netty.channel.ChannelHandlerContext)

setStateIfNotClosed

protected void setStateIfNotClosed(CommandHandler.LifecycleState lifecycleState)

setState

protected void setState(CommandHandler.LifecycleState lifecycleState)

getState

protected CommandHandler.LifecycleState getState()

exceptionCaught

public void exceptionCaught(ChannelHandlerContext ctx,
                            Throwable cause)
                     throws Exception

Specified by:

exceptionCaught in interface ChannelHandler

Specified by:

exceptionCaught in interface ChannelInboundHandler

Overrides:

exceptionCaught in class ChannelInboundHandlerAdapter

Throws:

Exception

close

public void close()

Close the connection.

Specified by:

close in interface RedisChannelWriter<K,V>

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

isClosed

public boolean isClosed()

reset

public void reset()

Reset the writer state. Queued commands will be canceled and the internal state will be reset. This is useful when the internal state machine gets out of sync with the connection.

Specified by:

reset in interface RedisChannelWriter<K,V>

setRedisChannelHandler

public void setRedisChannelHandler(RedisChannelHandler<K,V> redisChannelHandler)

Description copied from interface: RedisChannelWriter

Set the corresponding connection instance in order to notify it about channel active/inactive state.

Specified by:

setRedisChannelHandler in interface RedisChannelWriter<K,V>

Parameters:

redisChannelHandler - the channel handler (external connection object)

setAutoFlushCommands

public void setAutoFlushCommands(boolean autoFlush)

Description copied from interface: RedisChannelWriter

Disable or enable auto-flush behavior. Default is true. If autoFlushCommands is disabled, multiple commands can be issued without writing them actually to the transport. Commands are buffered until a RedisChannelWriter.flushCommands() is issued. After calling RedisChannelWriter.flushCommands() commands are sent to the transport and executed by Redis.

Specified by:

setAutoFlushCommands in interface RedisChannelWriter<K,V>

Parameters:

autoFlush - state of autoFlush.

logPrefix

protected String logPrefix()