Parent

Redis::Distributed

Attributes

ring[R]

Public Class Methods

new(node_configs, options = {}) click to toggle source
# File lib/redis/distributed.rb, line 18
def initialize(node_configs, options = {})
  @tag = options.delete(:tag) || /^\{(.+?)\}/
  @ring = options.delete(:ring) || HashRing.new
  @default_options = options
  node_configs.each { |node_config| add_node(node_config) }
  @subscribed_node = nil
end

Public Instance Methods

[](key) click to toggle source
# File lib/redis/distributed.rb, line 335
def [](key)
  get(key)
end
[]=(key,value) click to toggle source
# File lib/redis/distributed.rb, line 339
def []=(key,value)
  set(key, value)
end
_bpop(cmd, args) click to toggle source
# File lib/redis/distributed.rb, line 386
def _bpop(cmd, args)
  options = {}

  case args.last
  when Hash
    options = args.pop
  when Integer
    # Issue deprecation notice in obnoxious mode...
    options[:timeout] = args.pop
  end

  if args.size > 1
    # Issue deprecation notice in obnoxious mode...
  end

  keys = args.flatten

  ensure_same_node(cmd, keys) do |node|
    node.__send__(cmd, keys, options)
  end
end
_eval(cmd, args) click to toggle source
# File lib/redis/distributed.rb, line 783
def _eval(cmd, args)
  script = args.shift
  options = args.pop if args.last.is_a?(Hash)
  options ||= {}

  keys = args.shift || options[:keys] || []
  argv = args.shift || options[:argv] || []

  ensure_same_node(cmd, keys) do |node|
    node.send(cmd, script, keys, argv)
  end
end
add_node(options) click to toggle source
# File lib/redis/distributed.rb, line 34
def add_node(options)
  options = { :url => options } if options.is_a?(String)
  options = @default_options.merge(options)
  @ring.add_node Redis.new( options )
end
append(key, value) click to toggle source

Append a value to a key.

# File lib/redis/distributed.rb, line 309
def append(key, value)
  node_for(key).append(key, value)
end
bgsave() click to toggle source

Asynchronously save the dataset to disk.

# File lib/redis/distributed.rb, line 61
def bgsave
  on_each_node :bgsave
end
bitcount(key, start = 0, stop = -1) click to toggle source

Count the number of set bits in a range of the string value stored at key.

# File lib/redis/distributed.rb, line 314
def bitcount(key, start = 0, stop = -1)
  node_for(key).bitcount(key, start, stop)
end
bitop(operation, destkey, *keys) click to toggle source

Perform a bitwise operation between strings and store the resulting string in a key.

# File lib/redis/distributed.rb, line 319
def bitop(operation, destkey, *keys)
  ensure_same_node(:bitop, [destkey] + keys) do |node|
    node.bitop(operation, destkey, *keys)
  end
end
blpop(*args) click to toggle source

Remove and get the first element in a list, or block until one is available.

# File lib/redis/distributed.rb, line 410
def blpop(*args)
  _bpop(:blpop, args)
end
brpop(*args) click to toggle source

Remove and get the last element in a list, or block until one is available.

# File lib/redis/distributed.rb, line 416
def brpop(*args)
  _bpop(:brpop, args)
end
brpoplpush(source, destination, options = {}) click to toggle source

Pop a value from a list, push it to another list and return it; or block until one is available.

# File lib/redis/distributed.rb, line 422
def brpoplpush(source, destination, options = {})
  case options
  when Integer
    # Issue deprecation notice in obnoxious mode...
    options = { :timeout => options }
  end

  ensure_same_node(:brpoplpush, [source, destination]) do |node|
    node.brpoplpush(source, destination, options)
  end
end
dbsize() click to toggle source

Return the number of keys in the selected database.

# File lib/redis/distributed.rb, line 66
def dbsize
  on_each_node :dbsize
end
decr(key) click to toggle source

Decrement the integer value of a key by one.

