rocketjob 1.0.0 → 1.1.0

data/lib/rocket_job/heartbeat.rb

@@ -8,6 +8,7 @@ module RocketJob
 
     embedded_in :worker
 
+    # @formatter:off
     # Time of the last heartbeat received from this worker
     key :updated_at,                 Time
 
@@ -39,6 +40,8 @@ module RocketJob
 
     # If available
     key :load_average,               Float
+    # @formatter:on
+
   end
 end
 

data/lib/rocket_job/job.rb

@@ -15,6 +15,7 @@ module RocketJob
     # User definable attributes
     #
     # The following attributes are set when the job is created
+    # @formatter:off
 
     # Description for this job instance
     key :description,             String
@@ -128,6 +129,7 @@ module RocketJob
     #                       -> :failed     -> :running
     #                                      -> :aborted
     #                       -> :aborted
+    #                       -> :queued (when a worker dies)
     #           -> :aborted
     aasm column: :state do
       # Job has been created and is queued for processing ( Initial state )
@@ -167,7 +169,7 @@ module RocketJob
       end
 
       event :retry, before: :before_retry do
-        transitions from: :failed, to: :running
+        transitions from: :failed, to: :queued
       end
 
       event :pause, before: :before_pause do
@@ -184,39 +186,40 @@ module RocketJob
         transitions from: :failed,  to: :aborted
         transitions from: :paused,  to: :aborted
       end
+
+      event :requeue, before: :before_requeue do
+        transitions from: :running, to: :queued
+      end
     end
+    # @formatter:on
 
     # Create indexes
     def self.create_indexes
       # Used by find_and_modify in .next_job
-      ensure_index({ state:1, run_at: 1, priority: 1, created_at: 1, sub_state: 1}, background: true)
+      ensure_index({state: 1, run_at: 1, priority: 1, created_at: 1, sub_state: 1}, background: true)
       # Remove outdated index if present
-      drop_index("state_1_priority_1_created_at_1_sub_state_1") rescue nil
+      drop_index('state_1_priority_1_created_at_1_sub_state_1') rescue nil
       # Used by Mission Control
       ensure_index [[:created_at, 1]]
     end
 
-    # Requeue all jobs for the specified dead worker
+    # Requeues all jobs that were running on worker that died
     def self.requeue_dead_worker(worker_name)
-      collection.update(
-        { 'worker_name' => worker_name, 'state' => :running },
-        { '$unset' => { 'worker_name' => true, 'started_at' => true }, '$set' => { 'state' => :queued } },
-        multi: true
-      )
+      running.each { |job| job.requeue!(worker_name) }
     end
 
     # Pause all running jobs
     def self.pause_all
-      where(state: 'running').each { |job| job.pause! }
+      running.each(&:pause!)
     end
 
     # Resume all paused jobs
     def self.resume_all
-      where(state: 'paused').each { |job| job.resume! }
+      paused.each(&:resume!)
     end
 
     # Returns the number of required arguments for this job
-    def self.argument_count(method=:perform)
+    def self.argument_count(method = :perform)
       instance_method(method).arity
     end
 
@@ -241,7 +244,7 @@ module RocketJob
 
     # Returns a human readable duration the job has taken
     def duration
-      seconds_as_duration(seconds)
+      RocketJob.seconds_as_duration(seconds)
     end
 
     # A job has expired if the expiry time has passed before it is started
@@ -262,57 +265,94 @@ module RocketJob
         attrs.delete('completed_at')
         attrs.delete('result')
         # Ensure 'paused_at' appears first in the hash
-        { 'paused_at' => completed_at }.merge(attrs)
+        {'paused_at' => completed_at}.merge(attrs)
       when aborted?
         attrs.delete('completed_at')
         attrs.delete('result')
-        { 'aborted_at' => completed_at }.merge(attrs)
+        {'aborted_at' => completed_at}.merge(attrs)
       when failed?
         attrs.delete('completed_at')
         attrs.delete('result')
-        { 'failed_at' => completed_at }.merge(attrs)
+        {'failed_at' => completed_at}.merge(attrs)
       else
         attrs
       end
     end
 
