inst-jobs 2.0.0 → 3.0.0

data/lib/delayed/backend/base.rb

@@ -12,7 +12,7 @@ module Delayed
     end
 
     module Base
-      ON_HOLD_LOCKED_BY = 'on hold'
+      ON_HOLD_LOCKED_BY = "on hold"
       ON_HOLD_COUNT = 50
 
       def self.included(base)
@@ -22,9 +22,7 @@ module Delayed
       end
 
       module ClassMethods
-        attr_accessor :batches
-        attr_accessor :batch_enqueue_args
-        attr_accessor :default_priority
+        attr_accessor :batches, :batch_enqueue_args, :default_priority
 
         # Add a job to the queue
         # The first argument should be an object that respond_to?(:perform)
@@ -32,29 +30,37 @@ module Delayed
         # :priority, :run_at, :queue, :strand, :singleton
         # Example: Delayed::Job.enqueue(object, priority: 0, run_at: time, queue: queue)
         def enqueue(object,
-          priority: default_priority,
-          run_at: nil,
-          expires_at: nil,
-          queue: Delayed::Settings.queue,
-          strand: nil,
-          singleton: nil,
-          n_strand: nil,
-          max_attempts: Delayed::Settings.max_attempts,
-          **kwargs)
+                    priority: default_priority,
+                    run_at: nil,
+                    expires_at: nil,
+                    queue: Delayed::Settings.queue,
+                    strand: nil,
+                    singleton: nil,
+                    n_strand: nil,
+                    max_attempts: Delayed::Settings.max_attempts,
+                    **kwargs)
 
           unless object.respond_to?(:perform)
-            raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
+            raise ArgumentError, "Cannot enqueue items which do not respond to perform"
           end
 
+          strand ||= singleton if Settings.infer_strand_from_singleton
+
           kwargs = Settings.default_job_options.merge(kwargs)
           kwargs[:payload_object] = object
           kwargs[:priority] = priority
           kwargs[:run_at] = run_at if run_at
           kwargs[:strand] = strand
           kwargs[:max_attempts] = max_attempts
-          kwargs[:source] = Marginalia::Comment.construct_comment if defined?(Marginalia) && Marginalia::Comment.components
+          if defined?(Marginalia) && Marginalia::Comment.components
+            kwargs[:source] =
+              Marginalia::Comment.construct_comment
+          end
           kwargs[:expires_at] = expires_at
           kwargs[:queue] = queue
+          kwargs[:singleton] = singleton
+
+          raise ArgumentError, "Only one of strand or n_strand can be used" if strand && n_strand
 
           # If two parameters are given to n_strand, the first param is used
           # as the strand name for looking up the Setting, while the second
@@ -80,14 +86,15 @@ module Delayed
           end
 
           if singleton
-            kwargs[:strand] = singleton
-            job = self.create_singleton(**kwargs)
+            job = create(**kwargs)
           elsif batches && strand.nil? && run_at.nil?
             batch_enqueue_args = kwargs.slice(*self.batch_enqueue_args)
             batches[batch_enqueue_args] << kwargs
             return true
           else
-            job = self.create(**kwargs)
+            raise ArgumentError, "on_conflict can only be provided with singleton" if kwargs[:on_conflict]
+
+            job = create(**kwargs)
           end
 
           JobTracking.job_created(job)
@@ -118,10 +125,10 @@ module Delayed
 
         def check_priorities(min_priority, max_priority)
           if min_priority && min_priority < Delayed::MIN_PRIORITY
-            raise(ArgumentError, "min_priority #{min_priority} can't be less than #{Delayed::MIN_PRIORITY}")
+            raise ArgumentError, "min_priority #{min_priority} can't be less than #{Delayed::MIN_PRIORITY}"
           end
-          if max_priority && max_priority > Delayed::MAX_PRIORITY
-            raise(ArgumentError, "max_priority #{max_priority} can't be greater than #{Delayed::MAX_PRIORITY}")
+          if max_priority && max_priority > Delayed::MAX_PRIORITY # rubocop:disable Style/GuardClause
+            raise ArgumentError, "max_priority #{max_priority} can't be greater than #{Delayed::MAX_PRIORITY}"
           end
         end
 
@@ -134,13 +141,19 @@ module Delayed
 
         def processes_locked_locally(name: nil)
           name ||= Socket.gethostname rescue x
