rocketjob 1.0.0 → 1.1.0

data/lib/rocket_job/version.rb

@@ -1,4 +1,4 @@
 # encoding: UTF-8
 module RocketJob #:nodoc
-  VERSION = "1.0.0"
+  VERSION = '1.1.0'
 end

data/lib/rocket_job/worker.rb

@@ -36,6 +36,7 @@ module RocketJob
     # Prevent data in MongoDB from re-defining the model behavior
     #self.static_keys = true
 
+    # @formatter:off
     # Unique Name of this worker instance
     #   Defaults to the `hostname` but _must_ be overriden if mutiple Worker instances
     #   are started on the same host
@@ -86,6 +87,7 @@ module RocketJob
         transitions from: :starting, to: :stopping
       end
     end
+    # @formatter:on
 
     attr_reader :thread_pool
 
@@ -100,7 +102,7 @@ module RocketJob
       worker.save!
       create_indexes
       register_signal_handlers
-      raise "The RocketJob configuration is being applied after the system has been initialized" unless RocketJob::Job.database.name == RocketJob::SlicedJob.database.name
+      raise 'The RocketJob configuration is being applied after the system has been initialized' unless RocketJob::Job.database.name == RocketJob::SlicedJob.database.name
       logger.info "Using MongoDB Database: #{RocketJob::Job.database.name}"
       worker.run
     end
@@ -112,37 +114,34 @@ module RocketJob
       Job.create_indexes
     end
 
-    # Destroy dead workers ( missed at least the last 4 heartbeats )
-    # Requeue jobs assigned to dead workers
-    # Destroy dead workers
-    def self.destroy_dead_workers
-      dead_seconds = Config.instance.heartbeat_seconds * 4
+    # Destroy's all instances of zombie workers and requeues any jobs still "running"
+    # on those workers
+    def self.destroy_zombies
       each do |worker|
-        next if (Time.now - worker.heartbeat.updated_at) < dead_seconds
-        logger.warn "Destroying worker #{worker.name}, and requeueing its jobs"
+        next unless zombie?
+        logger.warn "Destroying zombie worker #{worker.name}, and requeueing its jobs"
         worker.destroy
       end
     end
 
+    def self.destroy_dead_workers
+      warn 'RocketJob::Worker.destroy_dead_workers is deprecated, use RocketJob::Worker.destroy_zombies'
+      destroy_zombies
+    end
+
     # Stop all running, paused, or starting workers
     def self.stop_all
-      where(state: ['running', 'paused', 'starting']).each { |worker| worker.stop! }
+      where(state: [:running, :paused, :starting]).each(&:stop!)
     end
 
     # Pause all running workers
     def self.pause_all
-      where(state: 'running').each { |worker| worker.pause! }
+      running.each(&:pause!)
     end
 
     # Resume all paused workers
     def self.resume_all
-      each { |worker| worker.resume! if worker.paused? }
-    end
-
-    # Register a handler to perform cleanups etc. whenever a worker is
-    # explicitly destroyed
-    def self.register_destroy_handler(&block)
-      @@destroy_handlers << block
+      paused.each(&:resume!)
     end
 
     # Returns [Boolean] whether the worker is shutting down
@@ -162,7 +161,7 @@ module RocketJob
 
     # Run this instance of the worker
     def run
-      Thread.current.name = 'RocketJob main'
+      Thread.current.name = 'rocketjob main'
       build_heartbeat unless heartbeat
 
       started
@@ -211,7 +210,18 @@ module RocketJob
     end
 
     def thread_pool_count
-      thread_pool.count{ |i| i.alive? }
+      thread_pool.count { |i| i.alive? }
+    end
+
+    # Returns [true|false] if this worker has missed at least the last 4 heartbeats
+    #
+    # Possible causes for a worker to miss its heartbeats:
+    # - The worker process has died
+    # - The worker process is "hanging"
+    # - The worker is no longer able to communicate with the MongoDB Server
+    def zombie?(missed = 4)
+      dead_seconds = Config.instance.heartbeat_seconds * missed
+      (Time.now - worker.heartbeat.updated_at) >= dead_seconds
     end
 
     protected
@@ -279,7 +289,7 @@ module RocketJob
     # Process the next available job
     # Returns [Boolean] whether any job was actually processed
     def process_next_job
-      skip_job_ids  = []
+      skip_job_ids = []
       while job = Job.next_job(name, skip_job_ids)
         logger.tagged("Job #{job.id}") do
           if job.work(self)
