rocketjob 1.3.0 → 2.0.0.rc1

data/test/plugins/state_machine_event_callbacks_test.rb

@@ -0,0 +1,101 @@
+require_relative '../test_helper'
+
+module Plugins
+  # Unit Test for RocketJob::Job
+  class StateMachineEventCallbacksTest < Minitest::Test
+    # This job adds each event callback as they run into an array
+    # [:start, :complete, :fail, :retry, :pause, :resume, :abort, :requeue]
+    class PositivePathJob < RocketJob::Job
+      before_complete do
+        arguments.first << 'before_complete_block'
+      end
+
+      after_complete do
+        arguments.first << 'after_complete_block'
+      end
+
+      before_complete :before_complete_method
+
+      before_start do
+        arguments.first << 'before_start_block'
+      end
+
+      before_start :before_start_method
+
+      before_start do
+        arguments.first << 'before_start2_block'
+      end
+
+      after_start :after_start_method
+      after_complete :after_complete_method
+
+      before_complete do
+        arguments.first << 'before_complete2_block'
+      end
+
+      after_start do
+        arguments.first << 'after_start_block'
+      end
+
+      after_complete do
+        arguments.first << 'after_complete2_block'
+      end
+
+      after_start :after_start_method
+
+      after_start do
+        arguments.first << 'after_start2_block'
+      end
+
+      before_start :before_start_method2
+      before_complete :before_complete_method2
+
+      def perform(list)
+        list << 'perform'
+      end
+
+      private
+
+      def before_start_method
+        arguments.first << 'before_start_method'
+      end
+
+      def before_start_method2
+        arguments.first << 'before_start_method2'
+      end
+
+      def after_start_method
+        arguments.first << 'after_start_method'
+      end
+
+      def before_complete_method
+        arguments.first << 'before_complete_method'
+      end
+
+      def before_complete_method2
+        arguments.first << 'before_complete_method2'
+      end
+
+      def after_complete_method
+        arguments.first << 'after_complete_method'
+      end
+    end
+
+    describe RocketJob::Plugins::StateMachine do
+      after do
+        @job.destroy if @job && !@job.new_record?
+      end
+
+      describe 'before_start after_start & before_complete after_complete' do
+        it 'runs blocks and functions' do
+          @job = PositivePathJob.new(arguments: [[]])
+          @job.perform_now
+          assert @job.completed?, @job.attributes.ai
+          expected = %w(before_start_block before_start_method before_start2_block before_start_method2 after_start2_block after_start_method after_start_block perform before_complete_block before_complete_method before_complete2_block before_complete_method2 after_complete2_block after_complete_method after_complete_block)
+          assert_equal expected, @job.arguments.first, 'Sequence of before_perform callbacks is incorrect'
+        end
+      end
+
+    end
+  end
+end

data/test/plugins/state_machine_test.rb

@@ -0,0 +1,64 @@
+require_relative '../test_helper'
+
+module Plugins
+  # Unit Test for RocketJob::Job
+  class StateMachineTest < Minitest::Test
+
+    class Test
+      include RocketJob::Plugins::Document
+      include RocketJob::Plugins::StateMachine
+
+      key :name
+      key :state
+      validates_presence_of :name, :state
+
+      aasm column: :state do
+        state :pending, initial: true
+        state :enabled
+
+        event :enable do
+          transitions from: :pending, to: :enabled
+        end
+      end
+    end
+
+    describe RocketJob::Plugins::StateMachine do
+      before do
+        @doc = Test.new
+      end
+
+      after do
+        @doc.destroy if @doc && !@doc.new_record?
+      end
+
+      describe '#aasm_write_state' do
+        it 'raises an exception when a validation fails on create!' do
+          assert_raises MongoMapper::DocumentNotValid do
+            @doc = Test.create!
+          end
+        end
+
+        it 'raises an exception when a validation fails on save' do
+          assert_raises MongoMapper::DocumentNotValid do
+            @doc.save!
+          end
+        end
+
+        it 'raises an exception when a validation fails on state transition with save' do
+          assert_raises MongoMapper::DocumentNotValid do
+            @doc.enable!
+          end
+          assert @doc.pending?
+          refute @doc.valid?
+        end
+
+        it 'does not raise an exception when a validation fails on state transition without save' do
+          @doc.enable
+          assert @doc.enabled?
+        end
+
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -4,45 +4,12 @@ require 'yaml'
 require 'minitest/autorun'
 require 'minitest/reporters'
 require 'minitest/stub_any_instance'
-require 'rocketjob'
 require 'awesome_print'
-require 'symmetric-encryption'
+require 'rocketjob'
 
-if ENV['DETAILED_TESTS'].present?
-  # See every test and how long it took
-  MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new
-else
-  # Only show failed tests
-  MiniTest::Reporters.use! MiniTest::Reporters::ProgressReporter.new
-end
+MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new
 
 SemanticLogger.add_appender('test.log', &SemanticLogger::Appender::Base.colorized_formatter)
 SemanticLogger.default_level = :debug
 