# File lib/redis/distributed.rb, line 212
def decr(key)
  node_for(key).decr(key)
end
decrby(key, decrement) click to toggle source

Decrement the integer value of a key by the given number.

# File lib/redis/distributed.rb, line 217
def decrby(key, decrement)
  node_for(key).decrby(key, decrement)
end
del(*args) click to toggle source

Delete a key.

# File lib/redis/distributed.rb, line 156
def del(*args)
  keys_per_node = args.group_by { |key| node_for(key) }
  keys_per_node.inject(0) do |sum, (node, keys)|
    sum + node.del(*keys)
  end
end
discard() click to toggle source

Discard all commands issued after MULTI.

# File lib/redis/distributed.rb, line 774
def discard
  raise CannotDistribute, :discard
end
dump(key) click to toggle source

Return a serialized version of the value stored at a key.

# File lib/redis/distributed.rb, line 141
def dump(key)
  node_for(key).dump(key)
end
echo(value) click to toggle source

Echo the given string.

# File lib/redis/distributed.rb, line 51
def echo(value)
  on_each_node :echo, value
end
eval(*args) click to toggle source

Evaluate Lua script.

# File lib/redis/distributed.rb, line 797
def eval(*args)
  _eval(:eval, args)
end
evalsha(*args) click to toggle source

Evaluate Lua script by its SHA.

# File lib/redis/distributed.rb, line 802
def evalsha(*args)
  _eval(:evalsha, args)
end
exec() click to toggle source

Execute all commands issued after MULTI.

# File lib/redis/distributed.rb, line 769
def exec
  raise CannotDistribute, :exec
end
exists(key) click to toggle source

Determine if a key exists.

# File lib/redis/distributed.rb, line 164
def exists(key)
  node_for(key).exists(key)
end
expire(key, seconds) click to toggle source

Set a key's time to live in seconds.

# File lib/redis/distributed.rb, line 111
def expire(key, seconds)
  node_for(key).expire(key, seconds)
end
expireat(key, unix_time) click to toggle source

Set the expiration for a key as a UNIX timestamp.

# File lib/redis/distributed.rb, line 116
def expireat(key, unix_time)
  node_for(key).expireat(key, unix_time)
end
flushall() click to toggle source

Remove all keys from all databases.

# File lib/redis/distributed.rb, line 71
def flushall
  on_each_node :flushall
end
flushdb() click to toggle source

Remove all keys from the current database.

# File lib/redis/distributed.rb, line 76
def flushdb
  on_each_node :flushdb
end
get(key) click to toggle source

Get the value of a key.

# File lib/redis/distributed.rb, line 275
def get(key)
  node_for(key).get(key)
end
getbit(key, offset) click to toggle source

Returns the bit value at offset in the string value stored at key.

# File lib/redis/distributed.rb, line 304
def getbit(key, offset)
  node_for(key).getbit(key, offset)
end
getrange(key, start, stop) click to toggle source

Get a substring of the string stored at a key.

# File lib/redis/distributed.rb, line 294
def getrange(key, start, stop)
  node_for(key).getrange(key, start, stop)
end
getset(key, value) click to toggle source

Set the string value of a key and return its old value.

# File lib/redis/distributed.rb, line 326
def getset(key, value)
  node_for(key).getset(key, value)
end
hdel(key, field) click to toggle source

Delete one or more hash fields.

# File lib/redis/distributed.rb, line 676
def hdel(key, field)
  node_for(key).hdel(key, field)
end
hexists(key, field) click to toggle source

Determine if a hash field exists.

# File lib/redis/distributed.rb, line 681
def hexists(key, field)
  node_for(key).hexists(key, field)
end
hget(key, field) click to toggle source

Get the value of a hash field.

# File lib/redis/distributed.rb, line 662
def hget(key, field)
  node_for(key).hget(key, field)
end
hgetall(key) click to toggle source

Get all the fields and values in a hash.

# File lib/redis/distributed.rb, line 706
def hgetall(key)
  node_for(key).hgetall(key)
