delayed_job 4.0.2 → 4.0.3

data/lib/delayed/recipes.rb

@@ -25,7 +25,7 @@ Capistrano::Configuration.instance.load do
     end
 
     def args
-      fetch(:delayed_job_args, "")
+      fetch(:delayed_job_args, '')
     end
 
     def roles
@@ -33,20 +33,20 @@ Capistrano::Configuration.instance.load do
     end
 
     def delayed_job_command
-      fetch(:delayed_job_command, "script/delayed_job")
+      fetch(:delayed_job_command, 'script/delayed_job')
     end
 
-    desc "Stop the delayed_job process"
+    desc 'Stop the delayed_job process'
     task :stop, :roles => lambda { roles } do
       run "cd #{current_path};#{rails_env} #{delayed_job_command} stop"
     end
 
-    desc "Start the delayed_job process"
+    desc 'Start the delayed_job process'
     task :start, :roles => lambda { roles } do
       run "cd #{current_path};#{rails_env} #{delayed_job_command} start #{args}"
     end
 
-    desc "Restart the delayed_job process"
+    desc 'Restart the delayed_job process'
     task :restart, :roles => lambda { roles } do
       run "cd #{current_path};#{rails_env} #{delayed_job_command} restart #{args}"
     end

data/lib/delayed/serialization/active_record.rb

@@ -1,15 +1,17 @@
 if defined?(ActiveRecord)
-  class ActiveRecord::Base
-    yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
+  module ActiveRecord
+    class Base
+      yaml_as 'tag:ruby.yaml.org,2002:ActiveRecord'
 
-    def self.yaml_new(klass, tag, val)
-      klass.unscoped.find(val['attributes'][klass.primary_key])
-    rescue ActiveRecord::RecordNotFound
-      raise Delayed::DeserializationError, "ActiveRecord::RecordNotFound, class: #{klass} , primary key: #{val['attributes'][klass.primary_key]} "
-    end
+      def self.yaml_new(klass, _tag, val)
+        klass.unscoped.find(val['attributes'][klass.primary_key])
+      rescue ActiveRecord::RecordNotFound
+        raise Delayed::DeserializationError, "ActiveRecord::RecordNotFound, class: #{klass} , primary key: #{val['attributes'][klass.primary_key]}"
+      end
 
-    def to_yaml_properties
-      ['@attributes']
+      def to_yaml_properties
+        ['@attributes']
+      end
     end
   end
 end

data/lib/delayed/syck_ext.rb

@@ -1,7 +1,7 @@
 class Module
-  yaml_as "tag:ruby.yaml.org,2002:module"
+  yaml_as 'tag:ruby.yaml.org,2002:module'
 
-  def self.yaml_new(klass, tag, val)
+  def self.yaml_new(_klass, _tag, val)
     val.constantize
   end
 
@@ -20,7 +20,7 @@ class Module
 end
 
 class Class
-  yaml_as "tag:ruby.yaml.org,2002:class"
+  yaml_as 'tag:ruby.yaml.org,2002:class'
   remove_method :to_yaml if respond_to?(:to_yaml) && method(:to_yaml).owner == Class # use Module's to_yaml
 end
 

data/lib/delayed/tasks.rb

@@ -1,17 +1,17 @@
 namespace :jobs do
-  desc "Clear the delayed_job queue."
+  desc 'Clear the delayed_job queue.'
   task :clear => :environment do
     Delayed::Job.delete_all
   end
 
-  desc "Start a delayed_job worker."
+  desc 'Start a delayed_job worker.'
   task :work => :environment_options do
     Delayed::Worker.new(@worker_options).start
   end
 
-  desc "Start a delayed_job worker and exit when all available jobs are complete."
+  desc 'Start a delayed_job worker and exit when all available jobs are complete.'
   task :workoff => :environment_options do
-    Delayed::Worker.new(@worker_options.merge({:exit_on_complete => true})).start
+    Delayed::Worker.new(@worker_options.merge(:exit_on_complete => true)).start
   end
 
   task :environment_options => :environment do
@@ -30,7 +30,7 @@ namespace :jobs do
     unprocessed_jobs = Delayed::Job.where('attempts = 0 AND created_at < ?', Time.now - args[:max_age].to_i).count
 
     if unprocessed_jobs > 0
-      fail "#{unprocessed_jobs} jobs older than #{args[:max_age]} seconds have not been processed yet"
+      raise "#{unprocessed_jobs} jobs older than #{args[:max_age]} seconds have not been processed yet"
     end
 
   end

data/lib/delayed/worker.rb

@@ -7,8 +7,7 @@ require 'logger'
 require 'benchmark'
 
 module Delayed