-          running_jobs.select{|job| job.locked_by.start_with?("#{name}:")}.map{|job| job.locked_by.split(':').last.to_i}
+          local_jobs = running_jobs.select do |job|
+            job.locked_by.start_with?("#{name}:")
+          end
+          local_jobs.map { |job| job.locked_by.split(":").last.to_i }
         end
 
         def unlock_orphaned_prefetched_jobs
-          horizon = db_time_now - Settings.parent_process[:prefetched_jobs_timeout] * 4
-          orphaned_jobs = running_jobs.select { |job| job.locked_by.start_with?('prefetch:') && job.locked_at < horizon }
+          horizon = db_time_now - (Settings.parent_process[:prefetched_jobs_timeout] * 4)
+          orphaned_jobs = running_jobs.select do |job|
+            job.locked_by.start_with?("prefetch:") && job.locked_at < horizon
+          end
           return 0 if orphaned_jobs.empty?
+
           unlock(orphaned_jobs)
         end
 
@@ -153,16 +166,36 @@ module Delayed
           pid_regex = pid || '(\d+)'
           regex = Regexp.new("^#{Regexp.escape(name)}:#{pid_regex}$")
           unlocked_jobs = 0
+          escaped_name = name.gsub("\\", "\\\\")
+                             .gsub("%", "\\%")
+                             .gsub("_", "\\_")
+          locked_by_like = "#{escaped_name}:%"
           running = false if pid
-          self.running_jobs.each do |job|
-            next unless job.locked_by =~ regex
-            unless pid
-              job_pid = $1.to_i
-              running = Process.kill(0, job_pid) rescue false
-            end
-            if !running
-              unlocked_jobs += 1
-              job.reschedule("process died")
+          jobs = running_jobs.limit(100)
+          jobs = pid ? jobs.where(locked_by: "#{name}:#{pid}") : jobs.where("locked_by LIKE ?", locked_by_like)
+          ignores = []
+          loop do
+            batch_scope = ignores.empty? ? jobs : jobs.where.not(id: ignores)
+            batch = batch_scope.to_a
+            break if batch.empty?
+
+            batch.each do |job|
+              unless job.locked_by =~ regex
+                ignores << job.id
+                next
+              end
+
+              unless pid
+                job_pid = $1.to_i
+                running = Process.kill(0, job_pid) rescue false
+              end
+
+              if running
+                ignores << job.id
+              else
+                unlocked_jobs += 1
+                job.reschedule("process died")
+              end
             end
           end
           unlocked_jobs
@@ -172,33 +205,37 @@ module Delayed
       def failed?
         failed_at
       end
-      alias_method :failed, :failed?
+      alias failed failed?
 
       def expired?
         expires_at && (self.class.db_time_now >= expires_at)
       end
 
+      def inferred_max_attempts
+        max_attempts || Delayed::Settings.max_attempts
+      end
+
       # Reschedule the job in the future (when a job fails).
       # Uses an exponential scale depending on the number of failed attempts.
       def reschedule(error = nil, time = nil)
         begin
           obj = payload_object
-          return_code = obj.on_failure(error) if obj && obj.respond_to?(:on_failure)
+          return_code = obj.on_failure(error) if obj.respond_to?(:on_failure)
         rescue
           # don't allow a failed deserialization to prevent rescheduling
         end
 
         self.attempts += 1 unless return_code == :unlock
 
-        if self.attempts >= (self.max_attempts || Delayed::Settings.max_attempts)
+        if self.attempts >= inferred_max_attempts
           permanent_failure error || "max attempts reached"
         elsif expired?
           permanent_failure error || "job has expired"
         else
-          time ||= self.reschedule_at
+          time ||= reschedule_at
           self.run_at = time
-          self.unlock
-          self.save!
+          unlock
+          save!
         end
       end
 
@@ -206,26 +243,24 @@ module Delayed
         begin
           # notify the payload_object of a permanent failure
           obj = payload_object
-          obj.on_permanent_failure(error) if obj && obj.respond_to?(:on_permanent_failure)
+          obj.on_permanent_failure(error) if obj.respond_to?(:on_permanent_failure)
         rescue
           # don't allow a failed deserialization to prevent destroying the job
         end
 
         # optionally destroy the object
         destroy_self = true
