Class: Redis

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

Direct Known Subclasses

Pipeline

Defined Under Namespace

Classes: Pipeline

Constant Summary collapse

ERR = 
"-".freeze
OK = 
'OK'.freeze
SINGLE = 
'+'.freeze
BULK = 
'$'.freeze
MULTI = 
'*'.freeze
INT = 
':'.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Redis

Returns a new instance of Redis.



22
23
24
25
26
27
 
# File 'lib/redis.rb', line 22

def initialize(opts={})
  @opts = {:host => 'localhost', :port => '6379', :db => 0}.merge(opts)
  $debug = @opts[:debug]
  @db = @opts[:db]
  @server = Server.new(@opts[:host], @opts[:port], (@opts[:timeout]||10))
end

Instance Attribute Details

#server ⇒ Object (readonly)

Returns the value of attribute server.



19
20
21
 
# File 'lib/redis.rb', line 19

def server
  @server
end

Instance Method Details

#[](key) ⇒ Object 



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

def [](key)
  get(key)
end

#[]=(key, val) ⇒ Object 



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

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

#bgsave ⇒ Object 



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

def bgsave
  write "BGSAVE\r\n"
  get_response == OK
end

#bulk_reply ⇒ Object 



124
125
126
127
128
129
130
131
132
133
 
# File 'lib/redis.rb', line 124

def bulk_reply
  begin
    x = read
    puts "bulk_reply read value is #{x.inspect}" if $debug
    return x
  rescue => e
    puts "error in bulk_reply #{e}" if $debug
    nil
  end
end

#decr(key, decrement = nil) ⇒ Object 



216
217
218
219
220
221
222
223
 
# File 'lib/redis.rb', line 216

def decr(key, decrement=nil)
  if decrement
    write "DECRBY #{key} #{decrement}\r\n"
  else
    write "DECR #{key}\r\n"
  end    
  get_response
end

#delete(key) ⇒ Object 



188
189
190
191
 
# File 'lib/redis.rb', line 188

def delete(key)
  write "DEL #{key}\r\n"
  get_response == 1
end

#expire(key, expiry = nil) ⇒ Object 



427
428
429
430
 
# File 'lib/redis.rb', line 427

def expire(key, expiry=nil)
  write("EXPIRE #{key} #{expiry}\r\n")
  get_response == 1
end

#fetch(len) ⇒ Object 



142
143
144
145
146
147
148
149
 
# File 'lib/redis.rb', line 142

def fetch(len)
  with_socket_management(@server) do |socket|
    len = [0, len.to_i].max
    res = socket.read(len + 2)
    res = res.chomp if res
    res
  end
end

#flush_all ⇒ Object 



91
92
93
94
95
96
97
98
99
 
# File 'lib/redis.rb', line 91

def flush_all
  ensure_retry do
    puts "Warning!\nFlushing *ALL* databases!\n5 Seconds to Hit ^C!"
    trap('INT') {quit; return false}
    sleep 5
    write "FLUSHALL\r\n"
    get_response == OK
  end
end

#flush_db ⇒ Object 



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

def flush_db
  write "FLUSHDB\r\n"
  get_response == OK
end

#get(key) ⇒ Object 



197
198
199
200
 
# File 'lib/redis.rb', line 197

def get(key)
  write "GET #{key}\r\n"
  get_response
end

#get_reply ⇒ Object 



405
406
407
408
409
410
411
412
413
 
# File 'lib/redis.rb', line 405

def get_reply
  begin
    r = read(1)
    raise RedisError if (r == "\r" || r == "\n")
  rescue RedisError
    retry
  end
  r
end

#get_response ⇒ Object 



450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
 
# File 'lib/redis.rb', line 450

def get_response
  begin
    rtype = get_reply
  rescue => e
    raise RedisError, e.inspect
  end
  puts "reply_type is #{rtype.inspect}" if $debug
  case rtype
  when SINGLE
    single_line
  when BULK
    bulk_reply
  when MULTI
    multi_bulk
  when INT
    integer_reply
  when ERR
    raise RedisError, single_line
  else
    raise RedisError, "Unknown response.."
  end
end

#host ⇒ Object 



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

def host
  @opts[:host]
end

#incr(key, increment = nil) ⇒ Object 