end
hincrby(key, field, increment) click to toggle source

Increment the integer value of a hash field by the given integer number.

# File lib/redis/distributed.rb, line 686
def hincrby(key, field, increment)
  node_for(key).hincrby(key, field, increment)
end
hincrbyfloat(key, field, increment) click to toggle source

Increment the numeric value of a hash field by the given float number.

# File lib/redis/distributed.rb, line 691
def hincrbyfloat(key, field, increment)
  node_for(key).hincrbyfloat(key, field, increment)
end
hkeys(key) click to toggle source

Get all the fields in a hash.

# File lib/redis/distributed.rb, line 696
def hkeys(key)
  node_for(key).hkeys(key)
end
hlen(key) click to toggle source

Get the number of fields in a hash.

# File lib/redis/distributed.rb, line 638
def hlen(key)
  node_for(key).hlen(key)
end
hmget(key, *fields) click to toggle source

Get the values of all the given hash fields.

# File lib/redis/distributed.rb, line 667
def hmget(key, *fields)
  node_for(key).hmget(key, *fields)
end
hmset(key, *attrs) click to toggle source

Set multiple hash fields to multiple values.

# File lib/redis/distributed.rb, line 653
def hmset(key, *attrs)
  node_for(key).hmset(key, *attrs)
end
hset(key, field, value) click to toggle source

Set the string value of a hash field.

# File lib/redis/distributed.rb, line 643
def hset(key, field, value)
  node_for(key).hset(key, field, value)
end
hsetnx(key, field, value) click to toggle source

Set the value of a hash field, only if the field does not exist.

# File lib/redis/distributed.rb, line 648
def hsetnx(key, field, value)
  node_for(key).hsetnx(key, field, value)
end
hvals(key) click to toggle source

Get all the values in a hash.

# File lib/redis/distributed.rb, line 701
def hvals(key)
  node_for(key).hvals(key)
end
incr(key) click to toggle source

Increment the integer value of a key by one.

# File lib/redis/distributed.rb, line 222
def incr(key)
  node_for(key).incr(key)
end
incrby(key, increment) click to toggle source

Increment the integer value of a key by the given integer number.

# File lib/redis/distributed.rb, line 227
def incrby(key, increment)
  node_for(key).incrby(key, increment)
end
incrbyfloat(key, increment) click to toggle source

Increment the numeric value of a key by the given float number.

# File lib/redis/distributed.rb, line 232
def incrbyfloat(key, increment)
  node_for(key).incrbyfloat(key, increment)
end
info(cmd = nil) click to toggle source

Get information and statistics about the server.

# File lib/redis/distributed.rb, line 81
def info(cmd = nil)
  on_each_node :info, cmd
end
inspect() click to toggle source
# File lib/redis/distributed.rb, line 806
def inspect
  "#<Redis client v#{Redis::VERSION} for #{nodes.map(&:id).join(', ')}>"
end
keys(glob = "*") click to toggle source

Find all keys matching the given pattern.

# File lib/redis/distributed.rb, line 169
def keys(glob = "*")
  on_each_node(:keys, glob).flatten
end
lastsave() click to toggle source

Get the UNIX time stamp of the last successful save to disk.

# File lib/redis/distributed.rb, line 86
def lastsave
  on_each_node :lastsave
end
lindex(key, index) click to toggle source

Get an element from a list by its index.

# File lib/redis/distributed.rb, line 435
def lindex(key, index)
  node_for(key).lindex(key, index)
end
linsert(key, where, pivot, value) click to toggle source

Insert an element before or after another element in a list.

# File lib/redis/distributed.rb, line 440
def linsert(key, where, pivot, value)
  node_for(key).linsert(key, where, pivot, value)
end
llen(key) click to toggle source

Get the length of a list.

# File lib/redis/distributed.rb, line 344
def llen(key)
  node_for(key).llen(key)
end
lpop(key) click to toggle source

Remove and get the first element in a list.