-        if Delayed::Worker.on_max_failures
-          destroy_self = Delayed::Worker.on_max_failures.call(self, error)
-        end
+        destroy_self = Delayed::Worker.on_max_failures.call(self, error) if Delayed::Worker.on_max_failures
 
         if destroy_self
-          self.destroy
+          destroy
         else
-          self.fail!
+          fail!
         end
       end
 
       def payload_object
-        @payload_object ||= deserialize(self['handler'].untaint)
+        @payload_object ||= deserialize(self["handler"].untaint)
       end
 
       def name
@@ -241,7 +276,7 @@ module Delayed
 
       def full_name
         obj = payload_object rescue nil
-        if obj && obj.respond_to?(:full_name)
+        if obj.respond_to?(:full_name)
           obj.full_name
         else
           name
@@ -250,14 +285,14 @@ module Delayed
 
       def payload_object=(object)
         @payload_object = object
-        self['handler'] = object.to_yaml
-        self['tag'] = if object.respond_to?(:tag)
-          object.tag
-        elsif object.is_a?(Module)
-          "#{object}.perform"
-        else
-          "#{object.class}#perform"
-        end
+        self["handler"] = object.to_yaml
+        self["tag"] = if object.respond_to?(:tag)
+                        object.tag
+                      elsif object.is_a?(Module)
+                        "#{object}.perform"
+                      else
+                        "#{object.class}#perform"
+                      end
       end
 
       # Moved into its own method so that new_relic can trace it.
@@ -284,15 +319,16 @@ module Delayed
       end
 
       def locked?
-        !!(self.locked_at || self.locked_by)
+        !!(locked_at || locked_by)
       end
 
       def reschedule_at
-        new_time = self.class.db_time_now + (attempts ** 4) + 5
+        new_time = self.class.db_time_now + (attempts**4) + 5
         begin
           if payload_object.respond_to?(:reschedule_at)
             new_time = payload_object.reschedule_at(
-                                        self.class.db_time_now, attempts)
+              self.class.db_time_now, attempts
+            )
           end
         rescue
           # TODO: just swallow errors from reschedule_at ?
@@ -304,25 +340,26 @@ module Delayed
         self.locked_by = ON_HOLD_LOCKED_BY
         self.locked_at = self.class.db_time_now
         self.attempts = ON_HOLD_COUNT
-        self.save!
+        save!
       end
 
       def unhold!
         self.locked_by = nil
         self.locked_at = nil
         self.attempts = 0
-        self.run_at = [self.class.db_time_now, self.run_at].max
+        self.run_at = [self.class.db_time_now, run_at].max
         self.failed_at = nil
-        self.save!
+        save!
       end
 
       def on_hold?
-        self.locked_by == 'on hold' && self.locked_at && self.attempts == ON_HOLD_COUNT
+        locked_by == "on hold" && locked_at && self.attempts == ON_HOLD_COUNT
       end
 
-    private
+      private
 
-      ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
+      PARSE_OBJECT_FROM_YAML = %r{!ruby/\w+:([^\s]+)}.freeze
+      private_constant :PARSE_OBJECT_FROM_YAML
 
       def deserialize(source)
         handler = nil
@@ -336,13 +373,13 @@ module Delayed
         return handler if handler.respond_to?(:perform)
 
         raise DeserializationError,
-          'Job failed to load: Unknown handler. Try to manually require the appropriate file.'
+              "Job failed to load: Unknown handler. Try to manually require the appropriate file."
       rescue TypeError, LoadError, NameError => e
         raise DeserializationError,
-          "Job failed to load: #{e.message}. Try to manually require the required file."
+              "Job failed to load: #{e.message}. Try to manually require the required file."
       rescue Psych::SyntaxError => e
-          raise DeserializationError,
-            "YAML parsing error: #{e.message}. Probably not recoverable."
+        raise DeserializationError,
+              "YAML parsing error: #{e.message}. Probably not recoverable."
       end
 
       def _yaml_deserialize(source)
@@ -350,12 +387,13 @@ module Delayed
       end
 
       def attempt_to_load_from_source(source)
-        if md = ParseObjectFromYaml.match(source)
-          md[1].constantize
-        end
+        return unless (md = PARSE_OBJECT_FROM_YAML.match(source))
+
+        md[1].constantize
       end
 
