Module: Resque

Extended by:
Resque
Includes:
Helpers
Included in:
Resque
Defined in:
lib/resque.rb,
lib/resque/job.rb,
lib/resque/stat.rb,
lib/resque/errors.rb,
lib/resque/plugin.rb,
lib/resque/server.rb,
lib/resque/worker.rb,
lib/resque/failure.rb,
lib/resque/helpers.rb,
lib/resque/version.rb,
lib/resque/failure/base.rb,
lib/resque/failure/mongo.rb,
lib/resque/failure/hoptoad.rb,
lib/resque/failure/multiple.rb,
lib/resque/server/test_helper.rb

Defined Under Namespace

Modules: Failure, Helpers, Plugin, Stat, TestHelper Classes: DirtyExit, Job, NoClassError, NoQueueError, Server, Worker

Constant Summary collapse

Version = 
VERSION = '1.9.8.1'

Instance Method Summary collapse

Methods included from Helpers

#classify, #constantize, #decode, #encode

Instance Method Details

#add_indexes ⇒ Object 



120
121
122
123
124
 
# File 'lib/resque.rb', line 120

def add_indexes
  @mongo.create_index :queue
  @workers.create_index :worker
  @stats.create_index :stat
end

#after_fork(&block) ⇒ Object

The ‘after_fork` hook will be run in the child process and is passed the current job. Any changes you make, therefore, will only live as long as the job currently being processed.

Call with a block to set the hook. Call with no arguments to return the hook.



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

def after_fork(&block)
  block ? (@after_fork = block) : @after_fork
end

#after_fork=(after_fork) ⇒ Object

Set the after_fork proc.



112
113
114
 
# File 'lib/resque.rb', line 112

def after_fork=(after_fork)
  @after_fork = after_fork
end

#before_first_fork(&block) ⇒ Object

The ‘before_first_fork` hook will be run in the parent process only once, before forking to run the first job. Be careful- any changes you make will be permanent for the lifespan of the worker.

Call with a block to set the hook. Call with no arguments to return the hook.



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

def before_first_fork(&block)
  block ? (@before_first_fork = block) : @before_first_fork
end

#before_first_fork=(before_first_fork) ⇒ Object

Set a proc that will be called in the parent process before the worker forks for the first time.



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

def before_first_fork=(before_first_fork)
  @before_first_fork = before_first_fork
end

#before_fork(&block) ⇒ Object

The ‘before_fork` hook will be run in the parent process before every job, so be careful- any changes you make will be permanent for the lifespan of the worker.

Call with a block to set the hook. Call with no arguments to return the hook.



92
93
94
 
# File 'lib/resque.rb', line 92

def before_fork(&block)
  block ? (@before_fork = block) : @before_fork
end

#before_fork=(before_fork) ⇒ Object

Set the before_fork proc.



97
98
99
 
# File 'lib/resque.rb', line 97

def before_fork=(before_fork)
  @before_fork = before_fork
end

#dequeue(klass, *args) ⇒ Object

This method can be used to conveniently remove a job from a queue. It assumes the class you’re passing it is a real Ruby class (not a string or reference) which either:

a) has a @queue ivar set
b) responds to `queue`

If either of those conditions are met, it will use the value obtained from performing one of the above operations to determine the queue.

If no queue can be inferred this method will raise a ‘Resque::NoQueueError`

If no args are given, this method will dequeue all jobs matching the provided class. See ‘Resque::Job.destroy` for more information.

Returns the number of jobs destroyed.

Example:

# Removes all jobs of class `UpdateNetworkGraph`
Resque.dequeue(GitHub::Jobs::UpdateNetworkGraph)

# Removes all jobs of class `UpdateNetworkGraph` with matching args.
Resque.dequeue(GitHub::Jobs::UpdateNetworkGraph, 'repo:135325')

This method is considered part of the ‘stable` API.



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

def dequeue(klass, *args)
  Job.destroy(queue_from_class(klass), klass, *args)
end

#drop ⇒ Object 



126
127
128
129
130
131
132
 
# File 'lib/resque.rb', line 126

def drop
  @mongo.drop if @mongo
  @workers.drop if @workers
  @failures.drop if @failures
  @stats.drop if @stats
  @mongo = nil
end

#enqueue(klass, *args) ⇒ Object

This method can be used to conveniently add a job to a queue. It assumes the class you’re passing it is a real Ruby class (not a string or reference) which either:

a) has a @queue ivar set
b) responds to `queue`

If either of those conditions are met, it will use the value obtained from performing one of the above operations to determine the queue.

If no queue can be inferred this method will raise a ‘Resque::NoQueueError`

This method is considered part of the ‘stable` API.



220
221
222
 
# File 'lib/resque.rb', line 220

def enqueue(klass, *args)
  Job.create(queue_from_class(klass), klass, *args)
end

#info ⇒ Object

Returns a hash, similar to redis-rb’s #info, of interesting stats.



298
299
300
301
302
303
304
305
306
307
308
309
 
# File 'lib/resque.rb', line 298

def info
  return {
    :pending   => queues.inject(0) { |m,k| m + size(k) },
    :processed => Stat[:processed],
    :queues    => queues.size,
    :workers   => workers.size.to_i,
    :working   => working.size,
    :failed    => Stat[:failed],
    :servers   => ["#{@con.host}:#{@con.port}"],
    :environment  => ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
  }