-
-  class Worker
+  class Worker # rubocop:disable ClassLength
     DEFAULT_LOG_LEVEL        = 'info'
     DEFAULT_SLEEP_DELAY      = 5
     DEFAULT_MAX_ATTEMPTS     = 25
@@ -19,8 +18,8 @@ module Delayed
     DEFAULT_READ_AHEAD       = 5
 
     cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time,
-      :default_priority, :sleep_delay, :logger, :delay_jobs, :queues,
-      :read_ahead, :plugins, :destroy_failed_jobs, :exit_on_complete
+                   :default_priority, :sleep_delay, :logger, :delay_jobs, :queues,
+                   :read_ahead, :plugins, :destroy_failed_jobs, :exit_on_complete
 
     # Named queue into which jobs are enqueued by default
     cattr_accessor :default_queue_name
@@ -70,12 +69,12 @@ module Delayed
         require "delayed/backend/#{backend}"
         backend = "Delayed::Backend::#{backend.to_s.classify}::Job".constantize
       end
-      @@backend = backend
+      @@backend = backend # rubocop:disable ClassVars
       silence_warnings { ::Delayed.const_set(:Job, backend) }
     end
 
     def self.guess_backend
-      warn "[DEPRECATION] guess_backend is deprecated. Please remove it from your code."
+      warn '[DEPRECATION] guess_backend is deprecated. Please remove it from your code.'
     end
 
     def self.before_fork
@@ -93,12 +92,11 @@ module Delayed
       # Re-open file handles
       @files_to_reopen.each do |file|
         begin
-          file.reopen file.path, "a+"
+          file.reopen file.path, 'a+'
           file.sync = true
-        rescue ::Exception
+        rescue ::Exception # rubocop:disable HandleExceptions, RescueException
         end
       end
-
       backend.after_fork
     end
 
@@ -106,15 +104,15 @@ module Delayed
       @lifecycle ||= Delayed::Lifecycle.new
     end
 
-    def initialize(options={})
-      @quiet = options.has_key?(:quiet) ? options[:quiet] : true
+    def initialize(options = {})
+      @quiet = options.key?(:quiet) ? options[:quiet] : true
       @failed_reserve_count = 0
 
       [:min_priority, :max_priority, :sleep_delay, :read_ahead, :queues, :exit_on_complete].each do |option|
-        self.class.send("#{option}=", options[option]) if options.has_key?(option)
+        self.class.send("#{option}=", options[option]) if options.key?(option)
       end
 
-      self.plugins.each { |klass| klass.new }
+      plugins.each { |klass| klass.new }
     end
 
     # Every worker has a unique name which by default is the pid of the process. There are some
@@ -123,29 +121,27 @@ module Delayed
     # it crashed before.
     def name
       return @name unless @name.nil?
-      "#{@name_prefix}host:#{Socket.gethostname} pid:#{Process.pid}" rescue "#{@name_prefix}pid:#{Process.pid}"
+      "#{@name_prefix}host:#{Socket.gethostname} pid:#{Process.pid}" rescue "#{@name_prefix}pid:#{Process.pid}" # rubocop:disable RescueModifier
     end
 
     # Sets the name of the worker.
     # Setting the name to nil will reset the default worker name
-    def name=(val)
-      @name = val
-    end
+    attr_writer :name
 
-    def start
+    def start # rubocop:disable CyclomaticComplexity, PerceivedComplexity
       trap('TERM') do
         say 'Exiting...'
         stop
-        raise SignalException.new('TERM') if self.class.raise_signal_exceptions
+        raise SignalException, 'TERM' if self.class.raise_signal_exceptions
       end
 
       trap('INT') do
         say 'Exiting...'
         stop
-        raise SignalException.new('INT') if self.class.raise_signal_exceptions && self.class.raise_signal_exceptions != :term
+        raise SignalException, 'INT' if self.class.raise_signal_exceptions && self.class.raise_signal_exceptions != :term
       end
 
-      say "Starting job worker"
+      say 'Starting job worker'
 
       self.class.lifecycle.run_callbacks(:execute, self) do
         loop do
@@ -159,13 +155,13 @@ module Delayed
 
           if count.zero?
             if self.class.exit_on_complete
-              say "No more jobs available. Exiting"
+              say 'No more jobs available. Exiting'
               break
-            else
-              sleep(self.class.sleep_delay) unless stop?
+            elsif !stop?
+              sleep(self.class.sleep_delay)
             end
           else
-            say "#{count} jobs processed at %.4f j/s, %d failed" % [count / @realtime, @result.last]
+            say format("#{count} jobs processed at %.4f j/s, %d failed", count / @realtime, @result.last)
           end
 
           break if stop?
@@ -189,16 +185,16 @@ module Delayed
       num.times do
         case reserve_and_run_one_job
         when true
-            success += 1
+          success += 1
         when false
