Class: Redis::Distributed

Inherits:
Object
  • Object
show all
Defined in:
lib/redis/distributed.rb

Defined Under Namespace

Classes: CannotDistribute

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(node_configs, options = {}) ⇒ Distributed

Returns a new instance of Distributed.



18
19
20
21
22
23
24
25
 
# File 'lib/redis/distributed.rb', line 18

def initialize(node_configs, options = {})
  @tag = options[:tag] || /^\{(.+?)\}/
  @ring = options[:ring] || HashRing.new
  @node_configs = node_configs.dup
  @default_options = options.dup
  node_configs.each { |node_config| add_node(node_config) }
  @subscribed_node = nil
end

Instance Attribute Details

#ring ⇒ Object (readonly)

Returns the value of attribute ring.



16
17
18
 
# File 'lib/redis/distributed.rb', line 16

def ring
  @ring
end

Instance Method Details

#[](key) ⇒ Object 



341
342
343
 
# File 'lib/redis/distributed.rb', line 341

def [](key)
  get(key)
end

#[]=(key, value) ⇒ Object 



345
346
347
 
# File 'lib/redis/distributed.rb', line 345

def []=(key,value)
  set(key, value)
end

#_bpop(cmd, args) ⇒ Object 



392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
 
# File 'lib/redis/distributed.rb', line 392

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) ⇒ Object 



807
808
809
810
811
812
813
814
815
816
817
818
 
# File 'lib/redis/distributed.rb', line 807

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) ⇒ Object 



35
36
37
38
39
 
# File 'lib/redis/distributed.rb', line 35

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) ⇒ Object

Append a value to a key.



310
311
312
 
# File 'lib/redis/distributed.rb', line 310

def append(key, value)
  node_for(key).append(key, value)
end

#bgsave ⇒ Object

Asynchronously save the dataset to disk.



62
63
64
 
# File 'lib/redis/distributed.rb', line 62

def bgsave
  on_each_node :bgsave
end

#bitcount(key, start = 0, stop = -1)) ⇒ Object

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



315
316
317
 
# File 'lib/redis/distributed.rb', line 315

def bitcount(key, start = 0, stop = -1)
  node_for(key).bitcount(key, start, stop)
end

#bitop(operation, destkey, *keys) ⇒ Object

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



320
321
322
323
324
 
# File 'lib/redis/distributed.rb', line 320

def bitop(operation, destkey, *keys)
  ensure_same_node(:bitop, [destkey] + keys) do |node|
    node.bitop(operation, destkey, *keys)
  end
end

#bitpos(key, bit, start = nil, stop = nil) ⇒ Object

Return the position of the first bit set to 1 or 0 in a string.



327
328
329
 
# File 'lib/redis/distributed.rb', line 327

def bitpos(key, bit, start=nil, stop=nil)
  node_for(key).bitpos(key, bit, start, stop)
end

#blpop(*args) ⇒ Object

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



416
417
418
 
# File 'lib/redis/distributed.rb', line 416

def blpop(*args)
  _bpop(:blpop, args)
end

#brpop(*args) ⇒ Object

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



422
423
424
 
# File 'lib/redis/distributed.rb', line 422

def brpop(*args)
  _bpop(:brpop, args)
end

#brpoplpush(source, destination, options = {}) ⇒ Object

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



428
429
430
431
432
433
434
435
436
437
438
 
# File 'lib/redis/distributed.rb', line 428

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 ⇒ Object

Return the number of keys in the selected database.



67
68
69
 
# File 'lib/redis/distributed.rb', line 67

def dbsize
  on_each_node :dbsize
end

#decr(key) ⇒ Object

Decrement the integer value of a key by one.



213
214
215
 
# File 'lib/redis/distributed.rb', line 213

def decr(key)
  node_for(key).decr(key)
end

#decrby(key, decrement) ⇒ Object

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



218
219
220
 
# File 'lib/redis/distributed.rb', line 218

def decrby(key, decrement)
  node_for(key).decrby(key, decrement)
end

#del(*args) ⇒ Object

Delete a key.



157
158
159
160
161
162
 