-    def status(time_zone='Eastern Time (US & Canada)')
+    def status(time_zone = 'Eastern Time (US & Canada)')
       h = as_json
       h.delete('seconds')
       h.delete('perform_method') if h['perform_method'] == :perform
-      h.dup.each_pair do |k,v|
+      h.dup.each_pair do |k, v|
         case
-        when v.kind_of?(Time)
+        when v.is_a?(Time)
           h[k] = v.in_time_zone(time_zone).to_s
-        when v.kind_of?(BSON::ObjectId)
+        when v.is_a?(BSON::ObjectId)
           h[k] = v.to_s
         end
       end
       h
     end
 
-    # TODO Jobs are not currently automatically retried. Is there a need?
-    def seconds_to_delay(count)
-      # TODO Consider lowering the priority automatically after every retry?
-      # Same basic formula for calculating retry interval as delayed_job and Sidekiq
-      (count ** 4) + 15 + (rand(30)*(count+1))
-    end
-
     # Patch the way MongoMapper reloads a model
     # Only reload MongoMapper attributes, leaving other instance variables untouched
     def reload
-      if doc = collection.find_one(:_id => id)
+      if (doc = collection.find_one(_id: id))
+        # Clear out keys that are not returned during the reload from MongoDB
+        (keys.keys - doc.keys).each { |key| send("#{key}=", nil) }
+        initialize_default_values
         load_from_database(doc)
         self
       else
-        raise MongoMapper::DocumentNotFound, "Document match #{_id.inspect} does not exist in #{collection.name} collection"
+        if destroy_on_complete
+          self.state = :completed
+          before_complete
+        else
+          raise(MongoMapper::DocumentNotFound, "Document match #{_id.inspect} does not exist in #{collection.name} collection")
+        end
       end
     end
 
     # After this model is read, convert any hashes in the arguments list to HashWithIndifferentAccess
     def load_from_database(*args)
       super
-      self.arguments = arguments.collect {|i| i.is_a?(BSON::OrderedHash) ? i.with_indifferent_access : i  } if arguments.present?
+      if arguments.present?
+        self.arguments = arguments.collect { |i| i.is_a?(BSON::OrderedHash) ? i.with_indifferent_access : i }
+      end
+    end
+
+    # Set exception information for this job and fail it
+    def fail!(worker_name='user', exc_or_message='Job failed through user action')
+      if exc_or_message.is_a?(Exception)
+        self.exception        = JobException.from_exception(exc_or_message)
+        exception.worker_name = worker_name
+      else
+        build_exception(
+          class_name:  'RocketJob::JobException',
+          message:     exc_or_message,
+          backtrace:   [],
+          worker_name: worker_name
+        )
+      end
+      # not available as #super
+      aasm.current_event = :fail!
+      aasm_fire_event(:fail, persist: true)
+    end
+
+    # Requeue this running job since the worker assigned to it has died
+    def requeue!(worker_name_=nil)
+      return false if worker_name_ && (worker_name != worker_name_)
+      # not available as #super
+      aasm.current_event = :requeue!
+      aasm_fire_event(:requeue, persist: true)
+    end
+
+    # Requeue this running job since the worker assigned to it has died
+    def requeue(worker_name_=nil)
+      return false if worker_name_ && (worker_name != worker_name_)
+      # not available as #super
+      aasm.current_event = :requeue
+      aasm_fire_event(:requeue, persist: false)
     end
 
     ############################################################################
@@ -330,8 +370,9 @@ module RocketJob
     end
 
     def before_fail
-      self.completed_at = Time.now
-      self.worker_name      = nil
+      self.completed_at  = Time.now
+      self.worker_name   = nil
+      self.failure_count += 1
     end
 
     def before_retry
@@ -340,7 +381,7 @@ module RocketJob
 
     def before_pause
       self.completed_at = Time.now
-      self.worker_name      = nil
+      self.worker_name  = nil
     end
 
     def before_resume
@@ -349,130 +390,12 @@ module RocketJob
 
     def before_abort
       self.completed_at = Time.now
-      self.worker_name      = nil
+      self.worker_name  = nil
     end
 
