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, Mark Paluch

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 Deque<RedisCommand<K,V,?>>	commandBuffer
protected long	commandHandlerId
protected Queue<RedisCommand<K,V,?>>	queue
protected RedisStateMachine<K,V>	rsm
protected Object	stateLock
protected Deque<RedisCommand<K,V,?>>	transportBuffer
protected AtomicLong	writers

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
protected void	activateCommandHandlerAndExecuteBufferedCommands(ChannelHandlerContext ctx)
protected void	bufferCommand(RedisCommand<K,V,?> command)
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)
protected void	decrementWriters() Decrement writers without any wait.
void	exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
void	flushCommands() Flush pending commands.
protected CommandHandler.LifecycleState	getState()
protected void	incrementWriters() Wait for stateLock and increment writers.
void	initialState() Reset the command-handler to the initial not-connected state.
boolean	isClosed()
protected void	lockWritersExclusive() Wait for stateLock and no writers.
protected String	logPrefix()
protected List<RedisCommand<K,V,?>>	prepareReset()
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	unlockWritersExclusive() Unlock writers.
<T,C extends RedisCommand<K,V,T>> C	write(C command) Write a command on the channel.
void	write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
protected <C extends RedisCommand<K,V,T>,T> void	writeToBuffer(C command)
protected <C extends RedisCommand<K,V,T>,T> void	writeToChannel(C command, Channel 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

commandHandlerId

protected final long commandHandlerId

clientOptions

protected final ClientOptions clientOptions

clientResources

protected final ClientResources clientResources

queue

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

writers

protected final AtomicLong writers

stateLock

protected final Object stateLock

commandBuffer

protected final Deque<RedisCommand<K,V,?>> commandBuffer

transportBuffer

protected final Deque<RedisCommand<K,V,?>> transportBuffer

buffer

protected final ByteBuf buffer

rsm

protected final RedisStateMachine<K,V> rsm

channel

protected volatile 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,C extends RedisCommand<K,V,T>> C write(C 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

C - command type

Parameters:

command - the redis command

Returns:

the written redis command

writeToBuffer

protected <C extends RedisCommand<K,V,T>,T> void writeToBuffer(C command)

writeToChannel

protected <C extends RedisCommand<K,V,T>,T> void writeToChannel(C command,
                                                                Channel channel)

bufferCommand

protected void bufferCommand(RedisCommand<K,V,?> command)

incrementWriters

protected void incrementWriters()

Wait for stateLock and increment writers. Will wait if stateLock is locked and if writer counter is negative.

decrementWriters

protected void decrementWriters()

Decrement writers without any wait.

lockWritersExclusive

protected void lockWritersExclusive()

Wait for stateLock and no writers. Must be used in an outer synchronized block to prevent interleaving with other methods using writers. Sets writers to a negative value to create a lock for incrementWriters().

unlockWritersExclusive

protected void unlockWritersExclusive()

Unlock writers.

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

activateCommandHandlerAndExecuteBufferedCommands

protected void activateCommandHandlerAndExecuteBufferedCommands(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)

setState

protected void setState(CommandHandler.LifecycleState lifecycleState)

getState

protected CommandHandler.LifecycleState getState()

isClosed

public boolean isClosed()

prepareReset

protected List<RedisCommand<K,V,?>> prepareReset()

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

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>

initialState

public void initialState()

Reset the command-handler to the initial not-connected state.

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()