# File 'lib/redis/distributed.rb', line 157

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 ⇒ Object

Discard all commands issued after MULTI.

Raises:



780
781
782
 
# File 'lib/redis/distributed.rb', line 780

def discard
  raise CannotDistribute, :discard
end

#dump(key) ⇒ Object

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



142
143
144
 
# File 'lib/redis/distributed.rb', line 142

def dump(key)
  node_for(key).dump(key)
end

#dup ⇒ Object 



834
835
836
 
# File 'lib/redis/distributed.rb', line 834

def dup
  self.class.new(@node_configs, @default_options)
end

#echo(value) ⇒ Object

Echo the given string.



52
53
54
 
# File 'lib/redis/distributed.rb', line 52

def echo(value)
  on_each_node :echo, value
end

#eval(*args) ⇒ Object

Evaluate Lua script.



821
822
823
 
# File 'lib/redis/distributed.rb', line 821

def eval(*args)
  _eval(:eval, args)
end

#evalsha(*args) ⇒ Object

Evaluate Lua script by its SHA.



826
827
828
 
# File 'lib/redis/distributed.rb', line 826

def evalsha(*args)
  _eval(:evalsha, args)
end

#exec ⇒ Object

Execute all commands issued after MULTI.

Raises:



775
776
777
 
# File 'lib/redis/distributed.rb', line 775

def exec
  raise CannotDistribute, :exec
end

#exists(key) ⇒ Object

Determine if a key exists.



165
166
167
 
# File 'lib/redis/distributed.rb', line 165

def exists(key)
  node_for(key).exists(key)
end

#expire(key, seconds) ⇒ Object

Set a key's time to live in seconds.



112
113
114
 
# File 'lib/redis/distributed.rb', line 112

def expire(key, seconds)
  node_for(key).expire(key, seconds)
end

#expireat(key, unix_time) ⇒ Object

Set the expiration for a key as a UNIX timestamp.



117
118
119
 
# File 'lib/redis/distributed.rb', line 117

def expireat(key, unix_time)
  node_for(key).expireat(key, unix_time)
end

#flushall ⇒ Object

Remove all keys from all databases.



72
73
74
 
# File 'lib/redis/distributed.rb', line 72

def flushall
  on_each_node :flushall
end

#flushdb ⇒ Object

Remove all keys from the current database.



77
78
79
 
# File 'lib/redis/distributed.rb', line 77

def flushdb
  on_each_node :flushdb
end

#get(key) ⇒ Object

Get the value of a key.



276
277
278
 
# File 'lib/redis/distributed.rb', line 276

def get(key)
  node_for(key).get(key)
end

#getbit(key, offset) ⇒ Object

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



305
306
307
 
# File 'lib/redis/distributed.rb', line 305

def getbit(key, offset)
  node_for(key).getbit(key, offset)
end

#getrange(key, start, stop) ⇒ Object

Get a substring of the string stored at a key.



295
296
297
 
# File 'lib/redis/distributed.rb', line 295

def getrange(key, start, stop)
  node_for(key).getrange(key, start, stop)
end

#getset(key, value) ⇒ Object

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



332
333
334
 
# File 'lib/redis/distributed.rb', line 332

def getset(key, value)
  node_for(key).getset(key, value)
end

#hdel(key, field) ⇒ Object

Delete one or more hash fields.



682
683
684
 
# File 'lib/redis/distributed.rb', line 682

def hdel(key, field)
  node_for(key).hdel(key, field)
end

#hexists(key, field) ⇒ Object

Determine if a hash field exists.



687
688
689
 
# File 'lib/redis/distributed.rb', line 687

def hexists(key, field)
  node_for(key).hexists(key, field)
end

#hget(key, field) ⇒ Object

Get the value of a hash field.



668
669
670
 
# File 'lib/redis/distributed.rb', line 668

def hget(key, field)
  node_for(key).hget(key, field)
end

#hgetall(key) ⇒ Object

Get all the fields and values in a hash.



712
713
714
 
# File 'lib/redis/distributed.rb', line 712

def hgetall(key)
  node_for(key).hgetall(key)