-    public
+      public
+
       def initialize_defaults
         self.queue ||= Delayed::Settings.queue
         self.run_at ||= self.class.db_time_now

data/lib/delayed/batch.rb

@@ -2,11 +2,11 @@
 
 module Delayed
   module Batch
-    class PerformableBatch < Struct.new(:mode, :items)
+    PerformableBatch = Struct.new(:mode, :items) do
       def initialize(mode, items)
         raise "unsupported mode" unless mode == :serial
-        self.mode   = mode
-        self.items  = items
+
+        super
       end
 
       def display_name
@@ -25,14 +25,16 @@ module Delayed
     end
 
     class << self
-      def serial_batch(opts = {})
-        prepare_batches(:serial, opts){ yield }
+      def serial_batch(opts = {}, &block)
+        prepare_batches(:serial, opts, &block)
       end
 
       private
+
       def prepare_batches(mode, opts)
         raise "nested batching is not supported" if Delayed::Job.batches
-        Delayed::Job.batches = Hash.new { |h,k| h[k] = Set.new }
+
+        Delayed::Job.batches = Hash.new { |h, k| h[k] = Set.new }
         batch_enqueue_args = [:queue]
         batch_enqueue_args << :priority unless opts[:priority]
         Delayed::Job.batch_enqueue_args = batch_enqueue_args
@@ -42,9 +44,9 @@ module Delayed
         Delayed::Job.batches = nil
         batch_args = opts.slice(:priority)
         batches.each do |enqueue_args, batch|
-          if batch.size == 0
-            next
-          elsif batch.size == 1
+          next if batch.size.zero?
+
+          if batch.size == 1
             args = batch.first.merge(batch_args)
             payload_object = args.delete(:payload_object)
             Delayed::Job.enqueue(payload_object, **args)

data/lib/delayed/cli.rb

@@ -1,111 +1,125 @@
 # frozen_string_literal: true
 
-require 'optparse'
+require "optparse"
 
 module Delayed
-class CLI
-  class << self
-    attr_accessor :instance
-  end
+  class CLI
+    class << self
+      attr_accessor :instance
+    end
 
-  attr_reader :config
+    attr_reader :config
 
-  def initialize(args = ARGV)
-    self.class.instance = self
+    def initialize(args = ARGV)
+      self.class.instance = self
 
-    @args = args
-    # config that will be applied on Settings and passed to the created Pool
-    @config = {}
-    # CLI options that will be kept to this class
-    @options = {
-      :config_file => Settings.default_worker_config_name,
-      :pid_folder => Settings.expand_rails_path("tmp/pids"),
-      :tail_logs => true, # only in FG mode
-    }
-  end
+      @args = args
+      # config that will be applied on Settings and passed to the created Pool
+      @config = {}
+      # CLI options that will be kept to this class
+      @options = {
+        config_file: Settings.default_worker_config_name,
+        pid_folder: Settings.expand_rails_path("tmp/pids"),
+        tail_logs: true # only in FG mode
+      }
+    end
 
-  def run
-    parse_cli_options!
-    load_and_apply_config!
-
-    command = @args.shift
-    case command
-    when 'start'
-      exit 1 if daemon.status(print: :alive) == :running
-      daemon.daemonize!
-      start
-    when 'stop'
-      daemon.stop(kill: @options[:kill])
-    when 'run'
-      start
-    when 'status'
-      if daemon.status
-        exit 0
+    def run
+      parse_cli_options!
+      load_and_apply_config!
+
+      command = @args.shift
+      case command
+      when "start"
+        exit 1 if daemon.status(print: :alive) == :running
+        daemon.daemonize!
+        start
+      when "stop"
+        daemon.stop(kill: @options[:kill])
+      when "run"
+        start
+      when "status"
+        if daemon.status
+          exit 0
+        else
+          exit 1
+        end
+      when "restart"
+        daemon.stop(kill: @options[:kill])
+        daemon.daemonize!
+        start
+      when nil
+        puts option_parser.to_s
       else
-        exit 1
+        raise("Unknown command: #{command.inspect}")
       end
-    when 'restart'
-      daemon.stop(kill: @options[:kill])
-      daemon.daemonize!
-      start
-    when nil
-      puts option_parser.to_s
-    else
-      raise("Unknown command: #{command.inspect}")
     end
-  end
 
