resque 1.26.pre.0 → 1.26.0

data/lib/resque/failure/multiple.rb

@@ -27,6 +27,11 @@ module Resque
         classes.first.count(*args)
       end
 
+      # Returns an array of all available failure queues
+      def self.queues
+        classes.first.queues
+      end
+
       # Returns a paginated array of failure objects.
       def self.all(*args)
         classes.first.all(*args)
@@ -51,7 +56,7 @@ module Resque
         classes.first.requeue(*args)
       end
 
-      def self.remove(index)
+      def self.remove(index, queue)
         classes.each { |klass| klass.remove(index) }
       end
     end

data/lib/resque/failure/redis.rb

@@ -39,7 +39,7 @@ module Resque
       end
 
       def self.each(offset = 0, limit = self.count, queue = :failed, class_name = nil, order = 'desc')
-        all_items = Array(all(offset, limit, queue))
+        all_items = limit == 1 ? [all(offset,limit,queue)] : Array(all(offset, limit, queue))
         reversed = false
         if order.eql? 'desc'
           all_items.reverse!
@@ -48,7 +48,7 @@ module Resque
         all_items.each_with_index do |item, i|
           if !class_name || (item['payload'] && item['payload']['class'] == class_name)
             if reversed
-              id = (all_items.length - 1) - (offset + i)
+              id = (all_items.length - 1) + (offset - i)
             else
               id = offset + i
             end
@@ -62,14 +62,16 @@ module Resque
         Resque.redis.del(:failed)
       end
 
-      def self.requeue(id)
+      def self.requeue(id, queue = nil)
+        check_queue(queue)
         item = all(id)
         item['retried_at'] = Time.now.strftime("%Y/%m/%d %H:%M:%S")
         Resque.redis.lset(:failed, id, Resque.encode(item))
         Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
       end
 
-      def self.remove(id)
+      def self.remove(id, queue = nil)
+        check_queue(queue)
         sentinel = ""
         Resque.redis.lset(:failed, id, sentinel)
         Resque.redis.lrem(:failed, 1,  sentinel)
@@ -83,6 +85,12 @@ module Resque
         end
       end
 
+      def self.requeue_all
+        count.times do |num|
+          requeue(num)
+        end
+      end
+
       def self.remove_queue(queue)
         i = 0
         while job = all(i)
@@ -103,6 +111,7 @@ module Resque
         index = backtrace.index { |item| item.include?('/lib/resque/job.rb') }
         backtrace.first(index.to_i)
       end
+
     end
   end
 end

data/lib/resque/failure/redis_multi_queue.rb

@@ -33,8 +33,8 @@ module Resque
         end
       end
 
-      def self.all(offset = 0, limit = 1, queue = :failed, order = 'desc')
-        Resque.list_range(queue, offset, limit, order)
+      def self.all(offset = 0, limit = 1, queue = :failed)
+        Resque.list_range(queue, offset, limit)
       end
 
       def self.queues
@@ -42,20 +42,24 @@ module Resque
       end
 
       def self.each(offset = 0, limit = self.count, queue = :failed, class_name = nil, order = 'desc')
-        items = all(offset, limit, queue, order)
+        items = all(offset, limit, queue)
         items = [items] unless items.is_a? Array
+        reversed = false
         if order.eql? 'desc'
           items.reverse!
+          reversed = true
         end
         items.each_with_index do |item, i|
           if !class_name || (item['payload'] && item['payload']['class'] == class_name)
-            yield offset + i, item
+            id = reversed ? (items.length - 1) - (offset + i) : offset + i
+            yield id, item
           end
         end
       end
 
-      def self.clear(queue = :failed)
-        Resque.redis.del(queue)
+      def self.clear(queue = nil)
+        queues = queue ? Array(queue) : self.queues
+        queues.each { |queue| Resque.redis.del(queue) }
       end
 
       def self.requeue(id, queue = :failed)
@@ -76,6 +80,10 @@ module Resque
         each(0, count(failure_queue), failure_queue) { |id, _| requeue(id, failure_queue) }
       end
 
+      def self.requeue_all
+        queues.each { |queue| requeue_queue(Resque::Failure.job_queue_name(queue)) }
+      end
+
       def self.remove_queue(queue)
         Resque.redis.del(Resque::Failure.failure_queue_name(queue))
       end

data/lib/resque/helpers.rb

@@ -11,14 +11,6 @@ end
 module Resque
   # Methods used by various classes in Resque.
   module Helpers
-    def self.extended(parent_class)
-      warn("Resque::Helpers will be gone with no replacement in Resque 2.0.0.")
-    end
-
-    def self.included(parent_class)
-      warn("Resque::Helpers will be gone with no replacement in Resque 2.0.0.")
-    end
-
     class DecodeException < StandardError; end
 
     # Direct access to the Redis instance.