-    # Returns a human readable duration from the supplied [Float] number of seconds
-    def seconds_as_duration(seconds)
-      time = Time.at(seconds)
-      if seconds >= 1.day
-        "#{(seconds / 1.day).to_i}d #{time.strftime('%-Hh %-Mm %-Ss')}"
-      elsif seconds >= 1.hour
-        time.strftime('%-Hh %-Mm %-Ss')
-      elsif seconds >= 1.minute
-        time.strftime('%-Mm %-Ss')
-      else
-        time.strftime('%-Ss')
-      end
-    end
-
-    # Returns the next job to work on in priority based order
-    # Returns nil if there are currently no queued jobs, or processing batch jobs
-    #   with records that require processing
-    #
-    # Parameters
-    #   worker_name [String]
-    #     Name of the worker that will be processing this job
-    #
-    #   skip_job_ids [Array<BSON::ObjectId>]
-    #     Job ids to exclude when looking for the next job
-    #
-    # Note:
-    #   If a job is in queued state it will be started
-    def self.next_job(worker_name, skip_job_ids = nil)
-      query = {
-        '$and' => [
-          {
-            '$or' => [
-              { 'state' => 'queued' }, # Jobs
-              { 'state' => 'running', 'sub_state' => :processing }  # Slices
-            ]
-          },
-          {
-            '$or' => [
-              { run_at: { '$exists' => false } },
-              { run_at: { '$lte' => Time.now } }
-            ]
-          },
-        ]
-      }
-      query['_id'] = { '$nin' => skip_job_ids } if skip_job_ids && skip_job_ids.size > 0
-
-      while doc = find_and_modify(
-          query:  query,
-          sort:   [['priority', 'asc'], ['created_at', 'asc']],
-          update: { '$set' => { 'worker_name' => worker_name, 'state' => 'running' } }
-        )
-        job = load(doc)
-        if job.running?
-          return job
-        else
-          if job.expired?
-            job.destroy
-            logger.info "Destroyed expired job #{job.class.name}, id:#{job.id}"
-          else
-            # Also update in-memory state and run call-backs
-            job.start
-            job.set(started_at: job.started_at)
-            return job
-          end
-        end
-      end
-    end
-
-    ############################################################################
-    private
-
-    # Set exception information for this job
-    def set_exception(worker_name, exc)
+    def before_requeue
+      self.started_at  = nil
       self.worker_name = nil
-      self.failure_count += 1
-      self.exception = JobException.from_exception(exc)
-      exception.worker_name = worker_name
-      fail! unless failed?
-      logger.error("Exception running #{self.class.name}##{perform_method}", exc)
-    end
-
-    # Calls a method on this job, if it is defined
-    # Adds the event name to the method call if supplied
-    #
-    # Returns [Object] the result of calling the method
-    #
-    # Parameters
-    #   method [Symbol]
-    #     The method to call on this job
-    #
-    #   arguments [Array]
-    #     Arguments to pass to the method call
-    #
-    #   Options:
-    #     event: [Symbol]
-    #       Any one of: :before, :after
-    #       Default: None, just calls the method itself
-    #
-    #     log_level: [Symbol]
-    #       Log level to apply to silence logging during the call
-    #       Default: nil ( no change )
-    #
-    def call_method(method, arguments, options={})
-      options               = options.dup
-      event                 = options.delete(:event)
-      log_level             = options.delete(:log_level)
-      raise(ArgumentError, "Unknown #{self.class.name}#call_method options: #{options.inspect}") if options.size > 0
-
-      the_method = event.nil? ? method : "#{event}_#{method}".to_sym
-      if respond_to?(the_method)
-        method_name = "#{self.class.name}##{the_method}"
-        logger.info "Start #{method_name}"
-        logger.benchmark_info("Completed #{method_name}",
-          metric:             "rocketjob/#{self.class.name.underscore}/#{the_method}",
-          log_exception:      :full,
-          on_exception_level: :error,
-          silence:            log_level
-        ) do
-          self.send(the_method, *arguments)
-        end
-      end
     end
 
   end

data/lib/rocket_job/job_exception.rb

