rocketjob 3.4.3 → 3.5.0

data/lib/rocket_job/plugins/cron.rb

@@ -2,129 +2,7 @@ require 'active_support/concern'
 
 module RocketJob
   module Plugins
-    # Automatically schedules the job to start based on the supplied `cron_schedule`.
-    # Once started the job will automatically restart on completion and will only run again
-    # according to the `cron_schedule`.
-    # Failed jobs are aborted so that they cannot be restarted since a new instance has already
-    # been enqueued.
-    #
-    # Include RocketJob::Plugins::Singleton to prevent multiple copies of the job from running at
-    # the same time.
-    #
-    # Unlike cron, if a job is already running, another one is not queued when the cron
-    # schedule needs another started, but rather on completion of the current job. This prevents
-    # multiple instances of the same job from running at the same time. The next instance of the
-    # job is only scheduled on completion of the current job instance.
-    #
-    # For example if the job takes 10 minutes to complete, and is scheduled to run every 5 minutes,
-    # it will only be run every 10 minutes.
-    #
-    # Their is no centralized scheduler or need to start schedulers anywhere, since the jobs
-    # can be picked up by any Rocket Job worker. Once processing is complete a new instance is then
-    # automatically scheduled based on the `cron_schedule`.
-    #
-    # A job is only queued to run at the specified `cron_schedule`, it will only run if there are workers
-    # available to run. For example if workers are busy working on higher priority jobs, then the job
-    # will only run once those jobs have completed, or their priority lowered. Additionally, while the
-    # job is queued no additional instances will be enqueued, even if the next cron interval has been reached.
-    #
-    # Notes:
-    # - The job will not be restarted if:
-    #   - A validation fails after cloning this job.
-    #   - The job has expired.
-    # - Any time the `cron_schedule` is changed, the `run_at` is automatically set before saving the changes.
-    #   - However, if the `run_at` is explicitly set then it will not be overridden.
-    # - `cron_schedule` is not a required field so that the same job class
-    #   - can be scheduled to run at regular intervals,
-    #   - and run on an ad-hoc basis with custom values.
-    # - On job failure
-    #   - a new future instance is created immediately.
-    #   - the current instance is marked as failed and its cron schedule is set to nil.
-    #     - Prevents the failed instance from creating a new future instance when it completes.
-    #
-    # Example, schedule the job to run at regular intervals:
-    #
-    # class MyCronJob < RocketJob::Job
-    #   include RocketJob::Plugins::Cron
-    #
-    #   # Set the default cron_schedule
-    #   self.cron_schedule = "* 1 * * * UTC"
-    #
-    #   def perform
-    #     puts "DONE"
-    #   end
-    # end
-    #
-    # # Queue the job for processing using the default cron_schedule specified above.
-    # MyCronJob.create!
-    #
-    #
-    # Example, a job that can run at regular intervals, and can be run for ad-hoc reporting etc.:
-    #
-    # class ReportJob < RocketJob::Job
-    #   # Do not set a default cron_schedule so that the job can also be used for ad-hoc work.
-    #   include RocketJob::Plugins::Cron
-    #
-    #   field :start_date, type: Date
-    #   field :end_date,   type: Date
-    #
-    #   def perform
-    #     # Uses `scheduled_at` to take into account any possible delays.
-    #     self.start_at ||= scheduled_at.beginning_of_week.to_date
-    #     self.end_at   ||= scheduled_at.end_of_week.to_date
-    #
-    #     puts "Running report, starting at #{start_date}, ending at #{end_date}"
-    #   end
-    # end
-    #
-    # # Queue the job for processing using a cron_schedule.
-    # # On completion the job will create a new instance to run at a future date.
-    # ReportJob.create!(cron_schedule: '* 1 * * * America/New_York')
-    #
-    # # Queue the job for processing outside of the above cron schedule.
-    # # On completion the job will _not_ create a new instance to run at a future date.
-    # job = ReportJob.create!(start_date: 30.days.ago, end_date: 10.days.ago)
-    #
-    #
-    # To prevent multiple instances of the job from running at the same time, add the singleton plug-in:
-    #   include RocketJob::Plugins::Singleton
-    #
-    # Example: Only allow one instance of this job to be active at the same time (running, queued, scheduled, or failed):
-    #
-    # class MyCronJob < RocketJob::Job
-    #   # Add `cron_schedule`
-    #   include RocketJob::Plugins::Cron
-    #   # Prevents mutiple instances from being queued or run at the same time
-    #   include RocketJob::Plugins::Singleton
-    #
-    #   # Set the default cron_schedule
-    #   self.cron_schedule = "* 1 * * * UTC"
-    #
-    #   def perform
-    #     puts "DONE"
-    #   end
-    # end
-    #
-    # Note: The cron_schedule field is formatted as follows:
-    #
-    #     *    *    *    *    *    *
-    #     ┬    ┬    ┬    ┬    ┬    ┬
-    #     │    │    │    │    │    │
-    #     │    │    │    │    │    └ Optional: Timezone, for example: 'America/New_York', 'UTC'
-    #     │    │    │    │    └───── day_of_week (0-7) (0 or 7 is Sun, or use 3-letter names)
-    #     │    │    │    └────────── month (1-12, or use 3-letter names)
-    #     │    │    └─────────────── day_of_month (1-31)
-    #     │    └──────────────────── hour (0-23)
-    #     └───────────────────────── minute (0-59)
-    #
-    # * When specifying day of week, both day 0 and day 7 is Sunday.
-    # * Ranges & Lists of numbers are allowed.
-    # * Ranges or lists of names are not allowed.
-    # * Ranges can include 'steps', so `1-9/2` is the same as `1,3,5,7,9`.
-    # * Months or days of the week can be specified by name.
-    # * Use the first three letters of the particular day or month (case doesn't matter).
-    # * The timezone is recommended to prevent any issues with possible default timezone
-    #   differences across servers, or environments.
+    # Schedule jobs to run at set intervals.
     module Cron
       extend ActiveSupport::Concern
 
