Packages

package config

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. case class ClusterConfig(nodeConfigs: (NodeAddress) ⇒ NodeConfig = _ => NodeConfig(), monitoringConnectionConfigs: (NodeAddress) ⇒ ConnectionConfig = _ => ConnectionConfig(), autoRefreshInterval: FiniteDuration = 5.seconds, minRefreshInterval: FiniteDuration = 1.seconds, nodesToQueryForState: (Int) ⇒ Int = _ min 5, maxRedirections: Int = 3, nodeClientCloseDelay: FiniteDuration = 1.seconds, fallbackToSingleNode: Boolean = false) extends Product with Serializable

    Configuration of a RedisClusterClient

    Configuration of a RedisClusterClient

    nodeConfigs

    function that returns NodeConfig given the address of the node.

    monitoringConnectionConfigs

    function that returns ConnectionConfig for a monitoring connection used to monitor node with given address. The cluster client keeps single monitoring connection for every cluster master. Monitoring connections are used to refresh Redis Cluster state (current masters and slot mapping).

    autoRefreshInterval

    interval between routine cluster state refresh operations

    minRefreshInterval

    minimal interval between consecutive cluster state refresh operations. Normally, cluster state is not refreshed more frequently than specified by autoRefreshInterval but additional refresh operations may be forced when cluster redirections are observed. minRefreshInterval prevents too many refresh operations from being executed in such situations.

    nodesToQueryForState

    function that determines how many randomly selected masters should be queried for cluster state during routine state refresh operation. The function takes current number of known masters as its argument.

    maxRedirections

    maximum number of consecutive redirections automatically handled by RedisClusterClient. When set to 0, redirections are not handled at all.

    nodeClientCloseDelay

    Delay after which RedisNodeClient is closed when it's master leaves cluster state (goes down or becomes a slave). Note that the node client is NOT operational during that delay. Trying to execute commands on it will result in NodeRemovedException

    fallbackToSingleNode

    if RedisClusterClient has exactly one seed address configured and it points to a non-clustered Redis node then cluster client will not fail initialization but internally create a RedisNodeClient for that node and forward all operations to it.

  2. case class ConnectionConfig(initCommands: RedisBatch[Any] = RedisBatch.unit, actorName: commons.OptArg[String] = OptArg.Empty, localAddress: commons.OptArg[InetSocketAddress] = OptArg.Empty, socketOptions: List[SocketOption] = Nil, connectTimeout: commons.OptArg[FiniteDuration] = OptArg.Empty, maxWriteSizeHint: commons.OptArg[Int] = 50000, reconnectionStrategy: RetryStrategy = ..., debugListener: DebugListener = DevNullListener) extends Product with Serializable

    Configuration options for a single Redis connection.

    Configuration options for a single Redis connection.

    initCommands usage example:

    implicit val actorSystem = ActorSystem()
    import RedisApi.Batches.StringTyped._
    val nodeClient = new RedisNodeClient(
      config = NodeConfig(
        poolSize = 8,
        connectionConfigs = connectionId => ConnectionConfig(
          initCommands = auth("mypassword") *> clientSetname(s"conn_$$connectionId") *> select(1)
        )
      )
    )
    initCommands

    commands always sent upon establishing a Redis connection (and every time it's reconnected). The most common reason to configure initCommands is to specify authentication password used by every connection (AUTH command), but it's also useful for commands like CLIENT SETNAME, SELECT, etc. Note that these are all commands that can't be executed directly by RedisNodeClient or RedisClusterClient.

    actorName

    name of the actor representing the connection

    localAddress

    local bind address for the connection

    socketOptions

    socket options for the connection

    connectTimeout

    timeout for establishing connection

    maxWriteSizeHint

    hint for maximum number of bytes sent in a single network write message (the actual number of bytes sent may be slightly larger)

    reconnectionStrategy

    a RetryStrategy used to determine what delay should be used when reconnecting a failed connection. NOTE: reconnectionStrategy is ignored by RedisConnectionClient

    debugListener

    listener for traffic going through this connection. Only for debugging and testing purposes

  3. case class ExecutionConfig(timeout: Timeout = 10.seconds, decodeOn: commons.ExecutionContext = RunNowEC) extends Product with Serializable

    Additional options for executing a RedisBatch on a RedisExecutor

    Additional options for executing a RedisBatch on a RedisExecutor

    timeout

    execution timeout

    decodeOn

    execution context on which Redis response to a batch will be decoded. Normally this is happening on one of the connection actor threads. This is ok for simple Redis commands but may introduce performance bottleneck for large batches with more heavy decoding. In such case it may be beneficial to delegate that work to some external executor.

  4. case class ExponentialBackoff(firstDelay: FiniteDuration, maxDelay: FiniteDuration) extends RetryStrategy with Product with Serializable
  5. case class NodeConfig(poolSize: Int = 1, initOp: RedisOp[Any] = RedisOp.unit, initTimeout: Timeout = Timeout(10.seconds), connectionConfigs: (Int) ⇒ ConnectionConfig = _ => ConnectionConfig()) extends Product with Serializable

    Configuration of a RedisNodeClient, used either as a standalone client or internally by RedisClusterClient.

    Configuration of a RedisNodeClient, used either as a standalone client or internally by RedisClusterClient.

    poolSize

    number of connections used by node client. Commands are distributed between connections using a round-robin scenario. Number of connections in the pool is constant and cannot be changed. Due to single-threaded nature of Redis, the number of concurrent connections should be kept low for best performance. The only situation where the number of connections should be increased is when using WATCH-MULTI-EXEC transactions with optimistic locking.

    initOp

    a RedisOp executed by this client upon initialization. This may be useful for things like script loading, especially when using cluster client which may create and close node clients dynamically as reactions on cluster state changes.

    initTimeout

    timeout used by initialization operation (initOp)

    connectionConfigs

    a function that returns ConnectionConfig for a connection given its id. Connection ID is its index in the connection pool, i.e. an int ranging from 0 to poolSize-1.

  6. trait RetryStrategy extends AnyRef

Ungrouped