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, Jongyeol Choi

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

Constructor Summary

Constructors

Constructor and Description
CommandHandler(ClientOptions clientOptions, ClientResources clientResources) Initialize a new instance that handles commands from the supplied queue.

Method Summary

Modifier and Type	Method and Description
protected void	afterComplete(ChannelHandlerContext ctx, RedisCommand<K,V,?> command) Hook method called after command completion.
protected boolean	canDecode(ByteBuf buffer)
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.
protected static <T> List<T>	drainCommands(Queue<T> source)
protected static <T> void	drainCommands(Queue<T> source, Collection<T> target)
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.
void	userEventTriggered(ChannelHandlerContext ctx, Object evt)
<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	writeToDisconnectedBuffer(C command)

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

Methods inherited from class io.netty.channel.ChannelHandlerAdapter

ensureNotSharable, 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

disconnectedBuffer

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

commandBuffer

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

writers

protected final AtomicLong writers

stateLock

protected final Object stateLock

stack

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

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)

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

Method Detail

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.

setState

protected void setState(CommandHandler.LifecycleState lifecycleState)

getState

protected CommandHandler.LifecycleState getState()

isClosed

public boolean isClosed()

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

See Also:

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

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)

afterComplete

protected void afterComplete(ChannelHandlerContext ctx,
                             RedisCommand<K,V,?> command)

Hook method called after command completion.

Parameters:

ctx -

command -

canDecode

protected boolean canDecode(ByteBuf buffer)

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

writeToDisconnectedBuffer

protected <C extends RedisCommand<K,V,T>,T> void writeToDisconnectedBuffer(C 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)

userEventTriggered

public void userEventTriggered(ChannelHandlerContext ctx,
                               Object evt)
                        throws Exception

Specified by:

userEventTriggered in interface ChannelInboundHandler

Overrides:

userEventTriggered in class ChannelInboundHandlerAdapter

Throws:

Exception

channelActive

public void channelActive(ChannelHandlerContext ctx)
                   throws Exception

Specified by:

channelActive in interface ChannelInboundHandler

Overrides:

channelActive in class ChannelInboundHandlerAdapter

Throws:

Exception

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)

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.

logPrefix

protected String logPrefix()

drainCommands

protected static <T> List<T> drainCommands(Queue<T> source)

drainCommands

protected static <T> void drainCommands(Queue<T> source,
                                        Collection<T> target)