-# Setup MongoMapper from mongo config file
-config_file                  = File.join(File.dirname(__FILE__), 'config', 'mongo.yml')
-config                       = YAML.load(ERB.new(File.read(config_file)).result)
-if config
-  cfg              = config['test']
-  options          = cfg['options'] || {}
-  options[:logger] = SemanticLogger::DebugAsTraceLogger.new('Mongo')
-
-  MongoMapper.config     = cfg
-  MongoMapper.connection = Mongo::MongoClient.from_uri(cfg['uri'], options)
-  MongoMapper.database   = MongoMapper.connection.db.name
-
-  # If this environment has a separate Work server
-  if (cfg = config['test_work'])
-    options                                 = cfg['options'] || {}
-    options[:logger]                        = SemanticLogger::DebugAsTraceLogger.new('MongoWork')
-    RocketJob::Config.mongo_work_connection = Mongo::MongoClient.from_uri(cfg['uri'], options)
-  end
-end
-
-# Test cipher
-SymmetricEncryption.cipher = SymmetricEncryption::Cipher.new(
-  cipher_name: 'aes-128-cbc',
-  key:         '1234567890ABCDEF1234567890ABCDEF',
-  iv:          '1234567890ABCDEF',
-  encoding:    :base64strict
-)
+RocketJob::Config.load!('test', 'test/config/mongo.yml')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rocketjob
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-25 00:00:00.000000000 Z
+date: 2016-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aasm
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '4.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '4.3'
 - !ruby/object:Gem::Dependency
   name: semantic_logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '2.21'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '2.21'
 - !ruby/object:Gem::Dependency
   name: mongo_ha
   requirement: !ruby/object:Gem::Requirement
@@ -94,40 +94,77 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Enterprise Batch Processing System focused on performance, scalability,
   reliability, and visibility of every job in the system.
 email:
 - reidmo@gmail.com
 executables:
 - rocketjob
+- rocketjob_perf
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
 - README.md
 - Rakefile
 - bin/rocketjob
+- bin/rocketjob_perf
 - lib/rocket_job/cli.rb
-- lib/rocket_job/concerns/singleton.rb
-- lib/rocket_job/concerns/worker.rb
 - lib/rocket_job/config.rb
 - lib/rocket_job/dirmon_entry.rb
+- lib/rocket_job/extensions/aasm.rb
+- lib/rocket_job/extensions/mongo.rb
 - lib/rocket_job/heartbeat.rb
 - lib/rocket_job/job.rb
 - lib/rocket_job/job_exception.rb
 - lib/rocket_job/jobs/dirmon_job.rb
+- lib/rocket_job/jobs/simple_job.rb
+- lib/rocket_job/plugins/document.rb
+- lib/rocket_job/plugins/job/callbacks.rb
+- lib/rocket_job/plugins/job/defaults.rb
+- lib/rocket_job/plugins/job/logger.rb
+- lib/rocket_job/plugins/job/model.rb
+- lib/rocket_job/plugins/job/persistence.rb
+- lib/rocket_job/plugins/job/state_machine.rb
+- lib/rocket_job/plugins/job/worker.rb
+- lib/rocket_job/plugins/restart.rb
+- lib/rocket_job/plugins/singleton.rb
+- lib/rocket_job/plugins/state_machine.rb
 - lib/rocket_job/version.rb
 - lib/rocket_job/worker.rb
 - lib/rocketjob.rb
 - test/config/mongo.yml
+- test/config_test.rb
 - test/dirmon_entry_test.rb
 - test/dirmon_job_test.rb
-- test/files/_archive/archived.txt
 - test/files/text.txt
 - test/job_test.rb
-- test/job_worker_test.rb
-- test/jobs/test_job.rb
+- test/plugins/job/callbacks_test.rb
+- test/plugins/job/defaults_test.rb
+- test/plugins/job/logger_test.rb
+- test/plugins/job/model_test.rb
+- test/plugins/job/persistence_test.rb
+- test/plugins/job/state_machine_test.rb
+- test/plugins/job/worker_test.rb
+- test/plugins/restart_test.rb
+- test/plugins/singleton_test.rb
+- test/plugins/state_machine_event_callbacks_test.rb
+- test/plugins/state_machine_test.rb
 - test/test_helper.rb
-- test/worker_test.rb
 homepage: http://rocketjob.io
 licenses:
 - GPL-3.0
@@ -143,23 +180,31 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Enterprise Batch Processing System for Ruby, JRuby, and Rubinius
 test_files:
 - test/config/mongo.yml
+- test/config_test.rb
 - test/dirmon_entry_test.rb
 - test/dirmon_job_test.rb