@@ -35,73 +27,22 @@ module Resque
     # Given a Ruby object, returns a string suitable for storage in a
     # queue.
     def encode(object)
-      if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)
-        MultiJson.dump object
-      else
-        MultiJson.encode object
-      end
+      Resque.encode(object)
     end
 
     # Given a string, returns a Ruby object.
     def decode(object)
-      return unless object
-
-      begin
-        if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)
-          MultiJson.load object
-        else
-          MultiJson.decode object
-        end
-      rescue ::MultiJson::DecodeError => e
-        raise DecodeException, e.message, e.backtrace
-      end
+      Resque.decode(object)
     end
 
     # Given a word with dashes, returns a camel cased version of it.
-    #
-    # classify('job-name') # => 'JobName'
     def classify(dashed_word)
-      dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+      Resque.classify(dashed_word)
     end
 
-    # Tries to find a constant with the name specified in the argument string:
-    #
-    # constantize("Module") # => Module
-    # constantize("Test::Unit") # => Test::Unit
-    #
-    # The name is assumed to be the one of a top-level constant, no matter
-    # whether it starts with "::" or not. No lexical context is taken into
-    # account:
-    #
-    # C = 'outside'
-    # module M
-    #   C = 'inside'
-    #   C # => 'inside'
-    #   constantize("C") # => 'outside', same as ::C
-    # end
-    #
-    # NameError is raised when the constant is unknown.
+    # Tries to find a constant with the name specified in the argument string
     def constantize(camel_cased_word)
-      camel_cased_word = camel_cased_word.to_s
-
-      if camel_cased_word.include?('-')
-        camel_cased_word = classify(camel_cased_word)
-      end
-
-      names = camel_cased_word.split('::')
-      names.shift if names.empty? || names.first.empty?
-
-      constant = Object
-      names.each do |name|
-        args = Module.method(:const_get).arity != 1 ? [false] : []
-
-        if constant.const_defined?(name, *args)
-          constant = constant.const_get(name)
-        else
-          constant = constant.const_missing(name)
-        end
-      end
-      constant
+      Resque.constantize(camel_cased_word)
     end
   end
 end

data/lib/resque/job.rb

@@ -12,6 +12,8 @@ module Resque
   #   klass = Resque::Job.constantize(job.payload['class'])
   #   klass.perform(*job.payload['args'])
   class Job
+    include Helpers
+    extend Helpers
     def redis
       Resque.redis
     end
@@ -23,98 +25,33 @@ module Resque
     # Given a Ruby object, returns a string suitable for storage in a
     # queue.
     def encode(object)
-      if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)
-        MultiJson.dump object
-      else
-        MultiJson.encode object
-      end
+      Resque.encode(object)
     end
 
     # Given a string, returns a Ruby object.
     def decode(object)
-      return unless object
-
-      begin
-        if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)
-          MultiJson.load object
-        else
-          MultiJson.decode object
-        end
-      rescue ::MultiJson::DecodeError => e
-        raise DecodeException, e.message, e.backtrace
-      end
+      Resque.decode(object)
     end
 
     # Given a Ruby object, returns a string suitable for storage in a
     # queue.
     def self.encode(object)
-      if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)
-        MultiJson.dump object
-      else
-        MultiJson.encode object
-      end
+      Resque.encode(object)
     end
 
     # Given a string, returns a Ruby object.
     def self.decode(object)
-      return unless object
-
-      begin
-        if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)
-          MultiJson.load object
-        else
-          MultiJson.decode object
-        end
-      rescue ::MultiJson::DecodeError => e
-        raise DecodeException, e.message, e.backtrace
-      end
+      Resque.decode(object)
     end
     
     # Given a word with dashes, returns a camel cased version of it.
-    #
-    # classify('job-name') # => 'JobName'
     def classify(dashed_word)
-      dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+      Resque.classify(dashed_word)
     end
-    
-    # Tries to find a constant with the name specified in the argument string:
-    #
-    # constantize("Module") # => Module
-    # constantize("Test::Unit") # => Test::Unit
-    #
-    # The name is assumed to be the one of a top-level constant, no matter
-    # whether it starts with "::" or not. No lexical context is taken into
-    # account:
-    #
-    # C = 'outside'
-    # module M
-    #   C = 'inside'
-    #   C # => 'inside'
-    #   constantize("C") # => 'outside', same as ::C
-    # end
-    #
-    # NameError is raised when the constant is unknown.
-    def constantize(camel_cased_word)
-      camel_cased_word = camel_cased_word.to_s
-
-      if camel_cased_word.include?('-')
-        camel_cased_word = classify(camel_cased_word)
-      end
-
-      names = camel_cased_word.split('::')
-      names.shift if names.empty? || names.first.empty?
-
-      constant = Object
-      names.each do |name|
-        args = Module.method(:const_get).arity != 1 ? [false] : []
 
