resque 1.27.2 → 2.1.0

data/bin/resque-web

@@ -6,7 +6,7 @@ begin
 rescue LoadError
   require 'rubygems'
   require 'vegas'
-end  
+end
 require 'resque/server'
 
 

data/lib/resque.rb

@@ -23,6 +23,8 @@ require 'resque/thread_signal'
 
 require 'resque/vendor/utf8_util'
 
+require 'resque/railtie' if defined?(Rails)
+
 module Resque
   include Helpers
   extend self
@@ -112,8 +114,8 @@ module Resque
   def redis=(server)
     case server
     when String
-      if server =~ /redis\:\/\//
-        redis = Redis.connect(:url => server, :thread_safe => true)
+      if server =~ /rediss?\:\/\//
+        redis = Redis.new(:url => server, :thread_safe => true)
       else
         server, namespace = server.split('/', 2)
         host, port, db = server.split(':')
@@ -147,26 +149,76 @@ module Resque
     data_store.identifier
   end
 
+  # Set the data store for the processed and failed statistics.
+  #
+  # By default it uses the same as `Resque.redis`, but different stores can be used.
+  #
+  # A custom store needs to obey the following API to work correctly
+  #
+  # class NullDataStore
+  #   # Returns the current value for the given stat.
+  #   def stat(stat)
+  #   end
+  #
+  #   # Increments the stat by the given value.
+  #   def increment_stat(stat, by)
+  #   end
+  #
+  #   # Decrements the stat by the given value.
+  #   def decrement_stat(stat, by)
+  #   end
+  #
+  #   # Clear the values for the given stat.
+  #   def clear_stat(stat)
+  #   end
+  # end
+  def stat_data_store=(stat_data_store)
+    Resque::Stat.data_store = stat_data_store
+  end
+
+  # Returns the data store for the statistics module.
+  def stat_data_store
+    Resque::Stat.data_store
+  end
+
   # Set or retrieve the current logger object
   attr_accessor :logger
 
   DEFAULT_HEARTBEAT_INTERVAL = 60
   DEFAULT_PRUNE_INTERVAL = DEFAULT_HEARTBEAT_INTERVAL * 5
 
+  # Defines how often a Resque worker updates the heartbeat key. Must be less
+  # than the prune interval.
   attr_writer :heartbeat_interval
   def heartbeat_interval
-    @heartbeat_interval || DEFAULT_HEARTBEAT_INTERVAL
+    if defined? @heartbeat_interval
+      @heartbeat_interval
+    else
+      DEFAULT_HEARTBEAT_INTERVAL
+    end
   end
 
+  # Defines how often Resque checks for dead workers.
   attr_writer :prune_interval
   def prune_interval
-    @prune_interval || DEFAULT_PRUNE_INTERVAL
+    if defined? @prune_interval
+      @prune_interval
+    else
+      DEFAULT_PRUNE_INTERVAL
+    end
   end
 
+  # By default, jobs are pushed to the back of the queue and popped from
+  # the front, resulting in "first in, first out" (FIFO) execution order.
+  # Set to true to push jobs to the front of the queue instead, resulting
+  # in "last in, first out" (LIFO) execution order.
   attr_writer :enqueue_front
   def enqueue_front
-    return @enqueue_front unless @enqueue_front.nil?
-    @enqueue_front = false
+    if defined? @enqueue_front
+      @enqueue_front
+    else
+      @enqueue_front = false
+    end
   end
 
   # The `before_first_fork` hook will be run in the **parent** process
@@ -237,6 +289,34 @@ module Resque
     register_hook(:after_pause, block)
   end
 
+  # The `queue_empty` hook will be run in the **parent** process when
+  # the worker finds no more jobs in the queue and becomes idle.
+  #
+  # Call with a block to register a hook.
+  # Call with no arguments to return all registered hooks.
+  def queue_empty(&block)
+    block ? register_hook(:queue_empty, block) : hooks(:queue_empty)
+  end
+
+  # Register a queue_empty proc.
+  def queue_empty=(block)
+    register_hook(:queue_empty, block)
+  end
+
+  # The `worker_exit` hook will be run in the **parent** process
+  # after the worker has existed (via SIGQUIT, SIGTERM, SIGINT, etc.).
+  #
+  # Call with a block to register a hook.
+  # Call with no arguments to return all registered hooks.
+  def worker_exit(&block)
+    block ? register_hook(:worker_exit, block) : hooks(:worker_exit)
+  end
+
+  # Register a worker_exit proc.
+  def worker_exit=(block)
+    register_hook(:worker_exit, block)
+  end
+
   def to_s
     "Resque Client connected to #{redis_id}"
   end
@@ -424,7 +504,7 @@ module Resque
   # Given a class, try to extrapolate an appropriate queue based on a
   # class instance variable or `queue` method.
   def queue_from_class(klass)
