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 



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

def [](key)
  get(key)
end

#[]=(key, value) ⇒ Object 



348
349
350
 
# File 'lib/redis/distributed.rb', line 348

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

#_bpop(cmd, args) ⇒ Object 



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

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 



822
823
824
825
826
827
828
829
830
831
832
833
 
# File 'lib/redis/distributed.rb', line 822

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.



313
314
315
 
# File 'lib/redis/distributed.rb', line 313

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.



318
319
320
 
# File 'lib/redis/distributed.rb', line 318

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.



323
324
325
326
327
 
# File 'lib/redis/distributed.rb', line 323

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.



330
331
332
 
# File 'lib/redis/distributed.rb', line 330

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.



419
420
421
 
# File 'lib/redis/distributed.rb', line 419

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.



425
426
427
 
# File 'lib/redis/distributed.rb', line 425

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.



431
432
433
434
435
436
437
438
439
440
441
 
# File 'lib/redis/distributed.rb', line 431

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:



793
794
795
 
# File 'lib/redis/distributed.rb', line 793

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 



849
850
851
 
# File 'lib/redis/distributed.rb', line 849

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.



836
837
838
 
# File 'lib/redis/distributed.rb', line 836

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

#evalsha(*args) ⇒ Object

Evaluate Lua script by its SHA.



841
842
843
 
# File 'lib/redis/distributed.rb', line 841

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

#exec ⇒ Object

Execute all commands issued after MULTI.

Raises:



788
789
790
 
# File 'lib/redis/distributed.rb', line 788

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.



308
309
310
 
# File 'lib/redis/distributed.rb', line 308

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.



298
299
300
 
# File 'lib/redis/distributed.rb', line 298

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.



335
336
337
 
# File 'lib/redis/distributed.rb', line 335

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

#hdel(key, field) ⇒ Object

Delete one or more hash fields.



695
696
697
 
# File 'lib/redis/distributed.rb', line 695

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

#hexists(key, field) ⇒ Object

Determine if a hash field exists.



700
701
702
 
# File 'lib/redis/distributed.rb', line 700

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

#hget(key, field) ⇒ Object

Get the value of a hash field.



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

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

#hgetall(key) ⇒ Object

Get all the fields and values in a hash.



725
726
727
 
# File 'lib/redis/distributed.rb', line 725

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.



705
706
707
 
# File 'lib/redis/distributed.rb', line 705

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.



710
711
712
 
# File 'lib/redis/distributed.rb', line 710

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

#hkeys(key) ⇒ Object

Get all the fields in a hash.



715
716
717
 
# File 'lib/redis/distributed.rb', line 715

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

#hlen(key) ⇒ Object

Get the number of fields in a hash.



657
658
659
 
# File 'lib/redis/distributed.rb', line 657

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

#hmget(key, *fields) ⇒ Object

Get the values of all the given hash fields.



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

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

#hmset(key, *attrs) ⇒ Object

Set multiple hash fields to multiple values.



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

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

#hset(key, field, value) ⇒ Object

Set the string value of a hash field.



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

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.



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

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

#hvals(key) ⇒ Object

Get all the values in a hash.



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

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 



845
846
847
 
# File 'lib/redis/distributed.rb', line 845

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.



444
445
446
 
# File 'lib/redis/distributed.rb', line 444

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.



449
450
451
 
# File 'lib/redis/distributed.rb', line 449

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

#llen(key) ⇒ Object

Get the length of a list.



353
354
355
 
# File 'lib/redis/distributed.rb', line 353

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

#lpop(key) ⇒ Object

Remove and get the first element in a list.



378
379
380
 
# File 'lib/redis/distributed.rb', line 378

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

#lpush(key, value) ⇒ Object

Prepend one or more values to a list.



358
359
360
 
# File 'lib/redis/distributed.rb', line 358

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.



363
364
365
 
# File 'lib/redis/distributed.rb', line 363

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

#lrange(key, start, stop) ⇒ Object

Get a range of elements from a list.



454
455
456
 
# File 'lib/redis/distributed.rb', line 454

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

#lrem(key, count, value) ⇒ Object

Remove elements from a list.



459
460
461
 
# File 'lib/redis/distributed.rb', line 459

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.



464
465
466
 
# File 'lib/redis/distributed.rb', line 464

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.



469
470
471
 
# File 'lib/redis/distributed.rb', line 469

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

#mapped_hmget(key, *fields) ⇒ Object 



690
691
692
 
# File 'lib/redis/distributed.rb', line 690

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

#mapped_hmset(key, hash) ⇒ Object 



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

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

#mapped_mget(*keys) ⇒ Object

Get the values of all the given keys as a Hash.



286
287
288
289
290
 
# File 'lib/redis/distributed.rb', line 286

def mapped_mget(*keys)
  keys.group_by { |k| node_for k }.inject({}) do |results, (node, subkeys)|
    results.merge! node.mapped_mget(*subkeys)
  end
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 as an Array.



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

def mget(*keys)
  mapped_mget(*keys).values_at(*keys)
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:



783
784
785
 
# File 'lib/redis/distributed.rb', line 783

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.



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

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