@@ -176,6 +54,12 @@ module RocketJob
         run_at || created_at
       end
 
+      # Make this job run now, regardless of the cron schedule.
+      # Upon completion the job will automatically reschedule itself.
+      def run_now!
+        update_attributes(run_at: nil) if cron_schedule
+      end
+
       # Returns [Time] the next time this job will be scheduled to run at.
       #
       # Parameters
@@ -192,7 +76,6 @@ module RocketJob
         return unless cron_schedule
         self.run_at = rocket_job_cron_next_time if cron_schedule_changed? && !run_at_changed?
       end
-
     end
   end
 end

data/lib/rocket_job/plugins/document.rb

@@ -34,17 +34,15 @@ module RocketJob
       # Apply changes to this document returning the updated document from the database.
       # Allows other changes to be made on the server that will be loaded.
       def find_and_update(attrs)
-        if doc = collection.find(_id: id).find_one_and_update({'$set' => attrs}, return_document: :after)
-          # Clear out keys that are not returned during the reload from MongoDB
-          (fields.keys + embedded_relations.keys - doc.keys).each { |key| send("#{key}=", nil) }
-          @attributes = doc
-          apply_defaults
-          self
-        else
-          raise(Mongoid::Errors::DocumentNotFound.new(self.class, id))
-        end
+        doc = collection.find(_id: id).find_one_and_update({'$set' => attrs}, return_document: :after)
+        raise(Mongoid::Errors::DocumentNotFound.new(self.class, id)) unless doc
+
+        # Clear out keys that are not returned during the reload from MongoDB
+        (fields.keys + embedded_relations.keys - doc.keys).each { |key| send("#{key}=", nil) }
+        @attributes = doc
+        apply_defaults
+        self
       end
-
     end
   end
 end

data/lib/rocket_job/plugins/job/callbacks.rb

