Class: RedisQueue::Simple

Inherits:
RedisCall show all
Defined in:
lib/redis-call/redis_queue.rb

Direct Known Subclasses

Base

Constant Summary

Constants inherited from RedisCall

RedisCall::DEFAULT_HOST, RedisCall::DEFAULT_PORT

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from RedisCall

config=, #connection, #decrzerodelex, #disconnect, #geti, #getnnil, #getnnili, #hgetallarr, #insist, #key, #lgetall, #llen, #method_missing, query, #rpushex

Constructor Details

#initialize(name = nil, args = {}) ⇒ Simple

Returns a new instance of Simple.



52
53
54
55
56
57
58
59
 
# File 'lib/redis-call/redis_queue.rb', line 52

def initialize(name = nil, args = {})
  super(args)
  
  @name = key(name)
  @key = key(:queue)/name

  @config = args[:config] || RedisQueue.config[name] || {}
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class RedisCall

Instance Attribute Details

#config ⇒ Object (readonly)

Returns the value of attribute config.



50
51
52
 
# File 'lib/redis-call/redis_queue.rb', line 50

def config
  @config
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



50
51
52
 
# File 'lib/redis-call/redis_queue.rb', line 50

def name
  @name
end

Class Method Details

.all ⇒ Object 



34
35
36
37
38
39
40
41
 
# File 'lib/redis-call/redis_queue.rb', line 34

def all
  klass = self
  query do
    queued(keys "queue.*") do |result|
      (result.collect {|name| name.gsub /\Aqueue\./, ''} | RedisQueue.config.keys).sort.collect {|name| klass.new name}
    end
  end
end

.delete(*names) ⇒ Object 



43
44
45
46
47
 
# File 'lib/redis-call/redis_queue.rb', line 43

def delete *names
  query do
    del *(names.map{|name| key(:queue)/name})
  end
end

Instance Method Details

#backed_up_blocking_pop(timeout = 0) ⇒ Object

Returns element



102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/redis-call/redis_queue.rb', line 102

def backed_up_blocking_pop timeout = 0
  if raw_element = brpoplpush(@key, @key/:backup, timeout)
    element = decode(raw_element)
    
    if block_given?
      yield(element)
      remove_raw_backup_element raw_element
    else
      return element
    end
  end
end

#backed_up_pop ⇒ Object 



97
98
99
 
# File 'lib/redis-call/redis_queue.rb', line 97

def backed_up_pop
  queued(rpoplpush(@key, @key/:backup)) {|result| decode(result) if result}
end

#backed_up_pop_all ⇒ Object

Raises:



128
129
130
131
132
133
134
135
136
 
# File 'lib/redis-call/redis_queue.rb', line 128

def backed_up_pop_all
  raise(NonTransactionalMethod) if inside_transaction?
  result = []
  # We does not call backed_up_pop here, because of the edge case, when element is a string "null" which JSON-decoded as nil
  while element = rpoplpush(@key, @key/:backup)
    result.push decode(element)
  end
  result
end

#backup_elements ⇒ Object 



150
151
152
 
# File 'lib/redis-call/redis_queue.rb', line 150

def backup_elements
  queued(lgetall(@key/:backup)) {|result| result.map {|element| decode(element)}.reverse }
end

#backup_length ⇒ Object 



196
197
198
 
# File 'lib/redis-call/redis_queue.rb', line 196

def backup_length
  llen(@key/:backup)
end

#blocking_pop(timeout = 0) ⇒ Object

Returns element



91
92
93
94
95
 
# File 'lib/redis-call/redis_queue.rb', line 91

def blocking_pop timeout = 0
  if result = brpop(@key, timeout)
    decode(result.last)
  end
end

#blocking_redirect(to, timeout = 0) ⇒ Object

NOTE: Make sure your redis is 2.2.13 or higher to use this method

https://github.com/antirez/redis/commit/c47d152c8d96415de1af994b1a4bb3e0347caef3
http://code.google.com/p/redis/issues/detail?id=593



170
171
172
 
# File 'lib/redis-call/redis_queue.rb', line 170