-    klass.instance_variable_get(:@queue) ||
+    (klass.instance_variable_defined?(:@queue) && klass.instance_variable_get(:@queue)) ||
       (klass.respond_to?(:queue) and klass.queue)
   end
 
@@ -483,7 +563,7 @@ module Resque
   # Returns a hash, similar to redis-rb's #info, of interesting stats.
   def info
     return {
-      :pending   => queue_sizes.inject(0) { |sum, (queue_name, queue_size)| sum + queue_size },
+      :pending   => queue_sizes.inject(0) { |sum, (_queue_name, queue_size)| sum + queue_size },
       :processed => Stat[:processed],
       :queues    => queues.size,
       :workers   => workers.size.to_i,
@@ -543,6 +623,8 @@ module Resque
 
   private
 
+  @hooks = Hash.new { |h, k| h[k] = [] }
+
   # Register a new proc as a hook. If the block is nil this is the
   # equivalent of removing all hooks of the given name.
   #
@@ -550,26 +632,18 @@ module Resque
   def register_hook(name, block)
     return clear_hooks(name) if block.nil?
 
-    @hooks ||= {}
-    @hooks[name] ||= []
-
     block = Array(block)
     @hooks[name].concat(block)
   end
 
   # Clear all hooks given a hook name.
   def clear_hooks(name)
-    @hooks && @hooks[name] = []
-  end
-
-  # Retrieve all hooks
-  def hooks
-    @hooks || {}
+    @hooks[name] = []
   end
 
   # Retrieve all hooks of a given name.
   def hooks(name)
-    (@hooks && @hooks[name]) || []
+    @hooks[name]
   end
 end
 

data/lib/resque/data_store.rb

@@ -12,7 +12,6 @@ module Resque
       @failed_queue_access  = FailedQueueAccess.new(@redis)
       @workers              = Workers.new(@redis)
       @stats_access         = StatsAccess.new(@redis)
-      @redis_time_available = redis_time_available?
     end
 
     def_delegators :@queue_access, :push_to_queue,
@@ -45,14 +44,20 @@ module Resque
                               :heartbeat!,
                               :remove_heartbeat,
                               :all_heartbeats,
+                              :acquire_pruning_dead_worker_lock,
                               :set_worker_payload,
                               :worker_start_time,
                               :worker_done_working
 
-      def_delegators :@stats_access, :clear_stat,
-                                     :decremet_stat,
-                                     :increment_stat,
-                                     :stat
+    def_delegators :@stats_access, :clear_stat,
+                                   :decrement_stat,
+                                   :increment_stat,
+                                   :stat
+
+    def decremet_stat(*args)
+      warn '[Resque] [Deprecation] Resque::DataStore #decremet_stat method is deprecated (please use #decrement_stat)'
+      decrement_stat(*args)
+    end
 
     # Compatibility with any non-Resque classes that were using Resque.redis as a way to access Redis
     def method_missing(sym,*args,&block)
@@ -68,19 +73,12 @@ module Resque
     # Get a string identifying the underlying server.
     # Probably should be private, but was public so must stay public
     def identifier
-      # support 1.x versions of redis-rb
-      if @redis.respond_to?(:server)
-        @redis.server
-      elsif @redis.respond_to?(:nodes) # distributed
-        @redis.nodes.map { |n| n.id }.join(', ')
-      else
-        @redis.client.id
-      end
+      @redis.inspect
     end
 
     # Force a reconnect to Redis.
     def reconnect
-      @redis.client.reconnect
+      @redis._client.reconnect
     end
 
     # Returns an array of all known Resque keys in Redis. Redis' KEYS operation
@@ -92,17 +90,10 @@ module Resque
     end
 
     def server_time
-      time, _ = @redis_time_available ? @redis.time : Time.now
+      time, _ = @redis.time
       Time.at(time)
     end
 
-    def redis_time_available?
-      @redis.time
-    rescue Redis::CommandError
-      false
-    end
-    private :redis_time_available?
-
     class QueueAccess
       def initialize(redis)
         @redis = redis
@@ -283,6 +274,10 @@ module Resque
         @redis.hgetall(HEARTBEAT_KEY)
       end
 
+      def acquire_pruning_dead_worker_lock(worker, expiry)
+        @redis.set(redis_key_for_worker_pruning, worker.to_s, :ex => expiry, :nx => true)
+      end
+
       def set_worker_payload(worker, data)
         @redis.set(redis_key_for_worker(worker), data)
       end
@@ -307,6 +302,10 @@ module Resque
       def redis_key_for_worker_start_time(worker)
         "#{redis_key_for_worker(worker)}:started"
       end
+
+      def redis_key_for_worker_pruning
+        "pruning_dead_workers_in_progress"
+      end
     end
 
     class StatsAccess

data/lib/resque/errors.rb

@@ -14,7 +14,13 @@ module Resque
       super message
     end
   end
-  class PruneDeadWorkerDirtyExit < DirtyExit; end
+
+  class PruneDeadWorkerDirtyExit < DirtyExit
+    def initialize(hostname, job)
+      job ||= "<Unknown Job>"
+      super("Worker #{hostname} did not gracefully exit while processing #{job}")
+    end
+  end
 
   # Raised when child process is TERM'd so job can rescue this to do shutdown work.
   class TermException < SignalException; end

data/lib/resque/failure.rb

@@ -27,6 +27,7 @@ module Resque
     def self.backend=(backend)
       @backend = backend
     end
+    self.backend = nil
 
     # Returns the current backend class. If none has been set, falls
     # back to `Resque::Failure::Redis`

data/lib/resque/failure/airbrake.rb

@@ -9,7 +9,7 @@ module Resque
     class Airbrake < Base
       def self.configure(&block)
         Resque.logger.warn "This actually sets global Airbrake configuration, " \
-          "which is probably not what you want. This will be gone in 2.0."
+          "which is probably not what you want."
         Resque::Failure.backend = self
         ::Airbrake.configure(&block)
       end
@@ -21,12 +21,24 @@ module Resque
       end
 
       def save
-        ::Airbrake.notify(exception,
-            :parameters => {
-            :payload_class => payload['class'].to_s,
-            :payload_args => payload['args'].inspect
-            }
-          )
+        notify(
+          exception,
+          parameters: {
+            payload_class: payload['class'].to_s,
+            payload_args: payload['args'].inspect
+          }
+        )
+      end
+
+      private
+
+      def notify(exception, options)
+        if ::Airbrake.respond_to?(:notify_sync)
+          ::Airbrake.notify_sync(exception, options)
+        else
+          # Older versions of Airbrake (< 5)
+          ::Airbrake.notify(exception, options)
+        end
       end
     end
   end

data/lib/resque/failure/multiple.rb

@@ -60,8 +60,12 @@ module Resque
         classes.first.requeue_all
       end
 
-      def self.remove(index, queue)
-        classes.each { |klass| klass.remove(index) }
+      def self.requeue_queue(queue)
+        classes.first.requeue_queue(queue)
+      end
+
+      def self.remove(index, queue = nil)
+        classes.each { |klass| klass.remove(index, queue) }
       end
     end
   end

data/lib/resque/failure/redis.rb

@@ -31,7 +31,7 @@ module Resque
 
         if class_name
           n = 0
-          each(0, count(queue), queue, class_name) { n += 1 } 
+          each(0, count(queue), queue, class_name) { n += 1 }
           n
         else
           data_store.num_failed

data/lib/resque/failure/redis_multi_queue.rb

@@ -30,7 +30,7 @@ module Resque
         if queue
           if class_name
             n = 0
-            each(0, count(queue), queue, class_name) { n += 1 } 
+            each(0, count(queue), queue, class_name) { n += 1 }
             n
           else
             data_store.num_failed(queue).to_i
@@ -60,7 +60,7 @@ module Resque
         end
         items.each_with_index do |item, i|
           if !class_name || (item['payload'] && item['payload']['class'] == class_name)
-            id = reversed ? (items.length - 1) - (offset + i) : offset + i
+            id = reversed ? (items.length - 1) + (offset - i) : offset + i
             yield id, item
           end
         end
@@ -79,7 +79,7 @@ module Resque
       end
 
       def self.remove(id, queue = :failed)
-        data_store.remove_from_queue(id,queue)
+        data_store.remove_from_failed_queue(id,queue)
       end
 
       def self.requeue_queue(queue)

data/lib/resque/job.rb

@@ -48,7 +48,7 @@ module Resque
     def self.decode(object)
       Resque.decode(object)
     end
-    
+
     # Given a word with dashes, returns a camel cased version of it.
     def classify(dashed_word)
       Resque.classify(dashed_word)
@@ -154,7 +154,7 @@ module Resque
 
       begin
         # Execute before_perform hook. Abort the job gracefully if
-        # Resque::DontPerform is raised.
+        # Resque::Job::DontPerform is raised.
         begin
           before_hooks.each do |hook|
             job.send(hook, *job_args)

data/lib/resque/logging.rb

@@ -7,7 +7,7 @@ module Resque
     def self.log(severity, message)
       Resque.logger.__send__(severity, message) if Resque.logger
     end
-    
+
     # Log level aliases
     def debug(message); Logging.log :debug, message; end
     def info(message);  Logging.log :info,  message; end

data/lib/resque/railtie.rb

@@ -0,0 +1,10 @@
+module Resque
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require 'resque/tasks'
+
+      # redefine ths task to load the rails env
+      task "resque:setup" => :environment
+    end
+  end
+end