-  def parse_cli_options!
-    option_parser.parse!(@args)
-    @options
-  end
+    def parse_cli_options!
+      option_parser.parse!(@args)
+      @options
+    end
 
-  protected
+    protected
 
-  def load_and_apply_config!
-    @config = Settings.worker_config(@options[:config_file])
-    Settings.apply_worker_config!(@config)
-  end
+    def load_and_apply_config!
+      @config = Settings.worker_config(@options[:config_file])
+      Settings.apply_worker_config!(@config)
+    end
 
-  def option_parser
-    @option_parser ||= OptionParser.new do |opts|
-      opts.banner = "Usage #{$0} <command> <options>"
-      opts.separator %{\nWhere <command> is one of:
+    def option_parser
+      @option_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage #{$0} <command> <options>"
+        opts.separator %(\nWhere <command> is one of:
   start      start the jobs daemon
   stop       stop the jobs daemon
   run        start and run in the foreground
   restart    stop and then start the jobs daemon
   status     show daemon status
-}
-
-      opts.separator "\n<options>"
-      opts.on("-c", "--config [CONFIG_PATH]", "Use alternate config file (default #{@options[:config_file]})") { |c| @options[:config_file] = c }
-      opts.on("-p", "--pid", "Use alternate folder for PID files (default #{@options[:pid_folder]})") { |p| @options[:pid_folder] = p }
-      opts.on("--no-tail", "Don't tail the logs (only affects non-daemon mode)") { @options[:tail_logs] = false }
-      opts.on("--with-prejudice", "When stopping, interrupt jobs in progress, instead of letting them drain") { @options[:kill] ||= true }
-      opts.on("--with-extreme-prejudice", "When stopping, immediately kill jobs in progress, instead of letting them drain") { @options[:kill] = 9 }
-      opts.on_tail("-h", "--help", "Show this message") { puts opts; exit }
+)
+
+        opts.separator "\n<options>"
+        opts.on("-c", "--config [CONFIG_PATH]", "Use alternate config file (default #{@options[:config_file]})") do |c|
+          @options[:config_file] = c
+        end
+        opts.on("-p", "--pid [PID_PATH]",
+                "Use alternate folder for PID files (default #{@options[:pid_folder]})") do |p|
+          @options[:pid_folder] = p
+        end
+        opts.on("--no-tail", "Don't tail the logs (only affects non-daemon mode)") { @options[:tail_logs] = false }
+        opts.on("--with-prejudice", "When stopping, interrupt jobs in progress, instead of letting them drain") do
+          @options[:kill] ||= true
+        end
+        opts.on("--with-extreme-prejudice",
+                "When stopping, immediately kill jobs in progress, instead of letting them drain") do
+          @options[:kill] = 9
+        end
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
     end
-  end
 
-  def daemon
-    @daemon ||= Delayed::Daemon.new(@options[:pid_folder])
-  end
+    def daemon
+      @daemon ||= Delayed::Daemon.new(@options[:pid_folder])
+    end
 
-  def start
-    load_rails
-    tail_rails_log unless daemon.daemonized?
-    Delayed::Pool.new(@config).start
-  end
+    def start
+      load_rails
+      tail_rails_log unless daemon.daemonized?
+      Delayed::Pool.new(@config).start
+    end
 
-  def load_rails
-    require(Settings.expand_rails_path("config/environment.rb"))
-    Dir.chdir(Rails.root)
-  end
+    def load_rails
+      require(Settings.expand_rails_path("config/environment.rb"))
+      Dir.chdir(Rails.root)
+    end
+
+    def tail_rails_log
+      return unless @options[:tail_logs]
 
-  def tail_rails_log
-    return if !@options[:tail_logs]
-    Delayed::LogTailer.new.run
+      Delayed::LogTailer.new.run
+    end
   end
 end
-end

data/lib/delayed/core_ext/kernel.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Kernel
-  def sender(i = 0)
+  def sender(idx = 0)
     frame_self = nil
     # 3. one for the block, one for this method, one for the method calling this
     # method, and _then_ we get to the self for who sent the message we want
-    RubyVM::DebugInspector.open { |dc| frame_self = dc.frame_self(3 + i) }
+    RubyVM::DebugInspector.open { |dc| frame_self = dc.frame_self(3 + idx) }
     frame_self
   end
 end