207
208
209
210
211
212
213
214
 
# File 'lib/redis.rb', line 207

def incr(key, increment=nil)
  if increment
    write "INCRBY #{key} #{increment}\r\n"
  else
    write "INCR #{key}\r\n"
  end    
  get_response
end

#info ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/redis.rb', line 111

def info
 info = {}
 write("INFO\r\n")
 x = get_response
 x.each do |kv|
   k,v = kv.split(':', 2)
   k,v = k.chomp, v = v.chomp
   info[k.to_sym] = v
 end
 info
end

#integer_reply ⇒ Object 



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

def integer_reply
  Integer(read_proto)
end

#key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


183
184
185
186
 
# File 'lib/redis.rb', line 183

def key?(key)
  write "EXISTS #{key}\r\n"
  get_response == 1
end

#keys(glob) ⇒ Object 



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

def keys(glob)
  write "KEYS #{glob}\r\n"
  get_response.split(' ')
end

#last_save ⇒ Object 



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

def last_save
  write "LASTSAVE\r\n"
  get_response.to_i
end

#list_index(key, index) ⇒ Object 



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

def list_index(key, index)
  write "LINDEX #{key} #{index}\r\n"
  get_response
end

#list_length(key) ⇒ Object 



230
231
232
233
234
235
236
237
238
 
# File 'lib/redis.rb', line 230

def list_length(key)
  write "LLEN #{key}\r\n"
  case i = get_response
  when -2
    raise RedisError, "key: #{key} does not hold a list value"
  else
    i
  end
end

#list_range(key, start, ending) ⇒ Object 



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

def list_range(key, start, ending)
  write "LRANGE #{key} #{start} #{ending}\r\n"
  get_response
end

#list_rm(key, count, value) ⇒ Object 



285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/redis.rb', line 285

def list_rm(key, count, value)
  write "LREM #{key} #{count} #{value.to_s.size}\r\n#{value}\r\n"
  case num = get_response
  when -1
    raise RedisError, "key: #{key} does not exist"
  when -2
    raise RedisError, "key: #{key} does not hold a list value"
  else
    num
  end
end

#list_set(key, index, val) ⇒ Object 



265
266
267
268
 
# File 'lib/redis.rb', line 265

def list_set(key, index, val)
  write "LSET #{key} #{index} #{val.to_s.size}\r\n#{val}\r\n"
  get_response == OK
end

#list_trim(key, start, ending) ⇒ Object 



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

def list_trim(key, start, ending)
  write "LTRIM #{key} #{start} #{ending}\r\n"
  get_response
end

#mget(*keys) ⇒ Object 



202
203
204
205
 
# File 'lib/redis.rb', line 202

def mget(*keys)
  write "MGET #{keys.join(' ')}\r\n"
  get_response
end

#monitor ⇒ Object 



63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/redis.rb', line 63

def monitor
  with_socket_management(@server) do |socket|
    trap("INT") { puts "\nGot ^C! Dying!"; exit }
    write "MONITOR\r\n"
    puts "Now Monitoring..."
    socket.read(12)
    loop do
      x = socket.gets
      puts x unless x.nil?
    end
  end
end

#multi_bulk ⇒ Object 



392
393
394
395
396
397
398
399
400
401
402
403
 
# File 'lib/redis.rb', line 392

def multi_bulk
  res = read_proto
  puts "mb res is #{res.inspect}" if $debug
  list = []
  Integer(res).times do
    vf = get_response
    puts "curren vf is #{vf.inspect}" if $debug
    list << vf
    puts "current list is #{list.inspect}" if $debug
  end
  list
end

#pipelined {|pipeline| ... } ⇒ Object

Yields:

  • (pipeline) 


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

def pipelined
  pipeline = Pipeline.new(self)
  yield pipeline
  pipeline.finish
end

#pop_head(key) ⇒ Object 



255
256
257
258
 
# File 'lib/redis.rb', line 255

def pop_head(key)
  write "LPOP #{key}\r\n"
  get_response
end

#pop_tail(key) ⇒ Object 



260
261
262
263
 
# File 'lib/redis.rb', line 260

def pop_tail(key)
  write "RPOP #{key}\r\n"
  get_response
end

#port ⇒ Object 



39
40
41
 
# File 'lib/redis.rb', line 39