@@ -84,7 +84,6 @@ module RocketJob
             set_callback(:perform, :around, *filters, &blk)
           end
         end
-
       end
     end
   end

data/lib/rocket_job/plugins/job/logger.rb

@@ -28,7 +28,6 @@ module RocketJob
             &block
           )
         end
-
       end
     end
   end

data/lib/rocket_job/plugins/job/model.rb

@@ -9,7 +9,7 @@ module RocketJob
 
         included do
           # Fields that are end user editable.
-          # For example are editable in Rocket Job Mission Control.
+          # For example are editable in Rocket Job Web Interface.
           class_attribute :user_editable_fields, instance_accessor: false
           self.user_editable_fields = []
 
@@ -156,7 +156,7 @@ module RocketJob
           # Scope for queued jobs that can run now
           # I.e. Queued jobs excluding scheduled jobs
           def queued_now
-            queued.or({:run_at => nil}, {:run_at.lte => Time.now})
+            queued.or({run_at: nil}, :run_at.lte => Time.now)
           end
 
           # Defines all the fields that are accessible on the Document
@@ -182,10 +182,8 @@ module RocketJob
             end
             if options.delete(:class_attribute) == true
               class_attribute(name, instance_accessor: false)
-              if options.has_key?(:default)
-                public_send("#{name}=", options[:default])
-              end
-              options[:default] = lambda { self.class.public_send(name) }
+              public_send("#{name}=", options[:default]) if options.key?(:default)
+              options[:default] = -> { self.class.public_send(name) }
             end
             if options.delete(:copy_on_restart) == true
               self.rocket_job_restart_attributes += [name.to_sym] unless rocket_job_restart_attributes.include?(name.to_sym)
@@ -248,7 +246,7 @@ module RocketJob
         # Return [true|false] whether this job is sleeping.
         # I.e. No workers currently working on this job even if it is running.
         def sleeping?
-          running? && (worker_count == 0)
+          running? && worker_count.zero?
         end
 
         # Returns [Integer] the number of workers currently working on this job.
@@ -263,32 +261,31 @@ module RocketJob
 
         # Returns [Hash] status of this job
         def as_json
-          attrs = serializable_hash(methods: [:seconds, :duration])
+          attrs = serializable_hash(methods: %i[seconds duration])
           attrs.delete('result') unless collect_output?
-          attrs.delete('failure_count') unless failure_count > 0
-          case
-          when queued?
+          attrs.delete('failure_count') unless failure_count.positive?
+          if queued?
             attrs.delete('started_at')
             attrs.delete('completed_at')
             attrs.delete('result')
             attrs
-          when running?
+          elsif running?
             attrs.delete('completed_at')
             attrs.delete('result')
             attrs
-          when completed?
+          elsif completed?
             attrs.delete('percent_complete')
             attrs
-          when paused?
+          elsif paused?
             attrs.delete('completed_at')
             attrs.delete('result')
             # Ensure 'paused_at' appears first in the hash
             {'paused_at' => completed_at}.merge(attrs)
-          when aborted?
+          elsif aborted?
             attrs.delete('completed_at')
             attrs.delete('result')
             {'aborted_at' => completed_at}.merge(attrs)
-          when failed?
+          elsif failed?
             attrs.delete('completed_at')
             attrs.delete('result')
             {'failed_at' => completed_at}.merge(attrs)
@@ -302,10 +299,9 @@ module RocketJob
           h = as_json
           h.delete('seconds')
           h.dup.each_pair do |k, v|
-            case
-            when v.is_a?(Time)
+            if v.is_a?(Time)
               h[k] = v.in_time_zone(time_zone).to_s
-            when v.is_a?(BSON::ObjectId)
+            elsif v.is_a?(BSON::ObjectId)
               h[k] = v.to_s
             end
           end
@@ -317,7 +313,6 @@ module RocketJob
           return false unless worker_name.present? && server_name.present?
           worker_name.start_with?(server_name)
         end