# File lib/redis/distributed.rb, line 369
def lpop(key)
  node_for(key).lpop(key)
end
lpush(key, value) click to toggle source

Prepend one or more values to a list.

# File lib/redis/distributed.rb, line 349
def lpush(key, value)
  node_for(key).lpush(key, value)
end
lpushx(key, value) click to toggle source

Prepend a value to a list, only if the list exists.

# File lib/redis/distributed.rb, line 354
def lpushx(key, value)
  node_for(key).lpushx(key, value)
end
lrange(key, start, stop) click to toggle source

Get a range of elements from a list.

# File lib/redis/distributed.rb, line 445
def lrange(key, start, stop)
  node_for(key).lrange(key, start, stop)
end
lrem(key, count, value) click to toggle source

Remove elements from a list.

# File lib/redis/distributed.rb, line 450
def lrem(key, count, value)
  node_for(key).lrem(key, count, value)
end
lset(key, index, value) click to toggle source

Set the value of an element in a list by its index.

# File lib/redis/distributed.rb, line 455
def lset(key, index, value)
  node_for(key).lset(key, index, value)
end
ltrim(key, start, stop) click to toggle source

Trim a list to the specified range.

# File lib/redis/distributed.rb, line 460
def ltrim(key, start, stop)
  node_for(key).ltrim(key, start, stop)
end
mapped_hmget(key, *fields) click to toggle source
# File lib/redis/distributed.rb, line 671
def mapped_hmget(key, *fields)
  Hash[*fields.zip(hmget(key, *fields)).flatten]
end
mapped_hmset(key, hash) click to toggle source
# File lib/redis/distributed.rb, line 657
def mapped_hmset(key, hash)
  node_for(key).hmset(key, *hash.to_a.flatten)
end
mapped_mget(*keys) click to toggle source
# File lib/redis/distributed.rb, line 284
def mapped_mget(*keys)
  raise CannotDistribute, :mapped_mget
end
mapped_mset(hash) click to toggle source
# File lib/redis/distributed.rb, line 261
def mapped_mset(hash)
  raise CannotDistribute, :mapped_mset
end
mapped_msetnx(hash) click to toggle source
# File lib/redis/distributed.rb, line 270
def mapped_msetnx(hash)
  raise CannotDistribute, :mapped_msetnx
end
mget(*keys) click to toggle source

Get the values of all the given keys.

# File lib/redis/distributed.rb, line 280
def mget(*keys)
  raise CannotDistribute, :mget
end
migrate(key, options) click to toggle source

Transfer a key from the connected instance to another instance.

# File lib/redis/distributed.rb, line 151
def migrate(key, options)
  raise CannotDistribute, :migrate
end
monitor() click to toggle source

Listen for all requests received by the server in real time.

# File lib/redis/distributed.rb, line 91
def monitor
  raise NotImplementedError
end
move(key, db) click to toggle source

Move a key to another database.

# File lib/redis/distributed.rb, line 174
def move(key, db)
  node_for(key).move(key, db)
end
mset(*args) click to toggle source

Set multiple keys to multiple values.

# File lib/redis/distributed.rb, line 257
def mset(*args)
  raise CannotDistribute, :mset
end
msetnx(*args) click to toggle source

Set multiple keys to multiple values, only if none of the keys exist.

# File lib/redis/distributed.rb, line 266
def msetnx(*args)
  raise CannotDistribute, :msetnx
end
multi() click to toggle source

Mark the start of a transaction block.

# File lib/redis/distributed.rb, line 764
def multi
  raise CannotDistribute, :multi
end
node_for(key) click to toggle source
# File lib/redis/distributed.rb, line 26
def node_for(key)
  @ring.get_node(key_tag(key.to_s) || key.to_s)
end
nodes() click to toggle source
# File lib/redis/distributed.rb, line 30
def nodes
  @ring.nodes
end
persist(key) click to toggle source

Remove the expiration from a key.

# File lib/redis/distributed.rb, line 106
def persist(key)
  node_for(key).persist(key)