@@ -297,7 +307,7 @@ module RocketJob
     # Requeue any jobs assigned to this worker
     def requeue_jobs
       stop! if running? || paused?
-      @@destroy_handlers.each { |handler| handler.call(name) }
+      RocketJob::Job.requeue_dead_worker(name)
     end
 
     # Mutex protected shutdown indicator
@@ -311,25 +321,28 @@ module RocketJob
     #
     def self.register_signal_handlers
       begin
-        Signal.trap "SIGTERM" do
+        Signal.trap 'SIGTERM' do
           # Cannot use Mutex protected writer here since it is in a signal handler
           @@shutdown = true
-          logger.warn "Shutdown signal (SIGTERM) received. Will shutdown as soon as active jobs/slices have completed."
+          logger.warn 'Shutdown signal (SIGTERM) received. Will shutdown as soon as active jobs/slices have completed.'
         end
 
-        Signal.trap "INT" do
+        Signal.trap 'INT' do
           # Cannot use Mutex protected writer here since it is in a signal handler
           @@shutdown = true
-          logger.warn "Shutdown signal (INT) received. Will shutdown as soon as active jobs/slices have completed."
+          logger.warn 'Shutdown signal (INT) received. Will shutdown as soon as active jobs/slices have completed.'
         end
-      rescue Exception
-        logger.warn "SIGTERM handler not installed. Not able to shutdown gracefully"
+      rescue StandardError
+        logger.warn 'SIGTERM handler not installed. Not able to shutdown gracefully'
       end
     end
 
     # Patch the way MongoMapper reloads a model
     def reload
       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
@@ -337,10 +350,6 @@ module RocketJob
       end
     end
 
-    private
-
-    @@destroy_handlers = ThreadSafe::Array.new
-
   end
 end
 

data/lib/rocketjob.rb

@@ -5,18 +5,35 @@ require 'mongo_mapper'
 require 'semantic_logger'
 require 'rocket_job/version'
 
+# @formatter:off
 module RocketJob
-  autoload :CLI,                   'rocket_job/cli'
-  autoload :Config,                'rocket_job/config'
-  autoload :DirmonEntry,           'rocket_job/dirmon_entry'
-  autoload :Heartbeat,             'rocket_job/heartbeat'
-  autoload :Job,                   'rocket_job/job'
-  autoload :JobException,          'rocket_job/job_exception'
-  autoload :Worker,                'rocket_job/worker'
+  autoload :CLI,            'rocket_job/cli'
+  autoload :Config,         'rocket_job/config'
+  autoload :DirmonEntry,    'rocket_job/dirmon_entry'
+  autoload :Heartbeat,      'rocket_job/heartbeat'
+  autoload :Job,            'rocket_job/job'
+  autoload :JobException,   'rocket_job/job_exception'
+  autoload :Worker,         'rocket_job/worker'
   module Concerns
-    autoload :Worker,              'rocket_job/concerns/worker'
+    autoload :Worker,       'rocket_job/concerns/worker'
+    autoload :Singleton,    'rocket_job/concerns/singleton'
   end
   module Jobs
-    autoload :DirmonJob,           'rocket_job/jobs/dirmon_job'
+    autoload :DirmonJob,    'rocket_job/jobs/dirmon_job'
+  end
+
+  # @formatter:on
+  # Returns a human readable duration from the supplied [Float] number of seconds
+  def self.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
 end

data/test/dirmon_entry_test.rb

@@ -4,67 +4,233 @@ require_relative 'jobs/test_job'
 # Unit Test for RocketJob::Job
 class DirmonEntryTest < Minitest::Test
   context RocketJob::DirmonEntry do
-    teardown do
-      @dirmon_entry.destroy if @dirmon_entry && @dirmon_entry.new_record?
-    end
-
     context '.config' do
       should 'support multiple databases' do
         assert_equal 'test_rocketjob', RocketJob::DirmonEntry.collection.db.name
       end
     end
 