def port
  @opts[:port]
end

#push_head(key, string) ⇒ Object 



250
251
252
253
 
# File 'lib/redis.rb', line 250

def push_head(key, string)
  write "LPUSH #{key} #{string.to_s.size}\r\n#{string.to_s}\r\n"
  get_response
end

#push_tail(key, string) ⇒ Object 



245
246
247
248
 
# File 'lib/redis.rb', line 245

def push_tail(key, string)
  write "RPUSH #{key} #{string.to_s.size}\r\n#{string.to_s}\r\n"
  get_response
end

#quit ⇒ Object 



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

def quit
  write "QUIT\r\n"
end

#randkey ⇒ Object 



225
226
227
228
 
# File 'lib/redis.rb', line 225

def randkey
  write "RANDOMKEY\r\n"
  get_response
end

#read(length = read_proto) ⇒ Object 



151
152
153
154
155
156
157
 
# File 'lib/redis.rb', line 151

def read(length = read_proto)
  with_socket_management(@server) do |socket|
    res = socket.read(length)
    puts "read is #{res.inspect}" if $debug
    res
  end
end

#read_proto ⇒ Object 



494
495
496
497
498
499
500
501
502
 
# File 'lib/redis.rb', line 494

def read_proto
  with_socket_management(@server) do |socket|
    if res = socket.gets
      x = res.chomp
      puts "read_proto is #{x.inspect}\n\n" if $debug
      x.to_i
    end
  end
end

#read_socket ⇒ Object 



486
487
488
489
490
491
492
 
# File 'lib/redis.rb', line 486

def read_socket
  with_socket_management(@server) do |socket|
    while res = socket.read(8096)
      break if res.size != 8096
    end
  end
end

#rename(oldkey, newkey) ⇒ Object 



169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/redis.rb', line 169

def rename(oldkey, newkey)
  write "RENAMENX #{oldkey} #{newkey}\r\n"
  case get_response
  when -1
    raise RedisRenameError, "source key: #{oldkey} does not exist"
  when 0
    raise RedisRenameError, "target key: #{oldkey} already exists"
  when -3
    raise RedisRenameError, "source and destination keys are the same"
  when 1
    true
  end
end

#rename!(oldkey, newkey) ⇒ Object 



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

def rename!(oldkey, newkey)
  write "RENAME #{oldkey} #{newkey}\r\n"
  get_response
end

#select_db(index) ⇒ Object 



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

def select_db(index)
  @db = index
  write "SELECT #{index}\r\n"
  get_response
end

#set(key, val, expiry = nil) ⇒ Object 



420
421
422
423
424
425
 
# File 'lib/redis.rb', line 420

def set(key, val, expiry=nil)
  write("SET #{key} #{val.to_s.size}\r\n#{val}\r\n")
  s = get_response == OK
  return expire(key, expiry) if s && expiry
  s
end

#set_add(key, member) ⇒ Object 



297
298
299
300
301
302
303
304
305
306
307
 
# File 'lib/redis.rb', line 297

def set_add(key, member)
  write "SADD #{key} #{member.to_s.size}\r\n#{member}\r\n"
  case get_response
  when 1
    true
  when 0
    false
  when -2
    raise RedisError, "key: #{key} contains a non set value"
  end
end

#set_count(key) ⇒ Object 



321
322
323
324
325
326
327
328
329
 
# File 'lib/redis.rb', line 321

def set_count(key)
  write "SCARD #{key}\r\n"
  case i = get_response
  when -2
    raise RedisError, "key: #{key} contains a non set value"
  else
    i
  end
end

#set_delete(key, member) ⇒ Object 



309
310
311
312
313
314
315
316
317
318
319
 
# File 'lib/redis.rb', line 309

def set_delete(key, member)
  write "SREM #{key} #{member.to_s.size}\r\n#{member}\r\n"
  case get_response
  when 1
    true
  when 0
    false
  when -2
    raise RedisError, "key: #{key} contains a non set value"
  end
end

#set_diff(*keys) ⇒ Object 



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

def set_diff(*keys)
  write "SDIFF #{keys.join(' ')}\r\n"
  Set.new(get_response)
end

#set_diff_store(destkey, *keys) ⇒ Object 



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