end

#hincrby(key, field, increment) ⇒ Object

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



692
693
694
 
# File 'lib/redis/distributed.rb', line 692

def hincrby(key, field, increment)
  node_for(key).hincrby(key, field, increment)
end

#hincrbyfloat(key, field, increment) ⇒ Object

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



697
698
699
 
# File 'lib/redis/distributed.rb', line 697

def hincrbyfloat(key, field, increment)
  node_for(key).hincrbyfloat(key, field, increment)
end

#hkeys(key) ⇒ Object

Get all the fields in a hash.



702
703
704
 
# File 'lib/redis/distributed.rb', line 702

def hkeys(key)
  node_for(key).hkeys(key)
end

#hlen(key) ⇒ Object

Get the number of fields in a hash.



644
645
646
 
# File 'lib/redis/distributed.rb', line 644

def hlen(key)
  node_for(key).hlen(key)
end

#hmget(key, *fields) ⇒ Object

Get the values of all the given hash fields.



673
674
675
 
# File 'lib/redis/distributed.rb', line 673

def hmget(key, *fields)
  node_for(key).hmget(key, *fields)
end

#hmset(key, *attrs) ⇒ Object

Set multiple hash fields to multiple values.



659
660
661
 
# File 'lib/redis/distributed.rb', line 659

def hmset(key, *attrs)
  node_for(key).hmset(key, *attrs)
end

#hset(key, field, value) ⇒ Object

Set the string value of a hash field.



649
650
651
 
# File 'lib/redis/distributed.rb', line 649

def hset(key, field, value)
  node_for(key).hset(key, field, value)
end

#hsetnx(key, field, value) ⇒ Object

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



654
655
656
 
# File 'lib/redis/distributed.rb', line 654

def hsetnx(key, field, value)
  node_for(key).hsetnx(key, field, value)
end

#hvals(key) ⇒ Object

Get all the values in a hash.



707
708
709
 
# File 'lib/redis/distributed.rb', line 707

def hvals(key)
  node_for(key).hvals(key)
end

#incr(key) ⇒ Object

Increment the integer value of a key by one.



223
224
225
 
# File 'lib/redis/distributed.rb', line 223

def incr(key)
  node_for(key).incr(key)
end

#incrby(key, increment) ⇒ Object

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



228
229
230
 
# File 'lib/redis/distributed.rb', line 228

def incrby(key, increment)
  node_for(key).incrby(key, increment)
end

#incrbyfloat(key, increment) ⇒ Object

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



233
234
235
 
# File 'lib/redis/distributed.rb', line 233

def incrbyfloat(key, increment)
  node_for(key).incrbyfloat(key, increment)
end

#info(cmd = nil) ⇒ Object

Get information and statistics about the server.



82
83
84
 
# File 'lib/redis/distributed.rb', line 82

def info(cmd = nil)
  on_each_node :info, cmd
end

#inspect ⇒ Object 



830
831
832
 
# File 'lib/redis/distributed.rb', line 830

def inspect
  "#<Redis client v#{Redis::VERSION} for #{nodes.map(&:id).join(', ')}>"
end

#keys(glob = "*") ⇒ Object

Find all keys matching the given pattern.



170
171
172
 
# File 'lib/redis/distributed.rb', line 170

def keys(glob = "*")
  on_each_node(:keys, glob).flatten
end

#lastsave ⇒ Object

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



87
88
89
 
# File 'lib/redis/distributed.rb', line 87

def lastsave
  on_each_node :lastsave
end

#lindex(key, index) ⇒ Object

Get an element from a list by its index.



441
442
443
 
# File 'lib/redis/distributed.rb', line 441

def lindex(key, index)
  node_for(key).lindex(key, index)
end

#linsert(key, where, pivot, value) ⇒ Object

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



446
447
448
 
# File 'lib/redis/distributed.rb', line 446

def linsert(key, where, pivot, value)
  node_for(key).linsert(key, where, pivot, value)
end

#llen(key) ⇒ Object

Get the length of a list.



350
351
352
 
# File 'lib/redis/distributed.rb', line 350