end
pexpire(key, milliseconds) click to toggle source

Set a key's time to live in milliseconds.

# File lib/redis/distributed.rb, line 126
def pexpire(key, milliseconds)
  node_for(key).pexpire(key, milliseconds)
end
pexpireat(key, ms_unix_time) click to toggle source

Set the expiration for a key as number of milliseconds from UNIX Epoch.

# File lib/redis/distributed.rb, line 131
def pexpireat(key, ms_unix_time)
  node_for(key).pexpireat(key, ms_unix_time)
end
ping() click to toggle source

Ping the server.

# File lib/redis/distributed.rb, line 46
def ping
  on_each_node :ping
end
pipelined() click to toggle source
# File lib/redis/distributed.rb, line 759
def pipelined
  raise CannotDistribute, :pipelined
end
psetex(key, ttl, value) click to toggle source

Set the time to live in milliseconds of a key.

# File lib/redis/distributed.rb, line 247
def psetex(key, ttl, value)
  node_for(key).psetex(key, ttl, value)
end
psubscribe(*channels, &block) click to toggle source

Listen for messages published to channels matching the given patterns.

# File lib/redis/distributed.rb, line 739
def psubscribe(*channels, &block)
  raise NotImplementedError
end
pttl(key) click to toggle source

Get the time to live (in milliseconds) for a key.

# File lib/redis/distributed.rb, line 136
def pttl(key)
  node_for(key).pttl(key)
end
publish(channel, message) click to toggle source

Post a message to a channel.

# File lib/redis/distributed.rb, line 711
def publish(channel, message)
  node_for(channel).publish(channel, message)
end
punsubscribe(*channels) click to toggle source

Stop listening for messages posted to channels matching the given patterns.

# File lib/redis/distributed.rb, line 745
def punsubscribe(*channels)
  raise NotImplementedError
end
quit() click to toggle source

Close the connection.

# File lib/redis/distributed.rb, line 56
def quit
  on_each_node :quit
end
randomkey() click to toggle source

Return a random key from the keyspace.

# File lib/redis/distributed.rb, line 179
def randomkey
  raise CannotDistribute, :randomkey
end
rename(old_name, new_name) click to toggle source

Rename a key.

# File lib/redis/distributed.rb, line 184
def rename(old_name, new_name)
  ensure_same_node(:rename, [old_name, new_name]) do |node|
    node.rename(old_name, new_name)
  end
end
renamenx(old_name, new_name) click to toggle source

Rename a key, only if the new key does not exist.

# File lib/redis/distributed.rb, line 191
def renamenx(old_name, new_name)
  ensure_same_node(:renamenx, [old_name, new_name]) do |node|
    node.renamenx(old_name, new_name)
  end
end
restore(key, ttl, serialized_value) click to toggle source

Create a key using the serialized value, previously obtained using DUMP.

# File lib/redis/distributed.rb, line 146
def restore(key, ttl, serialized_value)
  node_for(key).restore(key, ttl, serialized_value)
end
rpop(key) click to toggle source

Remove and get the last element in a list.

# File lib/redis/distributed.rb, line 374
def rpop(key)
  node_for(key).rpop(key)
end
rpoplpush(source, destination) click to toggle source

Remove the last element in a list, append it to another list and return it.

# File lib/redis/distributed.rb, line 380
def rpoplpush(source, destination)
  ensure_same_node(:rpoplpush, [source, destination]) do |node|
    node.rpoplpush(source, destination)
  end
end
rpush(key, value) click to toggle source

Append one or more values to a list.

# File lib/redis/distributed.rb, line 359
def rpush(key, value)
  node_for(key).rpush(key, value)
end
rpushx(key, value) click to toggle source

Append a value to a list, only if the list exists.

# File lib/redis/distributed.rb, line 364
def rpushx(key, value)
  node_for(key).rpushx(key, value)
end
sadd(key, member) click to toggle source

Add one or more members to a set.

# File lib/redis/distributed.rb, line 470
def sadd(key, member)
  node_for(key).sadd(key, member)
