delayed_job 4.0.2 → 4.0.3

data/lib/delayed/command.rb

@@ -1,15 +1,17 @@
-begin
-  require 'daemons'
-rescue LoadError
-  raise "You need to add gem 'daemons' to your Gemfile if you wish to use it."
+unless ENV['RAILS_ENV'] == 'test'
+  begin
+    require 'daemons'
+  rescue LoadError
+    raise "You need to add gem 'daemons' to your Gemfile if you wish to use it."
+  end
 end
 require 'optparse'
 
 module Delayed
-  class Command
-    attr_accessor :worker_count
+  class Command # rubocop:disable ClassLength
+    attr_accessor :worker_count, :worker_pools
 
-    def initialize(args)
+    def initialize(args) # rubocop:disable MethodLength
       @options = {
         :quiet => true,
         :pid_dir => "#{Rails.root}/tmp/pids"
@@ -18,88 +20,106 @@ module Delayed
       @worker_count = 1
       @monitor = false
 
-      opts = OptionParser.new do |opts|
-        opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
+      opts = OptionParser.new do |opt|
+        opt.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options] start|stop|restart|run"
 
-        opts.on('-h', '--help', 'Show this message') do
-          puts opts
+        opt.on('-h', '--help', 'Show this message') do
+          puts opt
           exit 1
         end
-        opts.on('-e', '--environment=NAME', 'Specifies the environment to run this delayed jobs under (test/development/production).') do |e|
-          STDERR.puts "The -e/--environment option has been deprecated and has no effect. Use RAILS_ENV and see http://github.com/collectiveidea/delayed_job/issues/#issue/7"
+        opt.on('-e', '--environment=NAME', 'Specifies the environment to run this delayed jobs under (test/development/production).') do |_e|
+          STDERR.puts 'The -e/--environment option has been deprecated and has no effect. Use RAILS_ENV and see http://github.com/collectiveidea/delayed_job/issues/#issue/7'
         end
-        opts.on('--min-priority N', 'Minimum priority of jobs to run.') do |n|
+        opt.on('--min-priority N', 'Minimum priority of jobs to run.') do |n|
           @options[:min_priority] = n
         end
-        opts.on('--max-priority N', 'Maximum priority of jobs to run.') do |n|
+        opt.on('--max-priority N', 'Maximum priority of jobs to run.') do |n|
           @options[:max_priority] = n
         end
-        opts.on('-n', '--number_of_workers=workers', "Number of unique workers to spawn") do |worker_count|
-          @worker_count = worker_count.to_i rescue 1
+        opt.on('-n', '--number_of_workers=workers', 'Number of unique workers to spawn') do |worker_count|
+          @worker_count = worker_count.to_i rescue 1 # rubocop:disable RescueModifier
         end
-        opts.on('--pid-dir=DIR', 'Specifies an alternate directory in which to store the process ids.') do |dir|
+        opt.on('--pid-dir=DIR', 'Specifies an alternate directory in which to store the process ids.') do |dir|
           @options[:pid_dir] = dir
         end
-        opts.on('-i', '--identifier=n', 'A numeric identifier for the worker.') do |n|
+        opt.on('-i', '--identifier=n', 'A numeric identifier for the worker.') do |n|
           @options[:identifier] = n
         end
-        opts.on('-m', '--monitor', 'Start monitor process.') do
+        opt.on('-m', '--monitor', 'Start monitor process.') do
           @monitor = true
         end
-        opts.on('--sleep-delay N', "Amount of time to sleep when no jobs are found") do |n|
+        opt.on('--sleep-delay N', 'Amount of time to sleep when no jobs are found') do |n|
           @options[:sleep_delay] = n.to_i
         end
-        opts.on('--read-ahead N', "Number of jobs from the queue to consider") do |n|
+        opt.on('--read-ahead N', 'Number of jobs from the queue to consider') do |n|
           @options[:read_ahead] = n
         end
-        opts.on('-p', '--prefix NAME', "String to be prefixed to worker process names") do |prefix|
+        opt.on('-p', '--prefix NAME', 'String to be prefixed to worker process names') do |prefix|
           @options[:prefix] = prefix
         end
-        opts.on('--queues=queues', "Specify which queue DJ must look up for jobs") do |queues|
+        opt.on('--queues=queues', 'Specify which queue DJ must look up for jobs') do |queues|
           @options[:queues] = queues.split(',')
         end
-        opts.on('--queue=queue', "Specify which queue DJ must look up for jobs") do |queue|
+        opt.on('--queue=queue', 'Specify which queue DJ must look up for jobs') do |queue|
           @options[:queues] = queue.split(',')
         end