def llen(key)
  node_for(key).llen(key)
end

#lpop(key) ⇒ Object

Remove and get the first element in a list.



375
376
377
 
# File 'lib/redis/distributed.rb', line 375

def lpop(key)
  node_for(key).lpop(key)
end

#lpush(key, value) ⇒ Object

Prepend one or more values to a list.



355
356
357
 
# File 'lib/redis/distributed.rb', line 355

def lpush(key, value)
  node_for(key).lpush(key, value)
end

#lpushx(key, value) ⇒ Object

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



360
361
362
 
# File 'lib/redis/distributed.rb', line 360

def lpushx(key, value)
  node_for(key).lpushx(key, value)
end

#lrange(key, start, stop) ⇒ Object

Get a range of elements from a list.



451
452
453
 
# File 'lib/redis/distributed.rb', line 451

def lrange(key, start, stop)
  node_for(key).lrange(key, start, stop)
end

#lrem(key, count, value) ⇒ Object

Remove elements from a list.



456
457
458
 
# File 'lib/redis/distributed.rb', line 456

def lrem(key, count, value)
  node_for(key).lrem(key, count, value)
end

#lset(key, index, value) ⇒ Object

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



461
462
463
 
# File 'lib/redis/distributed.rb', line 461

def lset(key, index, value)
  node_for(key).lset(key, index, value)
end

#ltrim(key, start, stop) ⇒ Object

Trim a list to the specified range.



466
467
468
 
# File 'lib/redis/distributed.rb', line 466

def ltrim(key, start, stop)
  node_for(key).ltrim(key, start, stop)
end

#mapped_hmget(key, *fields) ⇒ Object 



677
678
679
 
# File 'lib/redis/distributed.rb', line 677

def mapped_hmget(key, *fields)
  Hash[*fields.zip(hmget(key, *fields)).flatten]
end

#mapped_hmset(key, hash) ⇒ Object 



663
664
665
 
# File 'lib/redis/distributed.rb', line 663

def mapped_hmset(key, hash)
  node_for(key).hmset(key, *hash.to_a.flatten)
end

#mapped_mget(*keys) ⇒ Object

Raises:



285
286
287
 
# File 'lib/redis/distributed.rb', line 285

def mapped_mget(*keys)
  raise CannotDistribute, :mapped_mget
end

#mapped_mset(hash) ⇒ Object

Raises:



262
263
264
 
# File 'lib/redis/distributed.rb', line 262

def mapped_mset(hash)
  raise CannotDistribute, :mapped_mset
end

#mapped_msetnx(hash) ⇒ Object

Raises:



271
272
273
 
# File 'lib/redis/distributed.rb', line 271

def mapped_msetnx(hash)
  raise CannotDistribute, :mapped_msetnx
end

#mget(*keys) ⇒ Object

Get the values of all the given keys.

Raises:



281
282
283
 
# File 'lib/redis/distributed.rb', line 281

def mget(*keys)
  raise CannotDistribute, :mget
end

#migrate(key, options) ⇒ Object

Transfer a key from the connected instance to another instance.

Raises:



152
153
154
 
# File 'lib/redis/distributed.rb', line 152

def migrate(key, options)
  raise CannotDistribute, :migrate
end

#monitor ⇒ Object

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

Raises:

  • (NotImplementedError) 


92
93
94
 
# File 'lib/redis/distributed.rb', line 92

def monitor
  raise NotImplementedError
end

#move(key, db) ⇒ Object

Move a key to another database.



175
176
177
 
# File 'lib/redis/distributed.rb', line 175

def move(key, db)
  node_for(key).move(key, db)
end

#mset(*args) ⇒ Object

Set multiple keys to multiple values.

Raises:



258
259
260
 
# File 'lib/redis/distributed.rb', line 258

def mset(*args)
  raise CannotDistribute, :mset
end

#msetnx(*args) ⇒ Object

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

Raises:



267
268
269
 
# File 'lib/redis/distributed.rb', line 267

def msetnx(*args)
  raise CannotDistribute, :msetnx
end

#multi ⇒ Object

