Class: RedisImpersonator

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

Constant Summary collapse

SET = 
'set'
LIST = 
'list'

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.swallow(method, return_value = nil) ⇒ Object 



5
6
7
8
9
10
 
# File 'lib/redis_impersonator.rb', line 5

def self.swallow(method, return_value = nil)
  define_method(method) do |*args|
    LOGGER.write("RedisImpersonator: Swallowed #{method} with the following arguments #{args.inspect}") if defined?(LOGGER)
    return_value
  end
end

Instance Method Details

#decrby(key, value) ⇒ Object 



61
62
63
64
65
66
 
# File 'lib/redis_impersonator.rb', line 61

def decrby(key, value)
  object = ResqueValue.find_or_initialize_by_key(key.to_s)
  object.value = (object.value.to_i - value.to_i).to_s
  object.save!
  object.value
end

#del(key) ⇒ Object 



45
46
47
48
 
# File 'lib/redis_impersonator.rb', line 45

def del(key)
  ResqueValue.delete_all(:key => key.to_s)
  nil
end

#exists(key) ⇒ Object 



50
51
52
 
# File 'lib/redis_impersonator.rb', line 50

def exists(key)
  ResqueValue.exists?(:key => key.to_s)
end

#get(key) ⇒ Object 



40
41
42
43
 
# File 'lib/redis_impersonator.rb', line 40

def get(key)
  resque_value = ResqueValue.first(:conditions => {:key => key})
  resque_value.value if resque_value
end

#incrby(key, value) ⇒ Object 



54
55
56
57
58
59
 
# File 'lib/redis_impersonator.rb', line 54

def incrby(key, value)
  object = ResqueValue.find_or_initialize_by_key(key.to_s)
  object.value = (object.value.to_i + value.to_i).to_s
  object.save!
  object.value    
end

#keys(pattern = '*') ⇒ Object 



114
115
116
117
 
# File 'lib/redis_impersonator.rb', line 114

def keys(pattern = '*')
  raise "Pattern '#{pattern}' not supported" if pattern != '*'
  ResqueValue.all(:select => 'DISTINCT resque_values.key').map(&:key)
end

#llen(list_name) ⇒ Object 



78
79
80
 
# File 'lib/redis_impersonator.rb', line 78

def llen(list_name)
  ResqueValue.all(:conditions => {:key => list_name.to_s, :key_type=> LIST }).size
end

#lpop(list_name) ⇒ Object 



100
101
102
103
104
105
106
107
108
 
# File 'lib/redis_impersonator.rb', line 100

def lpop(list_name)
  ResqueValue.transaction do
    last = ResqueValue.last(:conditions => {:key => list_name.to_s, :key_type => LIST}, :lock => true)
    if last
      last.destroy
      return last.value
    end
  end
end

#lrange(list_name, start_range, end_range) ⇒ Object 



86
87
88
89
90
91
92
93
 
# File 'lib/redis_impersonator.rb', line 86

def lrange(list_name, start_range, end_range)
  options = { :conditions => {
                :key => list_name.to_s,
                :key_type=> LIST}}
  options.merge!(:limit => end_range, :offset => start_range) unless end_range < 0
  values = ResqueValue.all(options)
  values.map(&:value)
end

#lrem(list_name, count, value) ⇒ Object 



95
96
97
98
 
# File 'lib/redis_impersonator.rb', line 95

def lrem(list_name, count, value)
  raise "Only supports count of 0 which means to remove all elements in list" if count != 0
  ResqueValue.delete_all(:key => list_name.to_s, :key_type=> LIST, :value => value )
end

#lset(list_name, index, value) ⇒ Object 



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

def lset(list_name, index, value)
  rpush(list_name, value)
end

#mapped_mget(*keys) ⇒ Object 



68
69
70
 
# File 'lib/redis_impersonator.rb', line 68

def mapped_mget(*keys)
  Hash[*keys.zip(mget(*keys)).flatten]
end

#mget(*keys) ⇒ Object 



72
73
74
75
76
 
# File 'lib/redis_impersonator.rb', line 72

def mget(*keys)
  keys.collect!{|key| key.to_s }
  resque_values = ResqueValue.all(:conditions => {:key => keys})
  resque_values.map(&:value)    
end

#rpush(list_name, value) ⇒ Object 



110
111
112
 
# File 'lib/redis_impersonator.rb', line 110

def rpush(list_name, value)
  ResqueValue.create!(:key => list_name.to_s, :key_type => LIST, :value => value.to_s)
end

#sadd(set_name, value) ⇒ Object 



29
30
31
 
# File 'lib/redis_impersonator.rb', line 29

def sadd(set_name, value)
  sismember(set_name, value) || ResqueValue.create!(:key => set_name.to_s, :key_type => SET, :value => value.to_s)
end

#set(key, value) ⇒ Object 



33
34
35
36
37
38
 
# File 'lib/redis_impersonator.rb', line 33

def set(key, value)
  resque_value = ResqueValue.find_or_initialize_by_key(key.to_s)
  resque_value.value = value
  resque_value.save!
  value
end

#sismember(set_name, value) ⇒ Object 



25
26
27
 
# File 'lib/redis_impersonator.rb', line 25

def sismember(set_name, value)
  ResqueValue.exists?(:key => set_name.to_s, :key_type => SET, :value => value.to_s)
end

#smembers(set_name) ⇒ Object 



21
22
23
 
# File 'lib/redis_impersonator.rb', line 21

def smembers(set_name)
  ResqueValue.all(:conditions => {:key => set_name.to_s, :key_type => SET}).map(&:value)
end

#srem(set_name, value) ⇒ Object 



16
17
18
19
 
# File 'lib/redis_impersonator.rb', line 16

def srem(set_name, value)
  ResqueValue.delete_all(:key => set_name.to_s, :key_type => SET, :value => value.to_s)
  nil
end