end

#keys ⇒ Object

Returns an array of all known Resque keys in Redis. Redis’ KEYS operation is O(N) for the keyspace, so be careful - this can be slow for big databases.



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

def keys
  queues
end

#mongo ⇒ Object

Returns the current Redis connection. If none has been created, will create a new one.



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

def mongo
  return @mongo if @mongo
  self.mongo = 'localhost:27017'
  self.mongo
end

#mongo=(server) ⇒ Object

Accepts a ‘hostname:port’ string or a Redis server.



27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/resque.rb', line 27

def mongo=(server)
  case server
  when String
    host, port = server.split(':')
    @con = Mongo::Connection.new(host, port)
    @db = @con.db('monque')
    @mongo = @db.collection('monque')
    @workers = @db.collection('workers')
    @failures = @db.collection('failures')
    @stats = @db.collection('stats')

    add_indexes
  end
end

#mongo_failures ⇒ Object 



57
58
59
60
61
 
# File 'lib/resque.rb', line 57

def mongo_failures
  return @failures if @failures
  self.mongo = 'localhost:27017'
  @failures
end

#mongo_stats ⇒ Object 



63
64
65
66
67
 
# File 'lib/resque.rb', line 63

def mongo_stats
  return @stats if @stats
  self.mongo = 'localhost:27017'
  @stats
end

#mongo_workers ⇒ Object 



51
52
53
54
55
 
# File 'lib/resque.rb', line 51

def mongo_workers
  return @workers if @workers
  self.mongo = 'localhost:27017'
  @workers
end

#peek(queue, start = 0, count = 1) ⇒ Object

Returns an array of items currently queued. Queue name should be a string.

start and count should be integer and can be used for pagination. start is the item to begin, count is how many items to return.

To get the 3rd page of a 30 item, paginatied list one would use:

Resque.peek('my_list', 59, 30)



172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/resque.rb', line 172

def peek(queue, start = 0, count = 1)
  start, count = [start, count].map { |n| Integer(n) }
  res = mongo.find(:queue => queue).sort([:natural, :desc]).skip(start).limit(count).to_a
  res.collect! { |doc| decode(doc['item']) }
  
  if count == 1
    return nil if res.empty?
    res.first
  else
    return [] if res.empty?
    res
  end
end

#pop(queue) ⇒ Object

Pops a job off a queue. Queue name should be a string.

Returns a Ruby object.



148
149
150
151
152
153
154
155
156
 
# File 'lib/resque.rb', line 148

def pop(queue)
  doc = mongo.find_and_modify( :query => { :queue => queue },
                               :sort => [:natural, :desc],
                               :remove => true )
  decode doc['item']
rescue Mongo::OperationFailure => e
  return nil if e.message =~ /No matching object/
  raise e
end

#push(queue, item) ⇒ Object

Pushes a job onto a queue. Queue name should be a string and the item should be any JSON-able Ruby object.



140
141
142
143
 
# File 'lib/resque.rb', line 140

def push(queue, item)
  watch_queue(queue)
  mongo << { :queue => queue.to_s, :item => encode(item) }
end

#queue_from_class(klass) ⇒ Object

Given a class, try to extrapolate an appropriate queue based on a class instance variable or ‘queue` method.



257
258
259
260
 
# File 'lib/resque.rb', line 257

def queue_from_class(klass)
  klass.instance_variable_get(:@queue) ||
    (klass.respond_to?(:queue) and klass.queue)
end

#queues ⇒ Object

Returns an array of all known Resque queues as strings.



187
188
189
 
# File 'lib/resque.rb', line 187

def queues
  mongo.distinct(:queue)
end

#remove_queue(queue) ⇒ Object

Given a queue name, completely deletes the queue.



192
193
194
 
# File 'lib/resque.rb', line 192

def remove_queue(queue)
  mongo.remove(:queue => queue)
end

#remove_worker(worker_id) ⇒ Object

A shortcut to unregister_worker useful for command line tool



288
289
290
291
 
# File 'lib/resque.rb', line 288

def remove_worker(worker_id)
  worker = Resque::Worker.find(worker_id)
  worker.unregister_worker
end

#reserve(queue) ⇒ Object

This method will return a ‘Resque::Job` object or a non-true value depending on whether a job can be obtained. You should pass it the precise name of a queue: case matters.

This method is considered part of the ‘stable` API.



267
268
269
 
# File 'lib/resque.rb', line 267

def reserve(queue)
  Job.reserve(queue)
end

#size(queue) ⇒ Object

Returns an integer representing the size of a queue. Queue name should be a string.



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

def size(queue)
  mongo.find(:queue => queue).count
end

#to_s ⇒ Object 



116
117
118
 
# File 'lib/resque.rb', line 116

def to_s
  "Mongo Client connected to #{@con.host}"
end

#watch_queue(queue) ⇒ Object

Used internally to keep track of which queues we’ve created. Don’t call this directly.



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

def watch_queue(queue)
#    redis.sadd(:queues, queue.to_s)
end

#workers ⇒ Object

A shortcut to Worker.all



277
278
279
 
# File 'lib/resque.rb', line 277

def workers
  Worker.all
end

#working ⇒ Object

A shortcut to Worker.working



282
283
284
 
# File 'lib/resque.rb', line 282

def working
  Worker.working
end