Mark the start of a transaction block.

Raises:



770
771
772
 
# File 'lib/redis/distributed.rb', line 770

def multi
  raise CannotDistribute, :multi
end

#node_for(key) ⇒ Object 



27
28
29
 
# File 'lib/redis/distributed.rb', line 27

def node_for(key)
  @ring.get_node(key_tag(key.to_s) || key.to_s)
end

#nodes ⇒ Object 



31
32
33
 
# File 'lib/redis/distributed.rb', line 31

def nodes
  @ring.nodes
end

#persist(key) ⇒ Object

Remove the expiration from a key.



107
108
109
 
# File 'lib/redis/distributed.rb', line 107

def persist(key)
  node_for(key).persist(key)
end

#pexpire(key, milliseconds) ⇒ Object

Set a key's time to live in milliseconds.



127
128
129
 
# File 'lib/redis/distributed.rb', line 127

def pexpire(key, milliseconds)
  node_for(key).pexpire(key, milliseconds)
end

#pexpireat(key, ms_unix_time) ⇒ Object

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



132
133
134
 
# File 'lib/redis/distributed.rb', line 132

def pexpireat(key, ms_unix_time)
  node_for(key).pexpireat(key, ms_unix_time)
end

#pfadd(key, member) ⇒ Object

Add one or more members to a HyperLogLog structure.



790
791
792
 
# File 'lib/redis/distributed.rb', line 790

def pfadd(key, member)
  node_for(key).pfadd(key, member)
end

#pfcount(key) ⇒ Object

Get the approximate cardinality of members added to HyperLogLog structure.



795
796
797
 
# File 'lib/redis/distributed.rb', line 795

def pfcount(key)
  node_for(key).pfcount(key)
end

#pfmerge(dest_key, *source_key) ⇒ Object

Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of the observed Sets of the source HyperLogLog structures.



801
802
803
804
805
 
# File 'lib/redis/distributed.rb', line 801

def pfmerge(dest_key, *source_key)
  ensure_same_node(:pfmerge, [dest_key, *source_key]) do |node|
    node.pfmerge(dest_key, *source_key)
  end
end

#ping ⇒ Object

Ping the server.



47
48
49
 
# File 'lib/redis/distributed.rb', line 47

def ping
  on_each_node :ping
end

#pipelined ⇒ Object

Raises:



765
766
767
 
# File 'lib/redis/distributed.rb', line 765

def pipelined
  raise CannotDistribute, :pipelined
end

#psetex(key, ttl, value) ⇒ Object

Set the time to live in milliseconds of a key.



248
249
250
 
# File 'lib/redis/distributed.rb', line 248

def psetex(key, ttl, value)
  node_for(key).psetex(key, ttl, value)
end

#psubscribe(*channels, &block) ⇒ Object

Listen for messages published to channels matching the given patterns.

Raises:

  • (NotImplementedError) 


745
746
747
 
# File 'lib/redis/distributed.rb', line 745

def psubscribe(*channels, &block)
  raise NotImplementedError
end

#pttl(key) ⇒ Object

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



137
138
139
 
# File 'lib/redis/distributed.rb', line 137

def pttl(key)
  node_for(key).pttl(key)
end

#publish(channel, message) ⇒ Object

Post a message to a channel.



717
718
719
 
# File 'lib/redis/distributed.rb', line 717

def publish(channel, message)
  node_for(channel).publish(channel, message)
end

#punsubscribe(*channels) ⇒ Object

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

Raises:

  • (NotImplementedError) 


751
752
753
 
# File 'lib/redis/distributed.rb', line 751

def punsubscribe(*channels)
  raise NotImplementedError
end

#quit ⇒ Object

Close the connection.



57
58
59
 
# File 'lib/redis/distributed.rb', line 57

def quit
  on_each_node :quit
end

#randomkey ⇒ Object

Return a random key from the keyspace.

Raises:



180
181
182
 
# File 'lib/redis/distributed.rb', line 180

def randomkey
  raise CannotDistribute, :randomkey
end

#rename(old_name, new_name) ⇒ Object