-        opts.on('--exit-on-complete', "Exit when no more jobs are available to run. This will exit if all jobs are scheduled to run in the future.") do
+        opt.on('--pool=queue1[,queue2][:worker_count]', 'Specify queues and number of workers for a worker pool') do |pool|
+          parse_worker_pool(pool)
+        end
+        opt.on('--exit-on-complete', 'Exit when no more jobs are available to run. This will exit if all jobs are scheduled to run in the future.') do
           @options[:exit_on_complete] = true
         end
       end
       @args = opts.parse!(args)
     end
 
-    def daemonize
+    def daemonize # rubocop:disable PerceivedComplexity
       dir = @options[:pid_dir]
-      Dir.mkdir(dir) unless File.exists?(dir)
+      Dir.mkdir(dir) unless File.exist?(dir)
 
-      if @worker_count > 1 && @options[:identifier]
-        raise ArgumentError, 'Cannot specify both --number-of-workers and --identifier'
-      elsif @worker_count == 1 && @options[:identifier]
-        process_name = "delayed_job.#{@options[:identifier]}"
-        run_process(process_name, dir)
+      if worker_pools
+        setup_pools
+      elsif @options[:identifier]
+        if worker_count > 1
+          raise ArgumentError, 'Cannot specify both --number-of-workers and --identifier'
+        else
+          run_process("delayed_job.#{@options[:identifier]}", @options)
+        end
       else
         worker_count.times do |worker_index|
-          process_name = worker_count == 1 ? "delayed_job" : "delayed_job.#{worker_index}"
-          run_process(process_name, dir)
+          process_name = worker_count == 1 ? 'delayed_job' : "delayed_job.#{worker_index}"
+          run_process(process_name, @options)
+        end
+      end
+    end
+
+    def setup_pools
+      worker_index = 0
+      @worker_pools.each do |queues, worker_count|
+        options = @options.merge(:queues => queues)
+        worker_count.times do
+          process_name = "delayed_job.#{worker_index}"
+          run_process(process_name, options)
+          worker_index += 1
         end
       end
     end
 
-    def run_process(process_name, dir)
+    def run_process(process_name, options = {})
       Delayed::Worker.before_fork