def blocking_redirect to, timeout = 0
  brpoplpush(@key, key(:queue)/(to.kind_of?(RedisQueue::Simple) ? to.name : to), timeout)
end

#decode(element) ⇒ Object 



66
67
68
 
# File 'lib/redis-call/redis_queue.rb', line 66

def decode element
  element
end

#delete ⇒ Object Also known as: destroy 



200
201
202
 
# File 'lib/redis-call/redis_queue.rb', line 200

def delete
  del(@key)
end

#elements ⇒ Object 



146
147
148
 
# File 'lib/redis-call/redis_queue.rb', line 146

def elements
  queued(lgetall(@key)) {|result| result.map {|element| decode(element)}.reverse }
end

#encode(element) ⇒ Object 



62
63
64
 
# File 'lib/redis-call/redis_queue.rb', line 62

def encode element
  element
end

#error_length ⇒ Object 



192
193
194
 
# File 'lib/redis-call/redis_queue.rb', line 192

def error_length
  llen(@key/:error)
end

#error_push(element) ⇒ Object 



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

def error_push element
  lpush(@key/:error, encode(element))
end

#error_push_raw(element) ⇒ Object 



80
81
82
 
# File 'lib/redis-call/redis_queue.rb', line 80

def error_push_raw element
  lpush(@key/:error, element)
end

#filter_backup_element(element) ⇒ Object 



184
185
186
 
# File 'lib/redis-call/redis_queue.rb', line 184

def filter_backup_element element
  element
end

#length ⇒ Object 



188
189
190
 
# File 'lib/redis-call/redis_queue.rb', line 188

def length
  llen(@key)
end

#pop ⇒ Object

Returns element



86
87
88
 
# File 'lib/redis-call/redis_queue.rb', line 86

def pop
  queued(rpop @key) {|result| decode(result) if result}
end

#pop_all ⇒ Object 



138
139
140
141
142
143
 
# File 'lib/redis-call/redis_queue.rb', line 138

def pop_all
  multi do
    queued(lgetall(@key)) {|result| result.map {|element| decode(element)}.reverse }
    queued(del @key)
  end
end

#push(element) ⇒ Object

Returns the number of elements inside the queue after the push operation.



72
73
74
 
# File 'lib/redis-call/redis_queue.rb', line 72

def push element
  lpush(@key, encode(element))
end

#raw_backup_elements ⇒ Object 



154
155
156
 
# File 'lib/redis-call/redis_queue.rb', line 154

def raw_backup_elements
  queued(lgetall(@key/:backup)) {|result| result.reverse }
end

#remove_raw_backup_element(element) ⇒ Object 



115
116
117
118
119
 
# File 'lib/redis-call/redis_queue.rb', line 115

def remove_raw_backup_element element
  queued(lrem(@key/:backup, -1, element)) do |result|
    raise(RedisQueue::ElementNotFound, "Not found element #{element.inspect} in queue #{@key/:backup}") if result != 1
  end
end

#remove_raw_element(element) ⇒ Object 



121
122
123
124
125
 
# File 'lib/redis-call/redis_queue.rb', line 121

def remove_raw_element element
  queued(lrem(@key, -1, element)) do |result|
    raise(RedisQueue::ElementNotFound, "Not found element #{element.inspect} in queue #{@key}") if result != 1
  end
end

#restore_backup ⇒ Object

Raises:



174
175
176
177
178
179
180
181
182
 
# File 'lib/redis-call/redis_queue.rb', line 174

def restore_backup
  raise(NonTransactionalMethod) if inside_transaction?
  
  while element = rpop(@key/:backup)
    if element = filter_backup_element(element)
      lpush(@key, element)
    end
  end
end

#watch(*keys) ⇒ Object 



159
160
161
 
# File 'lib/redis-call/redis_queue.rb', line 159

def watch *keys
  keys.empty? ? super(@key) : super(*keys)
end

#watch_backup ⇒ Object 



163
164
165
 
# File 'lib/redis-call/redis_queue.rb', line 163

def watch_backup
  watch @key/:backup
end