Rename a key.



185
186
187
188
189
 
# File 'lib/redis/distributed.rb', line 185

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) ⇒ Object

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



192
193
194
195
196
 
# File 'lib/redis/distributed.rb', line 192

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) ⇒ Object

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



147
148
149
 
# File 'lib/redis/distributed.rb', line 147

def restore(key, ttl, serialized_value)
  node_for(key).restore(key, ttl, serialized_value)
end

#rpop(key) ⇒ Object

Remove and get the last element in a list.



380
381
382
 
# File 'lib/redis/distributed.rb', line 380

def rpop(key)
  node_for(key).rpop(key)
end

#rpoplpush(source, destination) ⇒ Object

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



386
387
388
389
390
 
# File 'lib/redis/distributed.rb', line 386

def rpoplpush(source, destination)
  ensure_same_node(:rpoplpush, [source, destination]) do |node|
    node.rpoplpush(source, destination)
  end
end

#rpush(key, value) ⇒ Object

Append one or more values to a list.



365
366
367
 
# File 'lib/redis/distributed.rb', line 365

def rpush(key, value)
  node_for(key).rpush(key, value)
end

#rpushx(key, value) ⇒ Object

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



370
371
372
 
# File 'lib/redis/distributed.rb', line 370

def rpushx(key, value)
  node_for(key).rpushx(key, value)
end

#sadd(key, member) ⇒ Object

Add one or more members to a set.



476
477
478
 
# File 'lib/redis/distributed.rb', line 476

def sadd(key, member)
  node_for(key).sadd(key, member)
end

#save ⇒ Object

Synchronously save the dataset to disk.



97
98
99
 
# File 'lib/redis/distributed.rb', line 97

def save
  on_each_node :save
end

#scard(key) ⇒ Object

Get the number of members in a set.



471
472
473
 
# File 'lib/redis/distributed.rb', line 471

def scard(key)
  node_for(key).scard(key)
end

#script(subcommand, *args) ⇒ Object

Control remote script registry.



785
786
787
 
# File 'lib/redis/distributed.rb', line 785

def script(subcommand, *args)
  on_each_node(:script, subcommand, *args)
end

#sdiff(*keys) ⇒ Object

Subtract multiple sets.



513
514
515
516
517
 
# File 'lib/redis/distributed.rb', line 513

def sdiff(*keys)
  ensure_same_node(:sdiff, keys) do |node|
    node.sdiff(*keys)
  end
end

#sdiffstore(destination, *keys) ⇒ Object

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



520
521
522
523
524
 
# File 'lib/redis/distributed.rb', line 520

def sdiffstore(destination, *keys)
  ensure_same_node(:sdiffstore, [destination] + keys) do |node|
    node.sdiffstore(destination, *keys)
  end
end

#select(db) ⇒ Object

Change the selected database for the current connection.



42
43
44
 
# File 'lib/redis/distributed.rb', line 42

def select(db)
  on_each_node :select, db
end

#set(key, value, options = {}) ⇒ Object

Set the string value of a key.



238
239
240
 
# File 'lib/redis/distributed.rb', line 238

def set(key, value, options = {})
  node_for(key).set(key, value, options)
end

#setbit(key, offset, value) ⇒ Object

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



300
301
302
 
# File 'lib/redis/distributed.rb', line 300

def setbit(key, offset, value)
  node_for(key).setbit(key, offset, value)
end

#setex(key, ttl, value) ⇒ Object

Set the time to live in seconds of a key.



243
244
245
 
# File 'lib/redis/distributed.rb', line 243

def setex(key, ttl, value)
  node_for(key).setex(key, ttl, value)
end

#setnx(key, value) ⇒ Object

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



253
254
255
 
# File 'lib/redis/distributed.rb', line 253

def setnx(key, value)
  node_for(key).setnx(key, value)
end

#setrange(key, offset, value) ⇒ Object

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



290
291
292
 
# File 'lib/redis/distributed.rb', line 290

def setrange(key, offset, value)
  node_for(key).setrange(key, offset, value)
end

#sinter(*keys) ⇒ Object