-        if constant.const_defined?(name, *args)
-          constant = constant.const_get(name)
-        else
-          constant = constant.const_missing(name)
-        end
-      end
-      constant
+    # Tries to find a constant with the name specified in the argument string
+    def constantize(camel_cased_word)
+      Resque.constantize(camel_cased_word)
     end
 
     # Raise Resque::Job::DontPerform from a before_perform hook to
@@ -289,12 +226,17 @@ module Resque
     # Given an exception object, hands off the needed parameters to
     # the Failure module.
     def fail(exception)
-      run_failure_hooks(exception)
-      Failure.create \
-        :payload   => payload,
-        :exception => exception,
-        :worker    => worker,
-        :queue     => queue
+      begin
+        run_failure_hooks(exception)
+      rescue Exception => e
+        raise e
+      ensure
+        Failure.create \
+          :payload   => payload,
+          :exception => exception,
+          :worker    => worker,
+          :queue     => queue
+      end
     end
 
     # Creates an identical job, essentially placing this job back on
@@ -338,6 +280,10 @@ module Resque
         if has_payload_class?
           failure_hooks.each { |hook| payload_class.send(hook, exception, *job_args) } unless @failure_hooks_ran
         end
+      rescue Exception => e
+        error_message = "Additional error (#{e.class}: #{e}) occurred in running failure hooks for job #{inspect}\n" \
+                        "Original error that caused job failure was #{e.class}: #{exception.class}: #{exception.message}"
+        raise RuntimeError.new(error_message)
       ensure
         @failure_hooks_ran = true
       end

data/lib/resque/logging.rb

@@ -15,4 +15,4 @@ module Resque
     def error(message); Logging.log :error, message; end
     def fatal(message); Logging.log :fatal, message; end
   end
-end
+end

data/lib/resque/plugin.rb

@@ -11,56 +11,68 @@ module Resque
       hooks = before_hooks(plugin) + around_hooks(plugin) + after_hooks(plugin)
 
       hooks.each do |hook|
-        if hook =~ /perform$/
+        if hook.to_s.end_with?("perform")
           raise LintError, "#{plugin}.#{hook} is not namespaced"
         end
       end
 
       failure_hooks(plugin).each do |hook|
-        if hook =~ /failure$/
+        if hook.to_s.end_with?("failure")
           raise LintError, "#{plugin}.#{hook} is not namespaced"
         end
       end
     end
 
+    @job_methods = {}
+    def job_methods(job)
+      @job_methods[job] ||= job.methods.collect{|m| m.to_s}
+    end
+
+    # Given an object, and a method prefix, returns a list of methods prefixed
+    # with that name (hook names).
+    def get_hook_names(job, hook_method_prefix)
+      methods = (job.respond_to?(:hooks) && job.hooks) || job_methods(job)
+      methods.select{|m| m.start_with?(hook_method_prefix)}.sort
+    end
+
     # Given an object, returns a list `before_perform` hook names.
     def before_hooks(job)
-      job.methods.grep(/^before_perform/).sort
+      get_hook_names(job, 'before_perform')
     end
 
     # Given an object, returns a list `around_perform` hook names.
     def around_hooks(job)
-      job.methods.grep(/^around_perform/).sort
+      get_hook_names(job, 'around_perform')
     end
 
     # Given an object, returns a list `after_perform` hook names.
     def after_hooks(job)
-      job.methods.grep(/^after_perform/).sort
+      get_hook_names(job, 'after_perform')
     end
 
     # Given an object, returns a list `on_failure` hook names.
     def failure_hooks(job)
-      job.methods.grep(/^on_failure/).sort
+      get_hook_names(job, 'on_failure')
     end
 
     # Given an object, returns a list `after_enqueue` hook names.
     def after_enqueue_hooks(job)
-      job.methods.grep(/^after_enqueue/).sort
+      get_hook_names(job, 'after_enqueue')
     end
 
     # Given an object, returns a list `before_enqueue` hook names.
     def before_enqueue_hooks(job)
-      job.methods.grep(/^before_enqueue/).sort
+      get_hook_names(job, 'before_enqueue')
     end
 
     # Given an object, returns a list `after_dequeue` hook names.
     def after_dequeue_hooks(job)
-      job.methods.grep(/^after_dequeue/).sort
+      get_hook_names(job, 'after_dequeue')
     end
 
     # Given an object, returns a list `before_dequeue` hook names.
     def before_dequeue_hooks(job)
-      job.methods.grep(/^before_dequeue/).sort
+      get_hook_names(job, 'before_dequeue')
     end
   end
 end