-
       end
     end
   end

data/lib/rocket_job/plugins/job/persistence.rb

@@ -10,8 +10,6 @@ module RocketJob
         included do
           # Store all job types in this collection
           store_in collection: 'rocket_job.jobs'
-
-          after_initialize :remove_arguments
         end
 
         module ClassMethods
@@ -84,11 +82,11 @@ module RocketJob
             end
 
             # Calculate :queued_now and :scheduled if there are queued jobs
-            if queued_count = counts[:queued]
+            if (queued_count = counts[:queued])
               scheduled_count = RocketJob::Job.scheduled.count
-              if scheduled_count > 0
+              if scheduled_count.positive?
                 queued_now_count    = queued_count - scheduled_count
-                counts[:queued_now] = queued_count - scheduled_count if queued_now_count > 0
+                counts[:queued_now] = queued_count - scheduled_count if queued_now_count.positive?
                 counts[:scheduled]  = scheduled_count
               else
                 counts[:queued_now] = queued_count
@@ -112,14 +110,6 @@ module RocketJob
             self
           end
         end
-
-        private
-
-        # Remove old style arguments that were stored as an array
-        def remove_arguments
-          attributes.delete('arguments') unless respond_to?('arguments='.to_sym)
-        end
-
       end
     end
   end

data/lib/rocket_job/plugins/job/state_machine.rb

@@ -78,7 +78,7 @@ module RocketJob
 
             event :requeue do
               transitions from:  :running, to: :queued,
-                          if:    -> server_name { worker_on_server?(server_name) },
+                          if:    ->(server_name) { worker_on_server?(server_name) },
                           after: :rocket_job_clear_started_at
             end
           end
@@ -165,7 +165,6 @@ module RocketJob
           destroy if destroy_on_complete && !new_record?
         end
       end
-
     end
   end
 end

data/lib/rocket_job/plugins/job/throttle.rb

@@ -47,21 +47,28 @@ module RocketJob
           #
           # Note: Throttles are executed in the order they are defined.
           def define_throttle(method_name, filter: :throttle_filter_class)
-            raise(ArgumentError, "Filter for #{method_name} must be a Symbol or Proc") unless filter.is_a?(Symbol) || filter.is_a?(Proc)
-            raise(ArgumentError, "Cannot define #{method_name} twice, undefine previous throttle first") if has_throttle?(method_name)
+            unless filter.is_a?(Symbol) || filter.is_a?(Proc)
+              raise(ArgumentError, "Filter for #{method_name} must be a Symbol or Proc")
+            end
+            if throttle?(method_name)
+              raise(ArgumentError, "Cannot define #{method_name} twice, undefine previous throttle first")
+            end
 
             self.rocket_job_throttles += [ThrottleDefinition.new(method_name, filter)]
           end
 
           # Undefine a previously defined throttle
-          def undefine_throttle(method_name)
-            rocket_job_throttles.delete_if { |throttle| throttle.method_name }
+          def undefine_throttle(_method_name)
+            rocket_job_throttles.delete_if(&:method_name)
           end
 
           # Has a throttle been defined?
-          def has_throttle?(method_name)
+          def throttle?(method_name)
             rocket_job_throttles.find { |throttle| throttle.method_name == method_name }
           end
+
+          # DEPRECATED
+          alias has_throttle? throttle?
         end
 
         # Default throttle to use when the throttle is exceeded.
@@ -86,17 +93,14 @@ module RocketJob
         def rocket_job_evaluate_throttles
           rocket_job_throttles.each do |throttle|
             # Throttle exceeded?
-            if send(throttle.method_name)
-              logger.debug { "Throttle: #{throttle.method_name} has been exceeded. #{self.class.name}:#{id}" }
-              filter = throttle.filter
-              return filter.is_a?(Proc) ? filter.call(self) : send(filter)
-            end
+            next unless send(throttle.method_name)
+            logger.debug { "Throttle: #{throttle.method_name} has been exceeded. #{self.class.name}:#{id}" }
+            filter = throttle.filter
+            return filter.is_a?(Proc) ? filter.call(self) : send(filter)
           end
           nil
         end