-      Daemons.run_proc(process_name, :dir => dir, :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*args|
-        $0 = File.join(@options[:prefix], process_name) if @options[:prefix]
+      Daemons.run_proc(process_name, :dir => options[:pid_dir], :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*_args|
+        $0 = File.join(options[:prefix], process_name) if @options[:prefix]
         run process_name
       end
     end
 
-    def run(worker_name = nil)
+    def run(worker_name = nil, options = {})
       Dir.chdir(Rails.root)
 
       Delayed::Worker.after_fork
       Delayed::Worker.logger ||= Logger.new(File.join(Rails.root, 'log', 'delayed_job.log'))
 
-      worker = Delayed::Worker.new(@options)
+      worker = Delayed::Worker.new(options)
       worker.name_prefix = "#{worker_name} "
       worker.start
     rescue => e
@@ -107,5 +127,20 @@ module Delayed
       STDERR.puts e.message
       exit 1
     end
+
+  private
+
+    def parse_worker_pool(pool)
+      @worker_pools ||= []
+
+      queues, worker_count = pool.split(':')
+      if ['*', '', nil].include?(queues)
+        queues = []
+      else
+        queues = queues.split(',')
+      end
+      worker_count = (worker_count || 1).to_i rescue 1
+      @worker_pools << [queues, worker_count]
+    end
   end
 end

data/lib/delayed/exceptions.rb

@@ -3,7 +3,8 @@ require 'timeout'
 module Delayed
   class WorkerTimeout < Timeout::Error
     def message
-      "#{super} (Delayed::Worker.max_run_time is only #{Delayed::Worker.max_run_time.to_i} seconds)"
+      seconds = Delayed::Worker.max_run_time.to_i
+      "#{super} (Delayed::Worker.max_run_time is only #{seconds} second#{seconds == 1 ? '' : 's'})"
     end
   end
 

data/lib/delayed/lifecycle.rb

@@ -13,7 +13,9 @@ module Delayed
     }
 
     def initialize
-      @callbacks = EVENTS.keys.inject({}) { |hash, e| hash[e] = Callback.new; hash }
+      @callbacks = EVENTS.keys.each_with_object({}) do |e, hash|
+        hash[e] = Callback.new
+      end
     end
 
     def before(event, &block)
@@ -29,7 +31,7 @@ module Delayed
     end
 
     def run_callbacks(event, *args, &block)
-      missing_callback(event) unless @callbacks.has_key?(event)
+      missing_callback(event) unless @callbacks.key?(event)
 
       unless EVENTS[event].size == args.size
         raise ArgumentError, "Callback #{event} expects #{EVENTS[event].size} parameter(s): #{EVENTS[event].join(', ')}"
@@ -38,17 +40,16 @@ module Delayed
       @callbacks[event].execute(*args, &block)
     end
 
-    private
-
-      def add(type, event, &block)
-        missing_callback(event) unless @callbacks.has_key?(event)
+  private
 
-        @callbacks[event].add(type, &block)
-      end
+    def add(type, event, &block)
+      missing_callback(event) unless @callbacks.key?(event)
+      @callbacks[event].add(type, &block)
+    end
 
-      def missing_callback(event)
-        raise InvalidCallback, "Unknown callback event: #{event}"
-      end
+    def missing_callback(event)
+      raise InvalidCallback, "Unknown callback event: #{event}"
+    end
   end
 
   class Callback

data/lib/delayed/message_sending.rb

@@ -17,31 +17,30 @@ module Delayed
     def delay(options = {})
       DelayProxy.new(PerformableMethod, self, options)
     end
-    alias __delay__ delay
+    alias_method :__delay__, :delay
 
     def send_later(method, *args)
-      warn "[DEPRECATION] `object.send_later(:method)` is deprecated. Use `object.delay.method"
+      warn '[DEPRECATION] `object.send_later(:method)` is deprecated. Use `object.delay.method'
       __delay__.__send__(method, *args)
     end
 
     def send_at(time, method, *args)
-      warn "[DEPRECATION] `object.send_at(time, :method)` is deprecated. Use `object.delay(:run_at => time).method"
+      warn '[DEPRECATION] `object.send_at(time, :method)` is deprecated. Use `object.delay(:run_at => time).method'
       __delay__(:run_at => time).__send__(method, *args)
     end
 
     module ClassMethods
       def handle_asynchronously(method, opts = {})
-        aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+        aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1 # rubocop:disable PerlBackrefs
         with_method, without_method = "#{aliased_method}_with_delay#{punctuation}", "#{aliased_method}_without_delay#{punctuation}"
         define_method(with_method) do |*args|
           curr_opts = opts.clone
           curr_opts.each_key do |key|
-            if (val = curr_opts[key]).is_a?(Proc)
-              curr_opts[key] = if val.arity == 1
-                val.call(self)
-              else
-                val.call
-              end
+            next unless (val = curr_opts[key]).is_a?(Proc)
+            curr_opts[key] = if val.arity == 1
+              val.call(self)
+            else
+              val.call
             end
           end
           delay(curr_opts).__send__(without_method, *args)

data/lib/delayed/performable_mailer.rb

@@ -15,7 +15,7 @@ module Delayed
 end
 
 Mail::Message.class_eval do
-  def delay(*args)
-    raise RuntimeError, "Use MyMailer.delay.mailer_action(args) to delay sending of emails."
+  def delay(*_args)
+    raise 'Use MyMailer.delay.mailer_action(args) to delay sending of emails.'
   end
 end

data/lib/delayed/performable_method.rb

@@ -10,7 +10,7 @@ module Delayed
       raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
 
       if object.respond_to?(:persisted?) && !object.persisted?
-        raise(ArgumentError, 'Jobs cannot be created for non-persisted records')
+        raise ArgumentError, 'Jobs cannot be created for non-persisted records'
       end
 
       self.object       = object
@@ -30,7 +30,7 @@ module Delayed
       object.send(symbol, *args)
     end
 
-    def respond_to?(symbol, include_private=false)
+    def respond_to?(symbol, include_private = false)
       super || object.respond_to?(symbol, include_private)
     end
   end

data/lib/delayed/psych_ext.rb

@@ -1,133 +1,69 @@
 if defined?(ActiveRecord)
   ActiveRecord::Base.class_eval do
+    # rubocop:disable BlockNesting
     if instance_methods.include?(:encode_with)
       def encode_with_override(coder)
         encode_with_without_override(coder)
-        coder.tag = "!ruby/ActiveRecord:#{self.class.name}"
+        coder.tag = "!ruby/ActiveRecord:#{self.class.name}" if coder.respond_to?(:tag=)
       end
       alias_method :encode_with_without_override, :encode_with
       alias_method :encode_with, :encode_with_override
     else
       def encode_with(coder)
-        coder["attributes"] = attributes
-        coder.tag = "!ruby/ActiveRecord:#{self.class.name}"
+        coder['attributes'] = attributes
+        coder.tag = "!ruby/ActiveRecord:#{self.class.name}" if coder.respond_to?(:tag=)
       end
     end
   end
 end
 
-class Delayed::PerformableMethod
-  # serialize to YAML
-  def encode_with(coder)
-    coder.map = {
-      "object" => object,
-      "method_name" => method_name,
-      "args" => args
-    }
+module Delayed
+  class PerformableMethod
+    # serialize to YAML
+    def encode_with(coder)
+      coder.map = {
+        'object' => object,
+        'method_name' => method_name,
+        'args' => args
+      }
+    end
   end
 end
 
 module Psych
   module Visitors
-    class YAMLTree
-      def visit_Class(klass)
-        @emitter.scalar klass.name, nil, '!ruby/class', false, false, Nodes::Scalar::SINGLE_QUOTED
-      end
-    end
-
     class ToRuby
-      def visit_Psych_Nodes_Scalar(o)
-        @st[o.anchor] = o.value if o.anchor
-
-        if klass = Psych.load_tags[o.tag]
-          instance = klass.allocate
-
-          if instance.respond_to?(:init_with)
-            coder = Psych::Coder.new(o.tag)
-            coder.scalar = o.value
-            instance.init_with coder
-          end
-
-          return instance
-        end
-
-        return o.value if o.quoted
-        return @ss.tokenize(o.value) unless o.tag
-
-        case o.tag
-        when '!binary', 'tag:yaml.org,2002:binary'
-          o.value.unpack('m').first
-        when '!str', 'tag:yaml.org,2002:str'
-          o.value
-        when "!ruby/object:DateTime"
-          require 'date'
-          @ss.parse_time(o.value).to_datetime
-        when "!ruby/object:Complex"
-          Complex(o.value)
-        when "!ruby/object:Rational"
-          Rational(o.value)
-        when "!ruby/class", "!ruby/module"
-          resolve_class o.value
-        when "tag:yaml.org,2002:float", "!float"
-          Float(@ss.tokenize(o.value))
-        when "!ruby/regexp"
-          o.value =~ /^\/(.*)\/([mixn]*)$/
-          source  = $1
-          options = 0
-          lang    = nil
-          ($2 || '').split('').each do |option|
-            case option
-            when 'x' then options |= Regexp::EXTENDED
-            when 'i' then options |= Regexp::IGNORECASE
-            when 'm' then options |= Regexp::MULTILINE
-            when 'n' then options |= Regexp::NOENCODING
-            else lang = option
-            end
-          end
-          Regexp.new(*[source, options, lang].compact)
-        when "!ruby/range"
-          args = o.value.split(/([.]{2,3})/, 2).map { |s|
-            accept Nodes::Scalar.new(s)
-          }
-          args.push(args.delete_at(1) == '...')
-          Range.new(*args)
-        when /^!ruby\/sym(bol)?:?(.*)?$/
-          o.value.to_sym
-        else
-          @ss.tokenize o.value
-        end
-      end
-
-      def visit_Psych_Nodes_Mapping_with_class(object)
+      def visit_Psych_Nodes_Mapping_with_class(object) # rubocop:disable CyclomaticComplexity, MethodName
         return revive(Psych.load_tags[object.tag], object) if Psych.load_tags[object.tag]
 
         case object.tag
         when /^!ruby\/ActiveRecord:(.+)$/
-          klass = resolve_class($1)
+          klass = resolve_class(Regexp.last_match[1])
           payload = Hash[*object.children.map { |c| accept c }]
-          id = payload["attributes"][klass.primary_key]
+          id = payload['attributes'][klass.primary_key]
           begin
             klass.unscoped.find(id)
-          rescue ActiveRecord::RecordNotFound
-            raise Delayed::DeserializationError
+          rescue ActiveRecord::RecordNotFound => error
+            raise Delayed::DeserializationError, "ActiveRecord::RecordNotFound, class: #{klass}, primary key: #{id} (#{error.message})"
           end
         when /^!ruby\/Mongoid:(.+)$/
-          klass = resolve_class($1)
+          klass = resolve_class(Regexp.last_match[1])
           payload = Hash[*object.children.map { |c| accept c }]
+          id = payload['attributes']['_id']
           begin
-            klass.find(payload["attributes"]["_id"])
-          rescue Mongoid::Errors::DocumentNotFound
-            raise Delayed::DeserializationError
+            klass.find(id)
+          rescue Mongoid::Errors::DocumentNotFound => error
+            raise Delayed::DeserializationError, "Mongoid::Errors::DocumentNotFound, class: #{klass}, primary key: #{id} (#{error.message})"
           end
         when /^!ruby\/DataMapper:(.+)$/
-          klass = resolve_class($1)
+          klass = resolve_class(Regexp.last_match[1])
           payload = Hash[*object.children.map { |c| accept c }]
           begin
-            primary_keys = klass.properties.select { |p| p.key? }
+            primary_keys = klass.properties.select(&:key?)
             key_names = primary_keys.map { |p| p.name.to_s }
-            klass.get!(*key_names.map { |k| payload["attributes"][k] })
-          rescue DataMapper::ObjectNotFoundError
-            raise Delayed::DeserializationError
+            klass.get!(*key_names.map { |k| payload['attributes'][k] })
+          rescue DataMapper::ObjectNotFoundError => error
+            raise Delayed::DeserializationError, "DataMapper::ObjectNotFoundError, class: #{klass} (#{error.message})"
           end
         else
           visit_Psych_Nodes_Mapping_without_class(object)