Class: Redis

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

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.



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

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])
end

Instance Attribute Details

#server ⇒ Object (readonly)

Returns the value of attribute server.



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

def server
  @server
end

Instance Method Details

#[](key) ⇒ Object 



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

def [](key)
  get(key)
end

#[]=(key, val) ⇒ Object 



398
399
400
 
# File 'lib/redis.rb', line 398

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

#bgsave ⇒ Object 



99
100
101
102
 
# File 'lib/redis.rb', line 99

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

#bulk_reply ⇒ Object 



117
118
119
120
121
122
123
124
125
126
 
# File 'lib/redis.rb', line 117

def bulk_reply
  begin
    x = read.chomp
    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 



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

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 



181
182
183
184
 
# File 'lib/redis.rb', line 181

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

#expire(key, expiry = nil) ⇒ Object 



410
411
412
413
 
# File 'lib/redis.rb', line 410

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

#fetch(len) ⇒ Object 



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

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 



84
85
86
87
88
89
90
91
92
 
# File 'lib/redis.rb', line 84

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 



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

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

#get(key) ⇒ Object 



190
191
192
193
 
# File 'lib/redis.rb', line 190

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

#get_reply ⇒ Object 



388
389
390
391
392
393
394
395
396
 
# File 'lib/redis.rb', line 388

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

#get_response ⇒ Object 



433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
 
# File 'lib/redis.rb', line 433

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 



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

def host
  @opts[:host]
end

#incr(key, increment = nil) ⇒ Object 



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

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 



104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/redis.rb', line 104

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 



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

def integer_reply
  Integer(read_proto)
end

#key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


176
177
178
179
 
# File 'lib/redis.rb', line 176

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

#keys(glob) ⇒ Object 



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

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

#last_save ⇒ Object 



94
95
96
97
 
# File 'lib/redis.rb', line 94

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

#list_index(key, index) ⇒ Object 



283
284
285
286
 
# File 'lib/redis.rb', line 283

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

#list_length(key) ⇒ Object 



223
224
225
226
227
228
229
230
231
 
# File 'lib/redis.rb', line 223

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 



273
274
275
276
 
# File 'lib/redis.rb', line 273

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

#list_rm(key, count, value) ⇒ Object 



288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/redis.rb', line 288

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 



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

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 



278
279
280
281
 
# File 'lib/redis.rb', line 278

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

#mget(*keys) ⇒ Object 



195
196
197
198
 
# File 'lib/redis.rb', line 195

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

#monitor ⇒ Object 



56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/redis.rb', line 56

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 



375
376
377
378
379
380
381
382
383
384
385
386
 
# File 'lib/redis.rb', line 375

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

#pop_head(key) ⇒ Object 



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

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

#pop_tail(key) ⇒ Object 



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

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

#port ⇒ Object 



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

def port
  @opts[:port]
end

#push_head(key, string) ⇒ Object 



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

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 



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

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

#quit ⇒ Object 



69
70
71
 
# File 'lib/redis.rb', line 69

def quit
  write "QUIT\r\n"
end

#randkey ⇒ Object 



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

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

#read(length = read_proto) ⇒ Object 



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

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 



469
470
471
472
473
474
475
476
477
 
# File 'lib/redis.rb', line 469

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

#rename(oldkey, newkey) ⇒ Object 



162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/redis.rb', line 162

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 



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

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

#select_db(index) ⇒ Object 



73
74
75
76
77
 
# File 'lib/redis.rb', line 73

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

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



403
404
405
406
407
408
 
# File 'lib/redis.rb', line 403

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 



300
301
302
303
304
305
306
307
308
309
310
 
# File 'lib/redis.rb', line 300

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 



324
325
326
327
328
329
330
331
332
 
# File 'lib/redis.rb', line 324

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 



312
313
314
315
316
317
318
319
320
321
322
 
# File 'lib/redis.rb', line 312

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_inter_store(destkey, *keys) ⇒ Object 



356
357
358
359
 
# File 'lib/redis.rb', line 356

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

#set_intersect(*keys) ⇒ Object 



351
352
353
354
 
# File 'lib/redis.rb', line 351

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

#set_member?(key, member) ⇒ Boolean

Returns:

  • (Boolean) 


334
335
336
337
338
339
340
341
342
343
344
 
# File 'lib/redis.rb', line 334

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 



346
347
348
349
 
# File 'lib/redis.rb', line 346

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

#set_unless_exists(key, val) ⇒ Object 



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

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 



460
461
462
463
464
465
466
467
 
# File 'lib/redis.rb', line 460

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 



361
362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'lib/redis.rb', line 361

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 



420
421
422
423
424
425
426
427
428
429
430
431
 
# File 'lib/redis.rb', line 420

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 



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

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

#type?(key) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#with_socket_management(server, &block) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/redis.rb', line 40

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 



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

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