-            failure += 1
+          failure += 1
         else
           break  # leave if no work could be done
         end
         break if stop? # leave if we're exiting
       end
 
-      return [success, failure]
+      [success, failure]
     end
 
     def run(job)
@@ -207,13 +203,13 @@ module Delayed
         Timeout.timeout(self.class.max_run_time.to_i, WorkerTimeout) { job.invoke_job }
         job.destroy
       end
-      job_say job, 'COMPLETED after %.4f' % runtime
+      job_say job, format('COMPLETED after %.4f', runtime)
       return true  # did work
     rescue DeserializationError => error
       job.last_error = "#{error.message}\n#{error.backtrace.join("\n")}"
       failed(job)
-    rescue Exception => error
-      self.class.lifecycle.run_callbacks(:error, self, job){ handle_failed_job(job, error) }
+    rescue => error
+      self.class.lifecycle.run_callbacks(:error, self, job) { handle_failed_job(job, error) }
       return false  # work failed
     end
 
@@ -233,8 +229,14 @@ module Delayed
 
     def failed(job)
       self.class.lifecycle.run_callbacks(:failure, self, job) do
-        job.hook(:failure)
-        self.class.destroy_failed_jobs ? job.destroy : job.fail!
+        begin
+          job.hook(:failure)
+        rescue => error
+          say "Error when running failure callback: #{error}", 'error'
+          say error.backtrace.join("\n"), 'error'
+        ensure
+          self.class.destroy_failed_jobs ? job.destroy : job.fail!
+        end
       end
     end
 
@@ -246,13 +248,12 @@ module Delayed
     def say(text, level = DEFAULT_LOG_LEVEL)
       text = "[Worker(#{name})] #{text}"
       puts text unless @quiet
-      if logger
-        # TODO: Deprecate use of Fixnum log levels
-        if !level.is_a?(String)
-          level = Logger::Severity.constants.detect {|i| Logger::Severity.const_get(i) == level }.to_s.downcase
-        end
-        logger.send(level, "#{Time.now.strftime('%FT%T%z')}: #{text}")
+      return unless logger
+      # TODO: Deprecate use of Fixnum log levels
+      unless level.is_a?(String)
+        level = Logger::Severity.constants.detect { |i| Logger::Severity.const_get(i) == level }.to_s.downcase
       end
+      logger.send(level, "#{Time.now.strftime('%FT%T%z')}: #{text}")
     end
 
     def max_attempts(job)
@@ -271,14 +272,14 @@ module Delayed
     # If no jobs are left we return nil
     def reserve_and_run_one_job
       job = reserve_job
-      self.class.lifecycle.run_callbacks(:perform, self, job){ run(job) } if job
+      self.class.lifecycle.run_callbacks(:perform, self, job) { run(job) } if job
     end
 
     def reserve_job
       job = Delayed::Job.reserve(self)
       @failed_reserve_count = 0
       job
-    rescue Exception => error
+    rescue ::Exception => error # rubocop:disable RescueException
       say "Error while reserving job: #{error}"
       Delayed::Job.recover_from(error)
       @failed_reserve_count += 1
@@ -286,5 +287,4 @@ module Delayed
       nil
     end
   end
-
 end

data/lib/generators/delayed_job/delayed_job_generator.rb

@@ -2,11 +2,10 @@ require 'rails/generators'
 require 'delayed/compatibility'
 
 class DelayedJobGenerator < Rails::Generators::Base
-
-  self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+  source_paths << File.join(File.dirname(__FILE__), 'templates')
 
   def create_executable_file
-    template "script", "#{Delayed::Compatibility.executable_prefix}/delayed_job"
+    template 'script', "#{Delayed::Compatibility.executable_prefix}/delayed_job"
     chmod "#{Delayed::Compatibility.executable_prefix}/delayed_job", 0755
   end
 end

data/spec/delayed/backend/test.rb

@@ -25,12 +25,11 @@ module Delayed
           self.attempts = 0
           self.priority = 0
           self.id = (self.class.id += 1)
-          hash.each{|k,v| send(:"#{k}=", v)}
+          hash.each { |k, v| send(:"#{k}=", v) }
         end
 
-        @jobs = []
         def self.all
-          @jobs
+          @jobs ||= []
         end
 
         def self.count
@@ -47,29 +46,33 @@ module Delayed
           end
         end
 
-        def self.create!(*args); create(*args); end
+        def self.create!(*args)
+          create(*args)
+        end
 
         def self.clear_locks!(worker_name)
-          all.select{|j| j.locked_by == worker_name}.each {|j| j.locked_by = nil; j.locked_at = nil}
+          all.select { |j| j.locked_by == worker_name }.each do |j|
+            j.locked_by = nil
+            j.locked_at = nil
+          end
         end
 
         # Find a few candidate jobs to run (in case some immediately get locked by others).