-
       end
-
     end
   end
 end

data/lib/rocket_job/plugins/job/worker.rb

@@ -10,15 +10,15 @@ module RocketJob
         module ClassMethods
           # Run this job now.
           #
-          # The job is not saved to the database since it is processed entriely in memory
+          # The job is not saved to the database since it is processed entirely in memory
           # As a result before_save and before_destroy callbacks will not be called.
           # Validations are still called however prior to calling #perform
           #
           # Note:
           # - Only batch throttles are checked when perform_now is called.
-          def perform_now(args, &block)
+          def perform_now(args)
             job = new(args)
-            block.call(job) if block
+            yield(job) if block_given?
             job.perform_now
             job
           end
@@ -38,14 +38,13 @@ module RocketJob
           #   If a job is in queued state it will be started
           def rocket_job_next_job(worker_name, filter = {})
             while (job = rocket_job_retrieve(worker_name, filter))
-              case
-              when job.running?
-                # Batch Job
-                return job
-              when job.expired?
+              # Batch Job?
+              return job if job.running?
+
+              if job.expired?
                 job.rocket_job_fail_on_exception!(worker_name) { job.destroy }
                 logger.info "Destroyed expired job #{job.class.name}, id:#{job.id}"
-              when new_filter = job.send(:rocket_job_evaluate_throttles)
+              elsif (new_filter = job.send(:rocket_job_evaluate_throttles))
                 rocket_job_merge_filter(filter, new_filter)
                 # Restore retrieved job so that other workers can process it later
                 job.set(worker_name: nil, state: :queued)
@@ -62,7 +61,7 @@ module RocketJob
           # Requeues all jobs that were running on a server that died
           def requeue_dead_server(server_name)
             # Need to requeue paused, failed since user may have transitioned job before it finished
-            where(:state.in => [:running, :paused, :failed]).each do |job|
+            where(:state.in => %i[running paused failed]).each do |job|
               job.requeue!(server_name) if job.may_requeue?(server_name)
             end
           end
@@ -73,7 +72,7 @@ module RocketJob
               perform_now(args, &block)
             else
               job = new(args)
-              block.call(job) if block
+              yield(job) if block
               job.save!
               job
             end
@@ -84,7 +83,7 @@ module RocketJob
           def rocket_job_merge_filter(target, source)
             source.each_pair do |k, v|
               target[k] =
-                if previous = target[k]
+                if (previous = target[k])
                   v.is_a?(Array) ? previous + v : v
                 else
                   v
@@ -136,12 +135,10 @@ module RocketJob
             self.exception        = JobException.from_exception(exc)
             exception.worker_name = worker_name
             save! unless new_record? || destroyed?
+          elsif new_record? || destroyed?
+            fail(worker_name, exc)
           else
-            if new_record? || destroyed?
-              fail(worker_name, exc)
-            else
-              fail!(worker_name, exc)
-            end
+            fail!(worker_name, exc)
           end
           raise exc if re_raise_exceptions
         end
@@ -154,7 +151,7 @@ module RocketJob
         # is set in the job itself.
         #
         # Thread-safe, can be called by multiple threads at the same time
-        def rocket_job_work(worker, re_raise_exceptions = false, filter = nil)
+        def rocket_job_work(worker, re_raise_exceptions = false, _filter = nil)
           raise(ArgumentError, 'Job must be started before calling #rocket_job_work') unless running?
           rocket_job_fail_on_exception!(worker.name, re_raise_exceptions) do
             if _perform_callbacks.empty?
@@ -186,7 +183,6 @@ module RocketJob
           return [] if !running? || (server_name && !worker_on_server?(server_name))
           [ActiveWorker.new(worker_name, started_at, self)]
         end
-
       end
     end
   end