Intersect multiple sets.



527
528
529
530
531
 
# File 'lib/redis/distributed.rb', line 527

def sinter(*keys)
  ensure_same_node(:sinter, keys) do |node|
    node.sinter(*keys)
  end
end

#sinterstore(destination, *keys) ⇒ Object

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



534
535
536
537
538
 
# File 'lib/redis/distributed.rb', line 534

def sinterstore(destination, *keys)
  ensure_same_node(:sinterstore, [destination] + keys) do |node|
    node.sinterstore(destination, *keys)
  end
end

#sismember(key, member) ⇒ Object

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



503
504
505
 
# File 'lib/redis/distributed.rb', line 503

def sismember(key, member)
  node_for(key).sismember(key, member)
end

#smembers(key) ⇒ Object

Get all the members in a set.



508
509
510
 
# File 'lib/redis/distributed.rb', line 508

def smembers(key)
  node_for(key).smembers(key)
end

#smove(source, destination, member) ⇒ Object

Move a member from one set to another.



496
497
498
499
500
 
# File 'lib/redis/distributed.rb', line 496

def smove(source, destination, member)
  ensure_same_node(:smove, [source, destination]) do |node|
    node.smove(source, destination, member)
  end
end

#sort(key, options = {}) ⇒ Object

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



199
200
201
202
203
204
205
 
# File 'lib/redis/distributed.rb', line 199

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) ⇒ Object

Remove and return a random member from a set.



486
487
488
 
# File 'lib/redis/distributed.rb', line 486

def spop(key)
  node_for(key).spop(key)
end

#srandmember(key, count = nil) ⇒ Object

Get a random member from a set.



491
492
493
 
# File 'lib/redis/distributed.rb', line 491

def srandmember(key, count = nil)
  node_for(key).srandmember(key, count)
end

#srem(key, member) ⇒ Object

Remove one or more members from a set.



481
482
483
 
# File 'lib/redis/distributed.rb', line 481

def srem(key, member)
  node_for(key).srem(key, member)
end

#strlen(key) ⇒ Object

Get the length of the value stored in a key.



337
338
339
 
# File 'lib/redis/distributed.rb', line 337

def strlen(key)
  node_for(key).strlen(key)
end

#subscribe(channel, *channels, &block) ⇒ Object

Listen for messages published to the given channels.



726
727
728
729
730
731
732
733
734
735
736
 
# File 'lib/redis/distributed.rb', line 726

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? ⇒ Boolean

Returns:

  • (Boolean) 


721
722
723
 
# File 'lib/redis/distributed.rb', line 721

def subscribed?
  !! @subscribed_node
end

#sunion(*keys) ⇒ Object

Add multiple sets.



541
542
543
544
545
 
# File 'lib/redis/distributed.rb', line 541

def sunion(*keys)
  ensure_same_node(:sunion, keys) do |node|
    node.sunion(*keys)
  end
end

#sunionstore(destination, *keys) ⇒ Object

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



548
549
550
551
552
 
# File 'lib/redis/distributed.rb', line 548

def sunionstore(destination, *keys)
  ensure_same_node(:sunionstore, [destination] + keys) do |node|
    node.sunionstore(destination, *keys)
  end
end

#time ⇒ Object

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



102
103
104
 
# File 'lib/redis/distributed.rb', line 102

def time
  on_each_node :time
end

#ttl(key) ⇒ Object

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



122
123
124
 
# File 'lib/redis/distributed.rb', line 122

def ttl(key)
  node_for(key).ttl(key)
end

#type(key) ⇒ Object

Determine the type stored at key.



208
209
210
 
# File 'lib/redis/distributed.rb', line 208

def type(key)
  node_for(key).type(key)
end

#unsubscribe(*channels) ⇒ Object

Stop listening for messages posted to the given channels.

Raises:

  • (RuntimeError) 


739
740
741
742
 
# File 'lib/redis/distributed.rb', line 739

def unsubscribe(*channels)
  raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
  @subscribed_node.unsubscribe(*channels)
end

#unwatch ⇒ Object

Forget about all watched keys.

Raises:



