RedisCluster

abstract val keyTag: Option[KeyTag]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val POINTS_PER_SERVER: Int

def addServer(server: ClusterNode): Unit

def append(key: Any, value: Any)(implicit format: Format): Option[Long]

def asAny: Option[Any]

def asBoolean: Boolean

def asBulk[T](implicit parse: Parse[T]): Option[T]

def asBulkWithTime[T](implicit parse: Parse[T]): Option[T]

def asExec(handlers: Seq[() ⇒ Any]): Option[List[Any]]

final def asInstanceOf[T0]: T0

def asInt: Option[Int]

def asList[T](implicit parse: Parse[T]): Option[List[Option[T]]]

def asListPairs[A, B](implicit parseA: Parse[A], parseB: Parse[B]): Option[List[Option[(A, B)]]]

def asLong: Option[Long]

def asPair[T](implicit parse: Parse[T]): Option[(Option[Int], Option[List[Option[T]]])]

def asQueuedList: Option[List[Option[String]]]

def asSet[T](implicit arg0: Parse[T]): Option[Set[Option[T]]]

def asString: Option[String]

def auth(secret: Any)(implicit format: Format): Nothing

def bgrewriteaof: Boolean

def bgsave: Boolean

def bitcount(key: Any, range: Option[(Int, Int)] = None)(implicit format: Format): Option[Int]

def bitop(op: String, destKey: Any, srcKeys: Any*)(implicit format: Format): Nothing