+    context '#job_class' do
+      context 'with a nil job_class_name' do
+        should 'return nil' do
+          entry = RocketJob::DirmonEntry.new
+          assert_equal(nil, entry.job_class)
+        end
+      end
+
+      context 'with an unknown job_class_name' do
+        should 'return nil' do
+          entry = RocketJob::DirmonEntry.new(job_class_name: 'FakeJobThatDoesNotExistAnyWhereIPromise')
+          assert_equal(nil, entry.job_class)
+        end
+      end
+
+      context 'with a valid job_class_name' do
+        should 'return job class' do
+          entry = RocketJob::DirmonEntry.new(job_class_name: 'RocketJob::Job')
+          assert_equal(RocketJob::Job, entry.job_class)
+        end
+      end
+    end
+
+    context '.whitelist_paths' do
+      should 'default to []' do
+        assert_equal [], RocketJob::DirmonEntry.whitelist_paths
+      end
+    end
+
+    context '.add_whitelist_path' do
+      teardown do
+        RocketJob::DirmonEntry.whitelist_paths.each { |path| RocketJob::DirmonEntry.delete_whitelist_path(path) }
+      end
+
+      should 'convert relative path to an absolute one' do
+        path = Pathname('test/jobs').realpath.to_s
+        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/jobs')
+        assert_equal [path], RocketJob::DirmonEntry.whitelist_paths
+      end
+
+      should 'prevent duplicates' do
+        path = Pathname('test/jobs').realpath.to_s
+        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/jobs')
+        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/jobs')
+        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path(path)
+        assert_equal [path], RocketJob::DirmonEntry.whitelist_paths
+      end
+    end
+
+    context '#fail_with_exception!' do
+      setup do
+        @dirmon_entry = RocketJob::DirmonEntry.new(job_class_name: 'Jobs::TestJob', pattern: '/abc/**', arguments: [1])
+        @dirmon_entry.enable!
+      end
+      teardown do
+        @dirmon_entry.destroy if @dirmon_entry && @dirmon_entry.new_record?
+      end
+
+      should 'fail with message' do
+        @dirmon_entry.fail_with_exception!('myworker:2323', 'oh no')
+        assert_equal true, @dirmon_entry.failed?
+        assert_equal 'RocketJob::DirmonEntryException', @dirmon_entry.exception.class_name
+        assert_equal 'oh no', @dirmon_entry.exception.message
+      end
+
+      should 'fail with exception' do
+        exception = nil
+        begin
+          blah
+        rescue Exception => exc
+          exception = exc
+        end
+        @dirmon_entry.fail_with_exception!('myworker:2323', exception)
+
+        assert_equal true, @dirmon_entry.failed?
+        assert_equal exception.class.name.to_s, @dirmon_entry.exception.class_name
+        assert @dirmon_entry.exception.message.include?('undefined local variable or method'), @dirmon_entry.attributes.inspect
+      end
+    end
+
     context '#validate' do
       should 'existance' do
-        assert entry = RocketJob::DirmonEntry.new(job_name: 'Jobs::TestJob')
+        assert entry = RocketJob::DirmonEntry.new(job_class_name: 'Jobs::TestJob')
         assert_equal false, entry.valid?
-        assert_equal [ "can't be blank" ], entry.errors[:path], entry.errors.inspect
+        assert_equal ["can't be blank"], entry.errors[:pattern], entry.errors.inspect
       end
 
-      should 'job_name' do
-        assert entry = RocketJob::DirmonEntry.new(path: '/abc/**')
-        assert_equal false, entry.valid?
-        assert_equal ["can't be blank", "job_name must be defined and must be derived from RocketJob::Job"], entry.errors[:job_name], entry.errors.inspect
+      context 'job_class_name' do
+        should 'ensure presence' do
+          assert entry = RocketJob::DirmonEntry.new(pattern: '/abc/**')
+          assert_equal false, entry.valid?
+          assert_equal ["can't be blank", 'job_class_name must be defined and must be derived from RocketJob::Job'], entry.errors[:job_class_name], entry.errors.inspect
+        end
       end
 
-      should 'arguments' do
-        assert entry = RocketJob::DirmonEntry.new(
-          job_name: 'Jobs::TestJob',
-          path:     '/abc/**'
-        )
-        assert_equal false, entry.valid?
-        assert_equal ["There must be 1 argument(s)"], entry.errors[:arguments], entry.errors.inspect
+      context 'arguments' do
+        should 'ensure correct number of arguments' do
+          assert entry = RocketJob::DirmonEntry.new(
+              job_class_name: 'Jobs::TestJob',
+              pattern:        '/abc/**'
+            )
+          assert_equal false, entry.valid?
+          assert_equal ['There must be 1 argument(s)'], entry.errors[:arguments], entry.errors.inspect
+        end
+
+        should 'return false if the job name is bad' do
+          assert entry = RocketJob::DirmonEntry.new(
+              job_class_name: 'Jobs::Tests::Names::Things',
+              pattern:        '/abc/**'
+            )
+          assert_equal false, entry.valid?
+          assert_equal [], entry.errors[:arguments], entry.errors.inspect
+        end
       end
 
       should 'arguments with perform_method' do
         assert entry = RocketJob::DirmonEntry.new(
-          job_name:       'Jobs::TestJob',
-          path:           '/abc/**',
-          perform_method: :sum
-        )
+            job_class_name: 'Jobs::TestJob',
+            pattern:        '/abc/**',
+            perform_method: :sum
+          )
         assert_equal false, entry.valid?