end
save() click to toggle source

Synchronously save the dataset to disk.

# File lib/redis/distributed.rb, line 96
def save
  on_each_node :save
end
scard(key) click to toggle source

Get the number of members in a set.

# File lib/redis/distributed.rb, line 465
def scard(key)
  node_for(key).scard(key)
end
script(subcommand, *args) click to toggle source

Control remote script registry.

# File lib/redis/distributed.rb, line 779
def script(subcommand, *args)
  on_each_node(:script, subcommand, *args)
end
sdiff(*keys) click to toggle source

Subtract multiple sets.

# File lib/redis/distributed.rb, line 507
def sdiff(*keys)
  ensure_same_node(:sdiff, keys) do |node|
    node.sdiff(*keys)
  end
end
sdiffstore(destination, *keys) click to toggle source

Subtract multiple sets and store the resulting set in a key.

# File lib/redis/distributed.rb, line 514
def sdiffstore(destination, *keys)
  ensure_same_node(:sdiffstore, [destination] + keys) do |node|
    node.sdiffstore(destination, *keys)
  end
end
select(db) click to toggle source

Change the selected database for the current connection.

# File lib/redis/distributed.rb, line 41
def select(db)
  on_each_node :select, db
end
set(key, value, options = {}) click to toggle source

Set the string value of a key.

# File lib/redis/distributed.rb, line 237
def set(key, value, options = {})
  node_for(key).set(key, value, options)
end
setbit(key, offset, value) click to toggle source

Sets or clears the bit at offset in the string value stored at key.

# File lib/redis/distributed.rb, line 299
def setbit(key, offset, value)
  node_for(key).setbit(key, offset, value)
end
setex(key, ttl, value) click to toggle source

Set the time to live in seconds of a key.

# File lib/redis/distributed.rb, line 242
def setex(key, ttl, value)
  node_for(key).setex(key, ttl, value)
end
setnx(key, value) click to toggle source

Set the value of a key, only if the key does not exist.

# File lib/redis/distributed.rb, line 252
def setnx(key, value)
  node_for(key).setnx(key, value)
end
setrange(key, offset, value) click to toggle source

Overwrite part of a string at key starting at the specified offset.

# File lib/redis/distributed.rb, line 289
def setrange(key, offset, value)
  node_for(key).setrange(key, offset, value)
end
sinter(*keys) click to toggle source

Intersect multiple sets.

# File lib/redis/distributed.rb, line 521
def sinter(*keys)
  ensure_same_node(:sinter, keys) do |node|
    node.sinter(*keys)
  end
end
sinterstore(destination, *keys) click to toggle source

Intersect multiple sets and store the resulting set in a key.

# File lib/redis/distributed.rb, line 528
def sinterstore(destination, *keys)
  ensure_same_node(:sinterstore, [destination] + keys) do |node|
    node.sinterstore(destination, *keys)
  end
end
sismember(key, member) click to toggle source

Determine if a given value is a member of a set.

# File lib/redis/distributed.rb, line 497
def sismember(key, member)
  node_for(key).sismember(key, member)
end
smembers(key) click to toggle source

Get all the members in a set.

# File lib/redis/distributed.rb, line 502
def smembers(key)
  node_for(key).smembers(key)
end
smove(source, destination, member) click to toggle source

Move a member from one set to another.

# File lib/redis/distributed.rb, line 490
def smove(source, destination, member)
  ensure_same_node(:smove, [source, destination]) do |node|
    node.smove(source, destination, member)
  end
end
sort(key, options = {}) click to toggle source

Sort the elements in a list, set or sorted set.

# File lib/redis/distributed.rb, line 198
def sort(key, options = {})
  keys = [key, options[:by], options[:store], *Array(options[:get])].compact

  ensure_same_node(:sort, keys) do |node|
    node.sort(key, options)
  end
end
spop(key) click to toggle source

Remove and return a random member from a set.