#pfcount(*keys) ⇒ Object

Get the approximate cardinality of members added to HyperLogLog structure.



808
809
810
811
812
 
# File 'lib/redis/distributed.rb', line 808

def pfcount(*keys)
  ensure_same_node(:pfcount, keys.flatten(1)) do |node|
    node.pfcount(keys)
  end
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.



816
817
818
819
820
 
# File 'lib/redis/distributed.rb', line 816

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:



778
779
780
 
# File 'lib/redis/distributed.rb', line 778

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) 


758
759
760
 
# File 'lib/redis/distributed.rb', line 758

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.



730
731
732
 
# File 'lib/redis/distributed.rb', line 730

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) 


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

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, options = {}) ⇒ 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, options = {})
  node_for(key).restore(key, ttl, serialized_value, options)
end

#rpop(key) ⇒ Object

Remove and get the last element in a list.



383
384
385
 
# File 'lib/redis/distributed.rb', line 383

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.



389
390
391
392
393
 
# File 'lib/redis/distributed.rb', line 389

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.



368
369
370
 
# File 'lib/redis/distributed.rb', line 368

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.



373
374
375
 
# File 'lib/redis/distributed.rb', line 373

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

#sadd(key, member) ⇒ Object

Add one or more members to a set.



479
480
481
 
# File 'lib/redis/distributed.rb', line 479

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.



474
475
476
 
# File 'lib/redis/distributed.rb', line 474

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

#script(subcommand, *args) ⇒ Object

Control remote script registry.



798
799
800
 
# File 'lib/redis/distributed.rb', line 798

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

#sdiff(*keys) ⇒ Object

Subtract multiple sets.



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

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.



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

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.



303
304
305
 
# File 'lib/redis/distributed.rb', line 303

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.



293
294
295
 
# File 'lib/redis/distributed.rb', line 293

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

#sinter(*keys) ⇒ Object

Intersect multiple sets.



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

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.



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

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.



506
507
508
 
# File 'lib/redis/distributed.rb', line 506

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

#smembers(key) ⇒ Object

Get all the members in a set.



511
512
513
 
# File 'lib/redis/distributed.rb', line 511

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

#smove(source, destination, member) ⇒ Object

Move a member from one set to another.



499
500
501
502
503
 
# File 'lib/redis/distributed.rb', line 499

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, count = nil) ⇒ Object

Remove and return a random member from a set.



489
490
491
 
# File 'lib/redis/distributed.rb', line 489

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

#srandmember(key, count = nil) ⇒ Object

Get a random member from a set.



494
495
496
 
# File 'lib/redis/distributed.rb', line 494

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

#srem(key, member) ⇒ Object

Remove one or more members from a set.



484
485
486
 
# File 'lib/redis/distributed.rb', line 484

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

#sscan(key, cursor, options = {}) ⇒ Object

Scan a set



516
517
518
 
# File 'lib/redis/distributed.rb', line 516

def sscan(key, cursor, options={})
  node_for(key).sscan(key, cursor, options)
end

#sscan_each(key, options = {}, &block) ⇒ Object

Scan a set and return an enumerator



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

def sscan_each(key, options={}, &block)
  node_for(key).sscan_each(key, options, &block)
end

#strlen(key) ⇒ Object

Get the length of the value stored in a key.



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

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

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

Listen for messages published to the given channels.



739
740
741
742
743
744
745
746
747
748
749
 
# File 'lib/redis/distributed.rb', line 739

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) 


734
735
736
 
# File 'lib/redis/distributed.rb', line 734

def subscribed?
  !! @subscribed_node
end

#sunion(*keys) ⇒ Object

Add multiple sets.



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

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.



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

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) 


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

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:



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

def unwatch
  raise CannotDistribute, :unwatch
end

#watch(*keys) ⇒ Object

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

Raises:



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

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.



574
575
576
 
# File 'lib/redis/distributed.rb', line 574

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

#zcard(key) ⇒ Object

Get the number of members in a sorted set.



568
569
570
 
# File 'lib/redis/distributed.rb', line 568

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

#zcount(key, min, max) ⇒ Object

Get the number of members in a particular score range.



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

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.



579
580
581
 
# File 'lib/redis/distributed.rb', line 579

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.



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

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.



594
595
596
 
# File 'lib/redis/distributed.rb', line 594

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.



621
622
623
 
# File 'lib/redis/distributed.rb', line 621

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.



605
606
607
 
# File 'lib/redis/distributed.rb', line 605

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

#zrem(key, member) ⇒ Object

Remove one or more members from a sorted set.



584
585
586
 
# File 'lib/redis/distributed.rb', line 584

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.



616
617
618
 
# File 'lib/redis/distributed.rb', line 616

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.



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

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.



600
601
602
 
# File 'lib/redis/distributed.rb', line 600

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.



627
628
629
 
# File 'lib/redis/distributed.rb', line 627

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.



611
612
613
 
# File 'lib/redis/distributed.rb', line 611

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.



589
590
591
 
# File 'lib/redis/distributed.rb', line 589

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.



650
651
652
653
654
 
# File 'lib/redis/distributed.rb', line 650

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