-        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
+        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time) # rubocop:disable CyclomaticComplexity, PerceivedComplexity
           jobs = all.select do |j|
             j.run_at <= db_time_now &&
-            (j.locked_at.nil? || j.locked_at < db_time_now - max_run_time || j.locked_by == worker_name) &&
-            !j.failed?
+              (j.locked_at.nil? || j.locked_at < db_time_now - max_run_time || j.locked_by == worker_name) &&
+              !j.failed?
           end
-
-          jobs = jobs.select{|j| Worker.queues.include?(j.queue)}   if Worker.queues.any?
-          jobs = jobs.select{|j| j.priority >= Worker.min_priority} if Worker.min_priority
-          jobs = jobs.select{|j| j.priority <= Worker.max_priority} if Worker.max_priority
-          jobs.sort_by{|j| [j.priority, j.run_at]}[0..limit-1]
+          jobs.select! { |j| j.priority <= Worker.max_priority } if Worker.max_priority
+          jobs.select! { |j| j.priority >= Worker.min_priority } if Worker.min_priority
+          jobs.select! { |j| Worker.queues.include?(j.queue) } if Worker.queues.any?
+          jobs.sort_by! { |j| [j.priority, j.run_at] }[0..limit - 1]
         end
 
         # Lock this job for this worker.
         # Returns true if we have the lock, false otherwise.
-        def lock_exclusively!(max_run_time, worker)
+        def lock_exclusively!(_max_run_time, worker)
           now = self.class.db_time_now
           if locked_by != worker
             # We don't own this job so we will update the locked_by name and the locked_at
@@ -77,7 +80,7 @@ module Delayed
             self.locked_by = worker
           end
 
-          return true
+          true
         end
 
         def self.db_time_now
@@ -85,7 +88,7 @@ module Delayed
         end
 
         def update_attributes(attrs = {})
-          attrs.each{|k,v| send(:"#{k}=", v)}
+          attrs.each { |k, v| send(:"#{k}=", v) }
           save
         end
 
@@ -100,7 +103,9 @@ module Delayed
           true
         end
 
-        def save!; save; end
+        def save!
+          save
+        end
 
         def reload
           reset

data/spec/delayed/command_spec.rb

@@ -0,0 +1,57 @@
+require 'helper'
+require 'delayed/command'
+
+describe Delayed::Command do
+  describe 'parsing --pool argument' do
+    it 'should parse --pool correctly' do
+      command = Delayed::Command.new(['--pool=*:1', '--pool=test_queue:4', '--pool=mailers,misc:2'])
+
+      expect(command.worker_pools).to eq [
+        [[], 1],
+        [['test_queue'], 4],
+        [%w[mailers misc], 2]
+      ]
+    end
+
+    it 'should allow * or blank to specify any pools' do
+      command = Delayed::Command.new(['--pool=*:4'])
+      expect(command.worker_pools).to eq [
+        [[], 4],
+      ]
+
+      command = Delayed::Command.new(['--pool=:4'])
+      expect(command.worker_pools).to eq [
+        [[], 4],
+      ]
+    end
+
+    it 'should default to one worker if not specified' do
+      command = Delayed::Command.new(['--pool=mailers'])
+      expect(command.worker_pools).to eq [
+        [['mailers'], 1],
+      ]
+    end
+  end
+
+  describe 'running worker pools defined by multiple --pool arguments' do
+    it 'should run the correct worker processes' do
+      command = Delayed::Command.new(['--pool=*:1', '--pool=test_queue:4', '--pool=mailers,misc:2'])
+
+      expect(Dir).to receive(:mkdir).with('./tmp/pids').once
+
+      [
+        ['delayed_job.0', {:quiet => true, :pid_dir => './tmp/pids', :queues => []}],
+        ['delayed_job.1', {:quiet => true, :pid_dir => './tmp/pids', :queues => ['test_queue']}],
+        ['delayed_job.2', {:quiet => true, :pid_dir => './tmp/pids', :queues => ['test_queue']}],
+        ['delayed_job.3', {:quiet => true, :pid_dir => './tmp/pids', :queues => ['test_queue']}],
+        ['delayed_job.4', {:quiet => true, :pid_dir => './tmp/pids', :queues => ['test_queue']}],
+        ['delayed_job.5', {:quiet => true, :pid_dir => './tmp/pids', :queues => %w[mailers misc]}],
+        ['delayed_job.6', {:quiet => true, :pid_dir => './tmp/pids', :queues => %w[mailers misc]}]
+      ].each do |args|
+        expect(command).to receive(:run_process).with(*args).once
+      end
+
+      command.daemonize
+    end
+  end
+end