-        assert_equal ["There must be 2 argument(s)"], entry.errors[:arguments], entry.errors.inspect
+        assert_equal ['There must be 2 argument(s)'], entry.errors[:arguments], entry.errors.inspect
       end
 
       should 'valid' do
         assert entry = RocketJob::DirmonEntry.new(
-          job_name:  'Jobs::TestJob',
-          path:      '/abc/**',
-          arguments: [1]
-        )
+            job_class_name: 'Jobs::TestJob',
+            pattern:        '/abc/**',
+            arguments:      [1]
+          )
         assert entry.valid?, entry.errors.inspect
       end
 
       should 'valid with perform_method' do
         assert entry = RocketJob::DirmonEntry.new(
-          job_name:       'Jobs::TestJob',
-          path:           '/abc/**',
-          perform_method: :sum,
-          arguments:      [1,2]
-        )
+            job_class_name: 'Jobs::TestJob',
+            pattern:        '/abc/**',
+            perform_method: :sum,
+            arguments:      [1, 2]
+          )
         assert entry.valid?, entry.errors.inspect
       end
     end
 
+    context 'with valid entry' do
+      setup do
+        @archive_directory = '/tmp/archive_directory'
+        @entry             = RocketJob::DirmonEntry.new(
+          pattern:           'abc/*',
+          job_class_name:    'Jobs::TestJob',
+          arguments:         [{input: 'yes'}],
+          properties:        {priority: 23, perform_method: :event},
+          archive_directory: @archive_directory
+        )
+        @job               = Jobs::TestJob.new
+        @file              = Tempfile.new('archive')
+        @file_name         = @file.path
+        @pathname          = Pathname.new(@file_name)
+        File.open(@file_name, 'w') { |file| file.write('Hello World') }
+        assert File.exists?(@file_name)
+        @archive_file_name = File.join(@archive_directory, "#{@job.id}_#{File.basename(@file_name)}")
+      end
+
+      teardown do
+        @file.delete if @file
+      end
+
+      context '#archive_pathname' do
+        should 'with archive directory' do
+          assert_equal @archive_directory.to_s, @entry.archive_pathname.to_s
+        end
+
+        should 'without archive directory' do
+          @entry.archive_directory = nil
+          assert_equal '_archive', @entry.archive_pathname.to_s
+        end
+      end
+
+      context '#archive_file' do
+        should 'archive file' do
+          assert_equal @archive_file_name, @entry.send(:archive_file, @job, Pathname.new(@file_name))
+          assert File.exists?(@archive_file_name), @archive_file_name
+        end
+      end
+
+      context '#upload_default' do
+        should 'upload' do
+          @entry.send(:upload_default, @job, @pathname)
+          assert_equal File.absolute_path(@archive_file_name), @job.arguments.first[:full_file_name], @job.arguments
+        end
+      end
+
+      context '#upload_file' do
+        should 'upload using #file_store_upload' do
+          @job.define_singleton_method(:file_store_upload) do |file_name|
+            self.description = "FILE:#{file_name}"
+          end
+          @entry.send(:upload_file, @job, @pathname)
+          assert_equal "FILE:#{@file_name}", @job.description
+        end
+
+        should 'upload using #upload' do
+          @job.define_singleton_method(:upload) do |file_name|
+            self.description = "FILE:#{file_name}"
+          end
+          @entry.send(:upload_file, @job, @pathname)
+          assert_equal "FILE:#{@file_name}", @job.description
+        end
+      end
+
+      context '#later' do
+        should 'enqueue job' do
+          @entry.arguments = [{}]
+          @entry.perform_method = :event
+          job = @entry.later(@pathname)
+          assert_equal File.join(@archive_directory, "#{job.id}_#{File.basename(@file_name)}"), job.arguments.first[:full_file_name]
+          assert job.queued?
+        end
+      end
+    end
+
   end
 end