org.redisson.connection

Interface ConnectionManager

All Known Implementing Classes:

ClusterConnectionManager, ElasticacheConnectionManager, MasterSlaveConnectionManager, SentinelConnectionManager, SingleConnectionManager

public interface ConnectionManager

Author:

Nikita Koksharov

Method Summary

Methods

Modifier and Type	Method and Description
int	calcSlot(String key)
io.netty.util.concurrent.Future<RedisConnection>	connectionReadOp(NodeSource source, RedisCommand<?> command)
io.netty.util.concurrent.Future<RedisConnection>	connectionWriteOp(NodeSource source, RedisCommand<?> command)
RedisClient	createClient(NodeType type, String host, int port)
RedisClient	createClient(String host, int port, int timeout, int commandTimeout)
Collection<RedisClientEntry>	getClients()
Codec	getCodec()
MasterSlaveServersConfig	getConfig()
ConnectionEventsHub	getConnectionEventsHub()
IdleConnectionWatcher	getConnectionWatcher()
ConnectionInitializer	getConnectListener()
MasterSlaveEntry	getEntry(InetSocketAddress addr)
MasterSlaveEntry	getEntry(int slot)
Set<MasterSlaveEntry>	getEntrySet()
io.netty.channel.EventLoopGroup	getGroup()
URI	getLastClusterNode()
PubSubConnectionEntry	getPubSubEntry(String channelName)
AsyncSemaphore	getSemaphore(String channelName)
InfinitySemaphoreLatch	getShutdownLatch()
io.netty.util.concurrent.Future<Boolean>	getShutdownPromise()
boolean	isClusterMode()
boolean	isShutdown()
boolean	isShuttingDown()
<R> io.netty.util.concurrent.Future<R>	newFailedFuture(Throwable cause)
<R> io.netty.util.concurrent.Promise<R>	newPromise()
<R> io.netty.util.concurrent.Future<R>	newSucceededFuture(R value)
io.netty.util.Timeout	newTimeout(io.netty.util.TimerTask task, long delay, TimeUnit unit)
io.netty.util.concurrent.Future<PubSubConnectionEntry>	psubscribe(String pattern, Codec codec, RedisPubSubListener<?> listener)
io.netty.util.concurrent.Future<PubSubConnectionEntry>	psubscribe(String pattern, Codec codec, RedisPubSubListener<?> listener, AsyncSemaphore semaphore)
Codec	punsubscribe(String channelName, AsyncSemaphore lock)
io.netty.util.concurrent.Future<Codec>	punsubscribe(String channelName, boolean temporaryDown)
void	releaseRead(NodeSource source, RedisConnection connection)
void	releaseWrite(NodeSource source, RedisConnection connection)
void	shutdown()
void	shutdown(long quietPeriod, long timeout, TimeUnit unit)
void	shutdownAsync(RedisClient client)
io.netty.util.concurrent.Future<PubSubConnectionEntry>	subscribe(Codec codec, String channelName, RedisPubSubListener<?> listener)
io.netty.util.concurrent.Future<PubSubConnectionEntry>	subscribe(Codec codec, String channelName, RedisPubSubListener<?> listener, AsyncSemaphore semaphore)
Codec	unsubscribe(String channelName, AsyncSemaphore lock)
io.netty.util.concurrent.Future<Codec>	unsubscribe(String channelName, boolean temporaryDown)

Method Detail

getLastClusterNode

URI getLastClusterNode()

isClusterMode

boolean isClusterMode()

getSemaphore

AsyncSemaphore getSemaphore(String channelName)

newSucceededFuture

<R> io.netty.util.concurrent.Future<R> newSucceededFuture(R value)

getConnectionEventsHub

ConnectionEventsHub getConnectionEventsHub()

isShutdown

boolean isShutdown()

isShuttingDown

boolean isShuttingDown()

subscribe

io.netty.util.concurrent.Future<PubSubConnectionEntry> subscribe(Codec codec,
                                                               String channelName,
                                                               RedisPubSubListener<?> listener)

subscribe

io.netty.util.concurrent.Future<PubSubConnectionEntry> subscribe(Codec codec,
                                                               String channelName,
                                                               RedisPubSubListener<?> listener,
                                                               AsyncSemaphore semaphore)

getConnectListener

ConnectionInitializer getConnectListener()

getConnectionWatcher

IdleConnectionWatcher getConnectionWatcher()

newFailedFuture

<R> io.netty.util.concurrent.Future<R> newFailedFuture(Throwable cause)

getClients

Collection<RedisClientEntry> getClients()

shutdownAsync

void shutdownAsync(RedisClient client)

calcSlot

int calcSlot(String key)

getConfig

MasterSlaveServersConfig getConfig()

getCodec

Codec getCodec()

getEntrySet

Set<MasterSlaveEntry> getEntrySet()

getEntry

MasterSlaveEntry getEntry(int slot)

newPromise

<R> io.netty.util.concurrent.Promise<R> newPromise()

releaseRead

void releaseRead(NodeSource source,
               RedisConnection connection)

releaseWrite

void releaseWrite(NodeSource source,
                RedisConnection connection)

connectionReadOp

io.netty.util.concurrent.Future<RedisConnection> connectionReadOp(NodeSource source,
                                                                RedisCommand<?> command)

connectionWriteOp

io.netty.util.concurrent.Future<RedisConnection> connectionWriteOp(NodeSource source,
                                                                 RedisCommand<?> command)

createClient

RedisClient createClient(String host,
                       int port,
                       int timeout,
                       int commandTimeout)

createClient

RedisClient createClient(NodeType type,
                       String host,
                       int port)

getEntry

MasterSlaveEntry getEntry(InetSocketAddress addr)

getPubSubEntry

PubSubConnectionEntry getPubSubEntry(String channelName)

psubscribe

io.netty.util.concurrent.Future<PubSubConnectionEntry> psubscribe(String pattern,
                                                                Codec codec,
                                                                RedisPubSubListener<?> listener)

psubscribe

io.netty.util.concurrent.Future<PubSubConnectionEntry> psubscribe(String pattern,
                                                                Codec codec,
                                                                RedisPubSubListener<?> listener,
                                                                AsyncSemaphore semaphore)

unsubscribe

Codec unsubscribe(String channelName,
                AsyncSemaphore lock)

unsubscribe

io.netty.util.concurrent.Future<Codec> unsubscribe(String channelName,
                                                 boolean temporaryDown)

punsubscribe

io.netty.util.concurrent.Future<Codec> punsubscribe(String channelName,
                                                  boolean temporaryDown)

punsubscribe

Codec punsubscribe(String channelName,
                 AsyncSemaphore lock)

shutdown

void shutdown()

shutdown

void shutdown(long quietPeriod,
            long timeout,
            TimeUnit unit)

getGroup

io.netty.channel.EventLoopGroup getGroup()

newTimeout

io.netty.util.Timeout newTimeout(io.netty.util.TimerTask task,
                               long delay,
                               TimeUnit unit)

getShutdownLatch

InfinitySemaphoreLatch getShutdownLatch()

getShutdownPromise

io.netty.util.concurrent.Future<Boolean> getShutdownPromise()