761
762
763
 
# File 'lib/redis/distributed.rb', line 761

def unwatch
  raise CannotDistribute, :unwatch
end

#watch(*keys) ⇒ Object

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

Raises:



756
757
758
 
# File 'lib/redis/distributed.rb', line 756

def watch(*keys)
  raise CannotDistribute, :watch
end

#zadd(key, *args) ⇒ Object

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



561
562
563
 
# File 'lib/redis/distributed.rb', line 561

def zadd(key, *args)
  node_for(key).zadd(key, *args)
end

#zcard(key) ⇒ Object

Get the number of members in a sorted set.



555
556
557
 
# File 'lib/redis/distributed.rb', line 555

def zcard(key)
  node_for(key).zcard(key)
end

#zcount(key, min, max) ⇒ Object

Get the number of members in a particular score range.



624
625
626
 
# File 'lib/redis/distributed.rb', line 624

def zcount(key, min, max)
  node_for(key).zcount(key, min, max)
end

#zincrby(key, increment, member) ⇒ Object

Increment the score of a member in a sorted set.



566
567
568
 
# File 'lib/redis/distributed.rb', line 566

def zincrby(key, increment, member)
  node_for(key).zincrby(key, increment, member)
end

#zinterstore(destination, keys, options = {}) ⇒ Object

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



630
631
632
633
634
 
# File 'lib/redis/distributed.rb', line 630

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 = {}) ⇒ Object

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



581
582
583
 
# File 'lib/redis/distributed.rb', line 581

def zrange(key, start, stop, options = {})
  node_for(key).zrange(key, start, stop, options)
end

#zrangebyscore(key, min, max, options = {}) ⇒ Object

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



608
609
610
 
# File 'lib/redis/distributed.rb', line 608

def zrangebyscore(key, min, max, options = {})
  node_for(key).zrangebyscore(key, min, max, options)
end

#zrank(key, member) ⇒ Object

Determine the index of a member in a sorted set.



592
593
594
 
# File 'lib/redis/distributed.rb', line 592

def zrank(key, member)
  node_for(key).zrank(key, member)
end

#zrem(key, member) ⇒ Object

Remove one or more members from a sorted set.



571
572
573
 
# File 'lib/redis/distributed.rb', line 571

def zrem(key, member)
  node_for(key).zrem(key, member)
end

#zremrangebyrank(key, start, stop) ⇒ Object

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



603
604
605
 
# File 'lib/redis/distributed.rb', line 603

def zremrangebyrank(key, start, stop)
  node_for(key).zremrangebyrank(key, start, stop)
end

#zremrangebyscore(key, min, max) ⇒ Object

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



619
620
621
 
# File 'lib/redis/distributed.rb', line 619

def zremrangebyscore(key, min, max)
  node_for(key).zremrangebyscore(key, min, max)
end

#zrevrange(key, start, stop, options = {}) ⇒ Object

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



587
588
589
 
# File 'lib/redis/distributed.rb', line 587

def zrevrange(key, start, stop, options = {})
  node_for(key).zrevrange(key, start, stop, options)
end

#zrevrangebyscore(key, max, min, options = {}) ⇒ Object

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



614
615
616
 
# File 'lib/redis/distributed.rb', line 614

def zrevrangebyscore(key, max, min, options = {})
  node_for(key).zrevrangebyscore(key, max, min, options)
end

#zrevrank(key, member) ⇒ Object

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



598
599
600
 
# File 'lib/redis/distributed.rb', line 598

def zrevrank(key, member)
  node_for(key).zrevrank(key, member)
end

#zscore(key, member) ⇒ Object

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



576
577
578
 
# File 'lib/redis/distributed.rb', line 576

def zscore(key, member)
  node_for(key).zscore(key, member)
end

#zunionstore(destination, keys, options = {}) ⇒ Object

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



637
638
639
640
641
 
# File 'lib/redis/distributed.rb', line 637

def zunionstore(destination, keys, options = {})
  ensure_same_node(:zunionstore, [destination] + keys) do |node|
    node.zunionstore(destination, keys, options)
  end
end