resque 1.27.4 → 2.6.0

data/bin/resque-web

@@ -1,31 +1,15 @@
 #!/usr/bin/env ruby
 
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-begin
-  require 'vegas'
-rescue LoadError
-  require 'rubygems'
-  require 'vegas'
-end  
-require 'resque/server'
 
-
-Vegas::Runner.new(Resque::Server, 'resque-web', {
-  :before_run => lambda {|v|
-    path = (ENV['RESQUECONFIG'] || v.args.first)
-    load path.to_s.strip if path
-  }
-}) do |runner, opts, app|
-  opts.on('-N NAMESPACE', "--namespace NAMESPACE", "set the Redis namespace") {|namespace|
-    runner.logger.info "Using Redis namespace '#{namespace}'"
-    Resque.redis.namespace = namespace
-  }
-  opts.on('-r redis-connection', "--redis redis-connection", "set the Redis connection string") {|redis_conf|
-    runner.logger.info "Using Redis connection '#{redis_conf}'"
-    Resque.redis = redis_conf
-  }
-  opts.on('-a url-prefix', "--append url-prefix", "set reverse_proxy friendly prefix to links") {|url_prefix|
-    runner.logger.info "Using URL Prefix '#{url_prefix}'"
-    Resque::Server.url_prefix = url_prefix
-  }
+if !!(RUBY_PLATFORM =~ /(mingw|bccwin|wince|mswin32)/i)
+  begin
+    require 'win32/process'
+  rescue
+    puts "Sorry, in order to use resque-web on Windows you need the win32-process gem:",
+         "gem install win32-process"
+  end
 end
+require 'resque/web_runner'
+
+Resque::WebRunner.new(*ARGV)

data/lib/resque/data_store.rb

@@ -44,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)
@@ -67,19 +73,15 @@ 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.
+    # Force a reconnect to Redis without closing the connection in the parent
+    # process after a fork.
     def reconnect
-      @redis.client.reconnect
+      @redis.disconnect!
+      @redis.ping
+      nil
     end
 
     # Returns an array of all known Resque keys in Redis. Redis' KEYS operation
@@ -91,34 +93,18 @@ module Resque
     end
 
     def server_time
-      time, _ = redis_time_available? ? @redis.time : Time.now
+      time, _ = @redis.time
       Time.at(time)
     end
 
-    # only needed until support for Redis 2.4 is removed
-    def redis_time_available?
-      if @redis_time_available.nil? && !Resque.inline
-        begin
-          @redis_time_available = @redis.time
-        rescue Redis::CommandError
-          @redis_time_available = false
-        end
-      elsif Resque.inline
-        false
-      else
-        @redis_time_available
-      end
-    end
-    private :redis_time_available?
-
     class QueueAccess
       def initialize(redis)
         @redis = redis
       end
       def push_to_queue(queue,encoded_item)
-        @redis.pipelined do
-          watch_queue(queue)
-          @redis.rpush redis_key_for_queue(queue), encoded_item
+        @redis.pipelined do |piped|
+          watch_queue(queue, redis: piped)
+          piped.rpush redis_key_for_queue(queue), encoded_item
         end
       end
 
@@ -145,9 +131,9 @@ module Resque
       end
 
       def remove_queue(queue)
-        @redis.pipelined do
-          @redis.srem(:queues, queue.to_s)
-          @redis.del(redis_key_for_queue(queue))
+        @redis.pipelined do |piped|
+          piped.srem(:queues, [queue.to_s])
+          piped.del(redis_key_for_queue(queue))
         end
       end
 
@@ -161,8 +147,8 @@ module Resque
       end
 
       # Private: do not call
-      def watch_queue(queue)
-        @redis.sadd(:queues, queue.to_s)
+      def watch_queue(queue, redis: @redis)
+        redis.sadd(:queues, [queue.to_s])
       end
 
       # Private: do not call
@@ -188,7 +174,7 @@ module Resque
       end
 
       def add_failed_queue(failed_queue_name)
-        @redis.sadd(:failed_queues, failed_queue_name)
+        @redis.sadd(:failed_queues, [failed_queue_name])
       end
 
       def remove_failed_queue(failed_queue_name=:failed)
@@ -253,24 +239,24 @@ module Resque
       end
 
       def register_worker(worker)
-        @redis.pipelined do
-          @redis.sadd(:workers, worker)
-          worker_started(worker)
+        @redis.pipelined do |piped|
+          piped.sadd(:workers, [worker.id])
+          worker_started(worker, redis: piped)
         end
       end
 
-      def worker_started(worker)
-        @redis.set(redis_key_for_worker_start_time(worker), Time.now.to_s)
+      def worker_started(worker, redis: @redis)
+        redis.set(redis_key_for_worker_start_time(worker), Time.now.to_s)
       end
 
       def unregister_worker(worker, &block)
-        @redis.pipelined do
-          @redis.srem(:workers, worker)
-          @redis.del(redis_key_for_worker(worker))
-          @redis.del(redis_key_for_worker_start_time(worker))
-          @redis.hdel(HEARTBEAT_KEY, worker.to_s)
+        @redis.pipelined do |piped|
+          piped.srem(:workers, [worker.id])
+          piped.del(redis_key_for_worker(worker))
+          piped.del(redis_key_for_worker_start_time(worker))
+          piped.hdel(HEARTBEAT_KEY, worker.to_s)
 
-          block.call
+          block.call redis: piped
         end
       end
 
@@ -291,6 +277,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
@@ -300,9 +290,9 @@ module Resque
       end
 
       def worker_done_working(worker, &block)
-        @redis.pipelined do
-          @redis.del(redis_key_for_worker(worker))
-          block.call
+        @redis.pipelined do |piped|
+          piped.del(redis_key_for_worker(worker))
+          block.call redis: piped
         end
       end
 
@@ -315,6 +305,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
@@ -325,16 +319,16 @@ module Resque
         @redis.get("stat:#{stat}").to_i
       end
 
-      def increment_stat(stat, by = 1)
-        @redis.incrby("stat:#{stat}", by)
+      def increment_stat(stat, by = 1, redis: @redis)
+        redis.incrby("stat:#{stat}", by)
       end
 
       def decremet_stat(stat, by = 1)
         @redis.decrby("stat:#{stat}", by)
       end
 
-      def clear_stat(stat)
-        @redis.del("stat:#{stat}")
+      def clear_stat(stat, redis: @redis)
+        redis.del("stat:#{stat}")
       end
     end
   end

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/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

@@ -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

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`
@@ -90,6 +91,12 @@ module Resque
       backend.clear(queue)
     end
 
+    def self.clear_retried
+      each do |index, job|
+        remove(index) unless job['retried_at'].nil?
+      end
+    end
+
     def self.requeue(id, queue = nil)
       backend.requeue(id, queue)
     end

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