@@ -6,6 +6,7 @@ module RocketJob
   class JobException
     include MongoMapper::EmbeddedDocument
 
+    # @formatter:off
     # Name of the exception class
     key :class_name,              String
 
@@ -13,7 +14,7 @@ module RocketJob
     key :message,                 String
 
     # Exception Backtrace [Array<String>]
-    key :backtrace,               Array
+    key :backtrace,               Array, default: []
 
     # Name of the worker on which this exception occurred
     key :worker_name,             String
@@ -21,15 +22,16 @@ module RocketJob
     # The record within which this exception occurred
     key :record_number,           Integer
 
+    # @formatter:on
+
     # Returns [JobException] built from the supplied exception
     def self.from_exception(exc)
-      self.new(
-        class_name:  exc.class.name,
-        message:     exc.message,
-        backtrace:   exc.backtrace || []
+      new(
+        class_name: exc.class.name,
+        message:    exc.message,
+        backtrace:  exc.backtrace || []
       )
     end
 
   end
 end
-

data/lib/rocket_job/jobs/dirmon_job.rb

@@ -5,17 +5,21 @@ module RocketJob
     #
     # * The first time Dirmon runs it gathers the names of files in the monitored
     #   folders.
-    # * On completion Dirmon kicks off a new Dimon job passing it the list
+    # * On completion Dirmon kicks off a new Dirmon job passing it the list
     #   of known files.
     # * On each subsequent Dirmon run it checks the size of each file against the
-    #   previous list of known files, and only of the file size has not changed
+    #   previous list of known files, and only if the file size has not changed
     #   the corresponding job is started for that file.
     # * If the job implements #file_store_upload or #upload, that method is called
     #   and then the file is deleted, or moved to the archive_directory if supplied
+
     # * Otherwise, the file is moved to the supplied archive_directory (defaults to
     #   `_archive` in the same folder as the file itself. The absolute path and
     #   file name of the archived file is passed into the job as it's first argument.
-    #   Note: This means that such jobs _must_ have a Hash as the first agrument
+
+    # Note:
+    # - Jobs that do not implement #file_store_upload or #upload _must_ have a
+    #   Hash as the first argument
     #
     # With RocketJob Pro, the file is automatically uploaded into the job itself
     # using the job's #upload method, after which the file is archived or deleted
@@ -25,35 +29,18 @@ module RocketJob
     #
     #
     # Note:
-    #   Do _not_ start multiple copies of Dirmon as it will result in duplicate
-    #   jobs being started.
+    #   Use `DirmonJob.start` to prevent creating multiple Dirmon jobs, otherwise
+    #   it will result in multiple jobs being started
     class DirmonJob < RocketJob::Job
-      DEFAULT_ARCHIVE_DIR = '_archive'.freeze
+      # Only allow one DirmonJob instance to be running at a time
+      include RocketJob::Concerns::Singleton
 
       rocket_job do |job|
         job.priority = 40
       end
 
       # Number of seconds between directory scans. Default 5 mins
-      key :check_seconds,         Float, default: 300.0
-
-      # TODO Make :perform_later, :perform_now, :perform, :now protected/private
-      #      class << self
-      #        # Ensure that only one instance of the job is running.
-      #        protected :perform_later, :perform_now, :perform, :now
-      #      end
-      #self.send(:protected, :perform_later)
-
-      # Start the single instance of this job
-      # Returns true if the job was started
-      # Returns false if the job is already running and doe not need to be started
-      def self.start(&block)
-        # Prevent multiple Dirmon Jobs from running at the same time
-        return false if where(state: [ :running, :queued ]).count > 0
-
-        perform_later({}, &block)
-        true
-      end
+      key :check_seconds, Float, default: 300.0
 
       # Iterate over each Dirmon entry looking for new files
       # If a new file is found, it is not processed immediately, instead
@@ -70,21 +57,19 @@ module RocketJob
         end
       end
 
+      protected
+
       # Checks the directories for new files, starting jobs if files have not changed
       # since the last run
       def check_directories(previous_file_names)
         new_file_names = {}
-        DirmonEntry.where(enabled: true).each do |entry|
-          logger.tagged("Entry:#{entry.id}") do
-            Dir[entry.path].each do |file_name|
-              next if File.directory?(file_name)
-              next if file_name.include?(DEFAULT_ARCHIVE_DIR)
-              # BSON Keys cannot contain periods
-              key = file_name.gsub('.', '_')
-              previous_size = previous_file_names[key]
-              if size = check_file(entry, file_name, previous_size)
-                new_file_names[key] = size
-              end
+        DirmonEntry.where(state: :enabled).each do |entry|
+          entry.each do |pathname|
+            # BSON Keys cannot contain periods
+            key           = pathname.to_s.gsub('.', '_')
+            previous_size = previous_file_names[key]
+            if (size = check_file(entry, pathname, previous_size))
+              new_file_names[key] = size
             end
           end
         end
@@ -93,14 +78,14 @@ module RocketJob
 
       # Checks if a file should result in starting a job
       # Returns [Integer] file size, or nil if the file started a job
-      def check_file(entry, file_name, previous_size)
-        size = File.size(file_name)
+      def check_file(entry, pathname, previous_size)
+        size = pathname.size
         if previous_size && (previous_size == size)
-          logger.info("File stabilized: #{file_name}. Starting: #{entry.job_name}")
-          start_job(entry, file_name)
+          logger.info("File stabilized: #{pathname}. Starting: #{entry.job_class_name}")
+          entry.later(pathname)
           nil
         else
-          logger.info("Found file: #{file_name}. File size: #{size}")
+          logger.info("Found file: #{pathname}. File size: #{size}")
           # Keep for the next run
           size
         end
@@ -109,67 +94,6 @@ module RocketJob
         nil
       end
 
-      # Starts the job for the supplied entry
-      def start_job(entry, file_name)
-        entry.job_class.perform_later(*entry.arguments) do |job|
-          job.perform_method = entry.perform_method
-          # Set properties
-          entry.properties.each_pair { |k, v| job.send("#{k}=".to_sym, v) }
-
-          upload_file(job, file_name, entry.archive_directory)
-        end
-      end
-
-      # Upload the file to the job
-      def upload_file(job, file_name, archive_directory)
-        if job.respond_to?(:file_store_upload)
-          # Allow the job to determine what to do with the file
-          job.file_store_upload(file_name)
-          archive_file(file_name, archive_directory)
-        elsif job.respond_to?(:upload)
-          # With RocketJob Pro the file can be uploaded directly into the Job itself
-          job.upload(file_name)
-          archive_file(file_name, archive_directory)
-        else
-          upload_default(job, file_name, archive_directory)
-        end
-      end
-
-      # Archives the file for a job where there was no #file_store_upload or #upload method
-      def upload_default(job, file_name, archive_directory)
-        # The first argument must be a hash
-        job.arguments << {} if job.arguments.size == 0
-        # If no archive directory is supplied, use DEFAULT_ARCHIVE_DIR under the same path as the file
-        archive_directory ||= File.join(File.dirname(file_name), DEFAULT_ARCHIVE_DIR)
-        file_name = File.join(archive_directory, File.basename(file_name))
-        job.arguments.first[:full_file_name] = File.absolute_path(file_name)
-        archive_file(file_name, archive_directory)
-      end
-
-      # Move the file to the archive directory
-      # Or, delete it if no archive directory was supplied for this entry
-      #
-      # If the file_name contains a relative path the relative path will be
-      # created in the archive_directory before moving the file.
-      #
-      # If an absolute path is supplied, then the file is just moved into the
-      # archive directory without any sub-directories
-      def archive_file(file_name, archive_directory)
-        # Move file to archive directory if set
-        if archive_directory
-          # Absolute path?
-          target_file_name = if file_name.start_with?('/')
-            File.join(archive_directory, File.basename(file_name))
-          else
-            File.join(archive_directory, file_name)
-          end
-          FileUtils.mkdir_p(File.dirname(target_file_name))
-          FileUtils.move(file_name, target_file_name)
-        else
-          File.delete(file_name)
-        end
-      end
-
     end
   end
 end