def blpop[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[(K, V)]

def brpop[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[(K, V)]

def brpoplpush[A](srcKey: Any, dstKey: Any, timeoutInSeconds: Int)(implicit format: Format, parse: Parse[A]): Option[A]

val bulkReply: SingleReply

def clearFd: Unit

val clients: List[IdentifiableRedisClientPool]

def clone(): AnyRef

def close: ArrayBuffer[Unit]

def cmd(args: Seq[Array[Byte]]): Array[Byte]

def connect: Boolean

def connected: Boolean

val database: Int

var db: Int

def dbsize: Option[Long]

def debug(message: String, error: Throwable): Unit

def debug(message: String, values: AnyRef*): Unit

def decr(key: Any)(implicit format: Format): Option[Long]

def decrby(key: Any, increment: Int)(implicit format: Format): Option[Long]

def del(key: Any, keys: Any*)(implicit format: Format): Option[Long]

def disconnect: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val errReply: Reply[Nothing]

def error(message: String, error: Throwable): Unit

def error(message: String, values: AnyRef*): Unit

def evalBulk[A](luaCode: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def evalMultiBulk[A](luaCode: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

def evalMultiSHA[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

def evalSHA[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def evalSHABulk[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def execReply(handlers: Seq[() ⇒ Any]): PartialFunction[(Char, Array[Byte]), Option[List[Any]]]

def exists(key: Any)(implicit format: Format): Boolean

def expire(key: Any, expiry: Int)(implicit format: Format): Boolean

def expireat(key: Any, expiry: Long)(implicit format: Format): Boolean

def finalize(): Unit

def flattenPairs(in: Iterable[Product2[Any, Any]]): List[Any]

def flushall: Boolean

def flushdb: Boolean

def get[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

final def getClass(): Class[_]

def getConfig(key: Any = "*")(implicit format: Format): Option[Map[String, Option[String]]]

def getType(key: Any)(implicit format: Format): Option[String]

def getbit(key: Any, offset: Int)(implicit format: Format): Option[Int]

def getrange[A](key: Any, start: Int, end: Int)(implicit format: Format, parse: Parse[A]): Option[A]

def getset[A](key: Any, value: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def hashCode(): Int

def hdel(key: Any, field: Any, fields: Any*)(implicit format: Format): Option[Long]

def hexists(key: Any, field: Any)(implicit format: Format): Boolean

def hget[A](key: Any, field: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def hgetall[K, V](key: Any)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[Map[K, V]]

def hgetall1[K, V](key: Any)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[Map[K, V]]

def hincrby(key: Any, field: Any, value: Int)(implicit format: Format): Option[Long]

def hincrbyfloat(key: Any, field: Any, value: Float)(implicit format: Format): Option[Float]

def hkeys[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def hlen(key: Any)(implicit format: Format): Option[Long]

def hmget[K, V](key: Any, fields: K*)(implicit format: Format, parseV: Parse[V]): Option[Map[K, V]]

def hmset(key: Any, map: Iterable[Product2[Any, Any]])(implicit format: Format): Boolean

val host: Null

val hr: HashRing[IdentifiableRedisClientPool]

def hscan[A](key: Any, cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

def hset(key: Any, field: Any, value: Any)(implicit format: Format): Boolean

HashOperations

def hsetnx(key: Any, field: Any, value: Any)(implicit format: Format): Boolean

def hvals[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def ifDebug(message: ⇒ String): Unit

def ifError(message: ⇒ String): Unit

def ifInfo(message: ⇒ String): Unit

def ifTrace(message: ⇒ String): Unit

def ifWarn(message: ⇒ String): Unit

var in: InputStream

def incr(key: Any)(implicit format: Format): Option[Long]

def incrby(key: Any, increment: Int)(implicit format: Format): Option[Long]

def incrbyfloat(key: Any, increment: Float)(implicit format: Format): Option[Float]

def info: Nothing

def info(message: String, error: Throwable): Unit

def info(message: String, values: AnyRef*): Unit

def initialize: Boolean

val integerReply: Reply[Option[Int]]

final def isInstanceOf[T0]: Boolean

def keys[A](pattern: Any = "*")(implicit format: Format, parse: Parse[A]): Some[List[Option[A]]]

Operations

def lastsave: Nothing

def lindex[A](key: Any, index: Int)(implicit format: Format, parse: Parse[A]): Option[A]

def listServers: List[ClusterNode]

def llen(key: Any)(implicit format: Format): Option[Long]

val longReply: Reply[Option[Long]]

def lpop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def lpush(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

ListOperations

def lpushx(key: Any, value: Any)(implicit format: Format): Option[Long]

def lrange[A](key: Any, start: Int, end: Int)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

def lrem(key: Any, count: Int, value: Any)(implicit format: Format): Option[Long]

def lset(key: Any, index: Int, value: Any)(implicit format: Format): Boolean

def ltrim(key: Any, start: Int, end: Int)(implicit format: Format): Boolean

def mget[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

def monitor: Nothing

def move(key: Any, db: Int)(implicit format: Format): Nothing

def mset(kvs: (Any, Any)*)(implicit format: Format): Boolean

def msetnx(kvs: (Any, Any)*)(implicit format: Format): Boolean

val multiBulkReply: MultiReply

final def ne(arg0: AnyRef): Boolean

def nodeForKey(key: Any)(implicit format: Format): IdentifiableRedisClientPool

final def notify(): Unit

final def notifyAll(): Unit

def onAllConns[T](body: (RedisClient) ⇒ T): ArrayBuffer[T]

var out: OutputStream

val pairBulkReply: PairReply

def persist(key: Any)(implicit format: Format): Boolean

def pexpire(key: Any, expiry: Int)(implicit format: Format): Boolean

def pexpireat(key: Any, expiry: Long)(implicit format: Format): Boolean

def pfadd(key: Any, value: Any, values: Any*): Option[Long]

def pfcount(keys: Any*): Option[Long]

def pfmerge(destination: Any, sources: Any*): Boolean

def ping: Option[String]

val port: Int

def processForKey[T](key: Any)(body: (RedisCommand) ⇒ T)(implicit format: Format): T

def psetex(key: Any, expiryInMillis: Long, value: Any)(implicit format: Format): Boolean

def pttl(key: Any)(implicit format: Format): Option[Long]

def publish(channel: String, msg: String): Option[Long]

def queuedReplyInt: Reply[Option[Int]]

def queuedReplyList: MultiReply

def queuedReplyLong: Reply[Option[Long]]

def quit: Boolean

def randkey[A](implicit parse: Parse[A]): Nothing

def randomkey[A](implicit parse: Parse[A]): Nothing

def readCounted(count: Int): Array[Byte]

def readLine: Array[Byte]

def receive[T](pf: Reply[T]): T

def reconnect: Boolean

def removeServer(nodename: String): Unit

def rename(oldkey: Any, newkey: Any)(implicit format: Format): Boolean

def renamenx(oldkey: Any, newkey: Any)(implicit format: Format): Boolean

def replaceServer(server: ClusterNode): Unit

Use Case: Suppose I have a big list of key/value pairs which are replicated in 2 Redis servers - one having test values for every key and the other having production values for the same set of keys.

def rpop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def rpoplpush[A](srcKey: Any, dstKey: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def rpush(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

def rpushx(key: Any, value: Any)(implicit format: Format): Option[Long]

def sadd(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

SetOperations

def save: Boolean

NodeOperations

def scan[A](cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

def scard(key: Any)(implicit format: Format): Option[Long]

def scriptExists(shahash: String): Option[Int]

def scriptFlush: Option[String]

def scriptLoad(luaCode: String): Option[String]

def sdiff[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

def sdiffstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

val secret: Option[Any]

def select(index: Int): Nothing

def send[A](command: String)(result: ⇒ A): A

def send[A](command: String, args: Seq[Any])(result: ⇒ A)(implicit format: Format): A

def set(key: Any, value: Any, onlyIfExists: Boolean, time: SecondsOrMillis): Boolean

def set(key: Any, value: Any)(implicit format: Format): Boolean

StringOperations

def setConfig(key: Any, value: Any)(implicit format: Format): Option[String]

def setbit(key: Any, offset: Int, value: Any)(implicit format: Format): Option[Int]

def setex(key: Any, expiry: Long, value: Any)(implicit format: Format): Boolean

def setnx(key: Any, value: Any)(implicit format: Format): Boolean

def setrange(key: Any, offset: Int, value: Any)(implicit format: Format): Option[Long]

def shutdown: Boolean

val singleLineReply: SingleReply

def sinter[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

def sinterstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

def sismember(key: Any, value: Any)(implicit format: Format): Boolean

def slaveof(options: Any): Nothing

def smembers[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

def smove(sourceKey: Any, destKey: Any, value: Any)(implicit format: Format): Option[Long]

var socket: Socket

def sort[A](key: String, limit: Option[(Int, Int)] = None, desc: Boolean = false, alpha: Boolean = false, by: Option[String] = None, get: List[String] = Nil)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

def sortNStore[A](key: String, limit: Option[(Int, Int)] = None, desc: Boolean = false, alpha: Boolean = false, by: Option[String] = None, get: List[String] = Nil, storeAt: String)(implicit format: Format, parse: Parse[A]): Option[Long]

def spop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def srandmember[A](key: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

def srandmember[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def srem(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

def sscan[A](key: Any, cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

def strlen(key: Any)(implicit format: Format): Option[Long]

def sunion[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

def sunionstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

final def synchronized[T0](arg0: ⇒ T0): T0

val timeout: Int

def toString(): String

def trace(message: String, error: Throwable): Unit

def trace(message: String, values: AnyRef*): Unit

def ttl(key: Any)(implicit format: Format): Option[Long]

def unwatch(): Boolean

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def warn(message: String, error: Throwable): Unit

def warn(message: String, values: AnyRef*): Unit

def watch(key: Any, keys: Any*)(implicit format: Format): Boolean

def write(data: Array[Byte]): Unit

def write_to_socket(data: Array[Byte])(op: (OutputStream) ⇒ Unit): Unit

def zadd(key: Any, score: Double, member: Any, scoreVals: (Double, Any)*)(implicit format: Format): Option[Long]

SortedSetOperations

def zcard(key: Any)(implicit format: Format): Option[Long]

def zcount(key: Any, min: Double = Double.NegativeInfinity, max: Double = Double.PositiveInfinity, minInclusive: Boolean = true, maxInclusive: Boolean = true)(implicit format: Format): Option[Long]

def zincrby(key: Any, incr: Double, member: Any)(implicit format: Format): Option[Double]

def zinterstore(dstKey: Any, keys: Iterable[Any], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zinterstoreWeighted(dstKey: Any, kws: Iterable[Product2[Any, Double]], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zrange[A](key: Any, start: Int = 0, end: Int = 1, sortAs: SortOrder)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangeWithScore[A](key: Any, start: Int = 0, end: Int = 1, sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[(A, Double)]]

def zrangebylex[A](key: Any, min: String, max: String, limit: Option[(Int, Int)])(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangebyscore[A](key: Any, min: Double = Double.NegativeInfinity, minInclusive: Boolean = true, max: Double = Double.PositiveInfinity, maxInclusive: Boolean = true, limit: Option[(Int, Int)], sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangebyscoreWithScore[A](key: Any, min: Double = Double.NegativeInfinity, minInclusive: Boolean = true, max: Double = Double.PositiveInfinity, maxInclusive: Boolean = true, limit: Option[(Int, Int)], sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[(A, Double)]]

def zrank(key: Any, member: Any, reverse: Boolean = false)(implicit format: Format): Option[Long]

def zrem(key: Any, member: Any, members: Any*)(implicit format: Format): Option[Long]

def zremrangebyrank(key: Any, start: Int = 0, end: Int = 1)(implicit format: Format): Option[Long]

def zremrangebyscore(key: Any, start: Double = Double.NegativeInfinity, end: Double = Double.PositiveInfinity)(implicit format: Format): Option[Long]

def zscan[A](key: Any, cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

def zscore(key: Any, element: Any)(implicit format: Format): Option[Double]

def zunionstore(dstKey: Any, keys: Iterable[Any], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zunionstoreWeighted(dstKey: Any, kws: Iterable[Product2[Any, Double]], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def set(key: Any, value: Any, nxxx: Any, expx: Any, time: Long): Boolean

def slaveOf(options: Any): Boolean