def set_diff_store(destkey, *keys)
  write "SDIFFSTORE #{destkey} #{keys.join(' ')}\r\n"
  get_response
end

#set_inter_store(destkey, *keys) ⇒ Object 



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

def set_inter_store(destkey, *keys)
  write "SINTERSTORE #{destkey} #{keys.join(' ')}\r\n"
  get_response
end

#set_intersect(*keys) ⇒ Object 



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

def set_intersect(*keys)
  write "SINTER #{keys.join(' ')}\r\n"
  Set.new(get_response)
end

#set_member?(key, member) ⇒ Boolean

Returns:

  • (Boolean) 


331
332
333
334
335
336
337
338
339
340
341
 
# File 'lib/redis.rb', line 331

def set_member?(key, member)
  write "SISMEMBER #{key} #{member.to_s.size}\r\n#{member}\r\n"
  case get_response
  when 1
    true
  when 0
    false
  when -2
    raise RedisError, "key: #{key} contains a non set value"
  end
end

#set_members(key) ⇒ Object 



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

def set_members(key)
  write "SMEMBERS #{key}\r\n"
  Set.new(get_response)
end

#set_union(*keys) ⇒ Object 



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

def set_union(*keys)
  write "SUNION #{keys.join(' ')}\r\n"
  Set.new(get_response)
end

#set_union_store(destkey, *keys) ⇒ Object 



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

def set_union_store(destkey, *keys)
  write "SUNIONSTORE #{destkey} #{keys.join(' ')}\r\n"
  get_response
end

#set_unless_exists(key, val) ⇒ Object 



432
433
434
435
 
# File 'lib/redis.rb', line 432

def set_unless_exists(key, val)
  write "SETNX #{key} #{val.to_s.size}\r\n#{val}\r\n"
  get_response == 1
end

#single_line ⇒ Object 



477
478
479
480
481
482
483
484
 
# File 'lib/redis.rb', line 477

def single_line
  buff = ""
  while buff[-2..-1] != "\r\n"
    buff << read(1)
  end
  puts "single_line value is #{buff[0..-3].inspect}" if $debug
  buff[0..-3]
end

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



378
379
380
381
382
383
384
385
386
387
388
389
390
 
# File 'lib/redis.rb', line 378

def sort(key, opts={})
  cmd = "SORT #{key}"
  cmd << " BY #{opts[:by]}" if opts[:by]
  cmd << " GET #{opts[:get]}" if opts[:get]
  cmd << " INCR #{opts[:incr]}" if opts[:incr]
  cmd << " DEL #{opts[:del]}" if opts[:del]
  cmd << " DECR #{opts[:decr]}" if opts[:decr]
  cmd << " #{opts[:order]}" if opts[:order]
  cmd << " LIMIT #{opts[:limit].join(' ')}" if opts[:limit]
  cmd << "\r\n"
  write(cmd)
  get_response
end

#status_code_reply ⇒ Object 



437
438
439
440
441
442
443
444
445
446
447
448
 
# File 'lib/redis.rb', line 437

def status_code_reply
  begin
    res = read_proto  
    if res.index('-') == 0          
      raise RedisError, res
    else          
      true
    end
  rescue RedisError
     raise RedisError
  end
end

#to_s ⇒ Object 



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

def to_s
  "#{host}:#{port}"
end

#type?(key) ⇒ Boolean

Returns:

  • (Boolean) 


240
241
242
243
 
# File 'lib/redis.rb', line 240

def type?(key)
  write "TYPE #{key}\r\n"
  get_response
end

#with_socket_management(server, &block) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/redis.rb', line 47

def with_socket_management(server, &block)
  begin
    block.call(server.socket)
  #Timeout or server down
  rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNREFUSED => e
    server.close
    puts "Client (#{server.inspect}) disconnected from server: #{e.inspect}\n" if $debug
    retry
  #Server down
  rescue NoMethodError => e
    puts "Client (#{server.inspect}) tryin server that is down: #{e.inspect}\n Dying!" if $debug
    raise Errno::ECONNREFUSED
    #exit
  end
end

#write(data) ⇒ Object 



135
136
137
138
139
140
 
# File 'lib/redis.rb', line 135

def write(data)
  with_socket_management(@server) do |socket|
    puts "writing: #{data}" if $debug
    socket.write(data)
  end
end