-- test/files/_archive/archived.txt
 - test/files/text.txt
 - test/job_test.rb
-- test/job_worker_test.rb
-- test/jobs/test_job.rb
+- test/plugins/job/callbacks_test.rb
+- test/plugins/job/defaults_test.rb
+- test/plugins/job/logger_test.rb
+- test/plugins/job/model_test.rb
+- test/plugins/job/persistence_test.rb
+- test/plugins/job/state_machine_test.rb
+- test/plugins/job/worker_test.rb
+- test/plugins/restart_test.rb
+- test/plugins/singleton_test.rb
+- test/plugins/state_machine_event_callbacks_test.rb
+- test/plugins/state_machine_test.rb
 - test/test_helper.rb
-- test/worker_test.rb

data/lib/rocket_job/concerns/singleton.rb

@@ -1,33 +0,0 @@
-# encoding: UTF-8
-require 'active_support/concern'
-
-# Worker behavior for a job
-module RocketJob
-  module Concerns
-    module Singleton
-      extend ActiveSupport::Concern
-
-      included do
-        # 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(*args, &block)
-          # Prevent multiple Jobs of the same class from running at the same time
-          return false if where(state: [:running, :queued]).count > 0
-
-          perform_later(*args, &block)
-          true
-        end
-
-        # 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)
-
-      end
-    end
-  end
-end

data/lib/rocket_job/concerns/worker.rb

@@ -1,214 +0,0 @@
-# encoding: UTF-8
-
-# Worker behavior for a job
-module RocketJob
-  module Concerns
-    module Worker
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        # Returns [Job] after queue-ing it for processing
-        def later(method, *args, &block)
-          if RocketJob::Config.inline_mode
-            now(method, *args, &block)
-          else
-            job = build(method, *args, &block)
-            job.save!
-            job
-          end
-        end
-
-        # Create a job and process it immediately in-line by this thread
-        def now(method, *args, &block)
-          build(method, *args, &block).work_now
-        end
-
-        # Build a Rocket Job instance
-        #
-        # Note:
-        #  - #save! must be called on the return job instance if it needs to be
-        #    queued for processing.
-        #  - If data is uploaded into the job instance before saving, and is then
-        #    discarded, call #cleanup! to clear out any partially uploaded data
-        def build(method, *args, &block)
-          job = new(arguments: args, perform_method: method.to_sym)
-          block.call(job) if block
-          job
-        end
-
-        # Method to be performed later
-        def perform_later(*args, &block)
-          later(:perform, *args, &block)
-        end
-
-        # Method to be performed later
-        def perform_build(*args, &block)
-          build(:perform, *args, &block)
-        end
-
-        # Method to be performed now
-        def perform_now(*args, &block)
-          now(:perform, *args, &block)
-        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 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
-
-      end
-
-      # Works on this job
-      #
-      # Returns [true|false] whether this job should be excluded from the next lookup
-      #
-      # If an exception is thrown the job is marked as failed and the exception
-      # is set in the job itself.
-      #
-      # Thread-safe, can be called by multiple threads at the same time
-      def work(worker)
-        raise(ArgumentError, 'Job must be started before calling #work') unless running?
-        begin
-          # before_perform
-          call_method(perform_method, arguments, event: :before, log_level: log_level)
-          # Allow before perform to explicitly fail this job
-          return unless running?
-
-          # perform
-          ret = call_method(perform_method, arguments, log_level: log_level)
-          if self.collect_output?
-            self.result = (ret.is_a?(Hash) || ret.is_a?(BSON::OrderedHash)) ? ret : {result: ret}
-          end
-
-          # Only run after perform if perform did not explicitly fail the job
-          return unless running?
-
-          # after_perform
-          call_method(perform_method, arguments, event: :after, log_level: log_level)
-
-          new_record? ? complete : complete!
-        rescue StandardError => exc
-          fail(worker.name, exc) if may_fail?
-          logger.error("Exception running #{self.class.name}##{perform_method}", exc)
-          save! unless new_record?
-          raise exc if RocketJob::Config.inline_mode
-        end
-        false
-      end
-
-      # Validates and runs the work on this job now in the current thread
-      # Returns this job once it has finished running
-      def work_now
-        # Call validations
-        if respond_to?(:validate!)
-          validate!
-        elsif invalid?
-          raise(MongoMapper::DocumentNotValid, "Validation failed: #{errors.messages.join(', ')}")
-        end
-        worker = RocketJob::Worker.new(name: 'inline')
-        worker.started
-        start if may_start?
-        while running? && !work(worker)
-        end
-        self
-      end
-
-      protected
-
-      # 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
-            send(the_method, *arguments)
-          end
-        end
-      end
-
-    end
-  end
-end

data/test/files/_archive/archived.txt

@@ -1,3 +0,0 @@
-Hello World
-Line2
-Line3