# File lib/redis/distributed.rb, line 480
def spop(key)
  node_for(key).spop(key)
end
srandmember(key, count = nil) click to toggle source

Get a random member from a set.

# File lib/redis/distributed.rb, line 485
def srandmember(key, count = nil)
  node_for(key).srandmember(key, count)
end
srem(key, member) click to toggle source

Remove one or more members from a set.

# File lib/redis/distributed.rb, line 475
def srem(key, member)
  node_for(key).srem(key, member)
end
strlen(key) click to toggle source

Get the length of the value stored in a key.

# File lib/redis/distributed.rb, line 331
def strlen(key)
  node_for(key).strlen(key)
end
subscribe(channel, *channels, &block) click to toggle source

Listen for messages published to the given channels.

# File lib/redis/distributed.rb, line 720
def subscribe(channel, *channels, &block)
  if channels.empty?
    @subscribed_node = node_for(channel)
    @subscribed_node.subscribe(channel, &block)
  else
    ensure_same_node(:subscribe, [channel] + channels) do |node|
      @subscribed_node = node
      node.subscribe(channel, *channels, &block)
    end
  end
end
subscribed?() click to toggle source
# File lib/redis/distributed.rb, line 715
def subscribed?
  !! @subscribed_node
end
sunion(*keys) click to toggle source

Add multiple sets.

# File lib/redis/distributed.rb, line 535
def sunion(*keys)
  ensure_same_node(:sunion, keys) do |node|
    node.sunion(*keys)
  end
end
sunionstore(destination, *keys) click to toggle source

Add multiple sets and store the resulting set in a key.

# File lib/redis/distributed.rb, line 542
def sunionstore(destination, *keys)
  ensure_same_node(:sunionstore, [destination] + keys) do |node|
    node.sunionstore(destination, *keys)
  end
end
time() click to toggle source

Get server time: an UNIX timestamp and the elapsed microseconds in the current second.

# File lib/redis/distributed.rb, line 101
def time
  on_each_node :time
end
ttl(key) click to toggle source

Get the time to live (in seconds) for a key.

# File lib/redis/distributed.rb, line 121
def ttl(key)
  node_for(key).ttl(key)
end
type(key) click to toggle source

Determine the type stored at key.

# File lib/redis/distributed.rb, line 207
def type(key)
  node_for(key).type(key)
end
unsubscribe(*channels) click to toggle source

Stop listening for messages posted to the given channels.

# File lib/redis/distributed.rb, line 733
def unsubscribe(*channels)
  raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
  @subscribed_node.unsubscribe(*channels)
end
unwatch() click to toggle source

Forget about all watched keys.

# File lib/redis/distributed.rb, line 755
def unwatch
  raise CannotDistribute, :unwatch
end
watch(*keys) click to toggle source

Watch the given keys to determine execution of the MULTI/EXEC block.

# File lib/redis/distributed.rb, line 750
def watch(*keys)
  raise CannotDistribute, :watch
end
zadd(key, *args) click to toggle source

Add one or more members to a sorted set, or update the score for members that already exist.

# File lib/redis/distributed.rb, line 555
def zadd(key, *args)
  node_for(key).zadd(key, *args)
end
zcard(key) click to toggle source

Get the number of members in a sorted set.

# File lib/redis/distributed.rb, line 549
def zcard(key)
  node_for(key).zcard(key)
end
zcount(key, min, max) click to toggle source

Get the number of members in a particular score range.

# File lib/redis/distributed.rb, line 618
def zcount(key, min, max)
  node_for(key).zcount(key, min, max)
end
zincrby(key, increment, member) click to toggle source

Increment the score of a member in a sorted set.

# File lib/redis/distributed.rb, line 560
def zincrby(key, increment, member)
  node_for(key).zincrby(key, increment, member)
end
zinterstore(destination, keys, options = {}) click to toggle source

Intersect multiple sorted sets and store the resulting sorted set in a new key.

# File lib/redis/distributed.rb, line 624
def zinterstore(destination, keys, options = {})
  ensure_same_node(:zinterstore, [destination] + keys) do |node|
    node.zinterstore(destination, keys, options)
  end
end
zrange(key, start, stop, options = {}) click to toggle source

Return a range of members in a sorted set, by index.

# File lib/redis/distributed.rb, line 575
def zrange(key, start, stop, options = {})
  node_for(key).zrange(key, start, stop, options)
end
zrangebyscore(key, min, max, options = {}) click to toggle source

Return a range of members in a sorted set, by score.

# File lib/redis/distributed.rb, line 602
def zrangebyscore(key, min, max, options = {})
  node_for(key).zrangebyscore(key, min, max, options)
end
zrank(key, member) click to toggle source

Determine the index of a member in a sorted set.

# File lib/redis/distributed.rb, line 586
def zrank(key, member)
  node_for(key).zrank(key, member)
end
zrem(key, member) click to toggle source

Remove one or more members from a sorted set.

# File lib/redis/distributed.rb, line 565
def zrem(key, member)
  node_for(key).zrem(key, member)
end
zremrangebyrank(key, start, stop) click to toggle source

Remove all members in a sorted set within the given indexes.

# File lib/redis/distributed.rb, line 597
def zremrangebyrank(key, start, stop)
  node_for(key).zremrangebyrank(key, start, stop)
end
zremrangebyscore(key, min, max) click to toggle source

Remove all members in a sorted set within the given scores.

# File lib/redis/distributed.rb, line 613
def zremrangebyscore(key, min, max)
  node_for(key).zremrangebyscore(key, min, max)
end
zrevrange(key, start, stop, options = {}) click to toggle source

Return a range of members in a sorted set, by index, with scores ordered from high to low.

# File lib/redis/distributed.rb, line 581
def zrevrange(key, start, stop, options = {})
  node_for(key).zrevrange(key, start, stop, options)
end
zrevrangebyscore(key, max, min, options = {}) click to toggle source

Return a range of members in a sorted set, by score, with scores ordered from high to low.

# File lib/redis/distributed.rb, line 608
def zrevrangebyscore(key, max, min, options = {})
  node_for(key).zrevrangebyscore(key, max, min, options)
end
zrevrank(key, member) click to toggle source

Determine the index of a member in a sorted set, with scores ordered from high to low.

# File lib/redis/distributed.rb, line 592
def zrevrank(key, member)
  node_for(key).zrevrank(key, member)
end
zscore(key, member) click to toggle source

Get the score associated with the given member in a sorted set.

# File lib/redis/distributed.rb, line 570
def zscore(key, member)
  node_for(key).zscore(key, member)
end
zunionstore(destination, keys, options = {}) click to toggle source

Add multiple sorted sets and store the resulting sorted set in a new key.

# File lib/redis/distributed.rb, line 631
def zunionstore(destination, keys, options = {})
  ensure_same_node(:zunionstore, [destination] + keys) do |node|
    node.zunionstore(destination, keys, options)
  end
end

Protected Instance Methods

ensure_same_node(command, keys) click to toggle source
# File lib/redis/distributed.rb, line 826
def ensure_same_node(command, keys)
  all = true

  tags = keys.map do |key|
    tag = key_tag(key)
    all = false unless tag
    tag
  end

  if (all && tags.uniq.size != 1) || (!all && keys.uniq.size != 1)
    # Not 1 unique tag or not 1 unique key
    raise CannotDistribute, command
  end

  yield(node_for(keys.first))
end
key_tag(key) click to toggle source
# File lib/redis/distributed.rb, line 822
def key_tag(key)
  key.to_s[@tag, 1] if @tag
end
node_index_for(key) click to toggle source
# File lib/redis/distributed.rb, line 818
def node_index_for(key)
  nodes.index(node_for(key))
end
on_each_node(command, *args) click to toggle source
# File lib/redis/distributed.rb, line 812
def on_each_node(command, *args)
  nodes.map do |node|
    node.send(command, *args)
  end
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.