rocketjob 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ce24994db3b436019267874436049b46226fe54
-  data.tar.gz: b34a433d970dab95a6f37fcf4d1db25002e17bf6
+  metadata.gz: c01cfe6dbadea5f8d327a520b68c7262b1bcff96
+  data.tar.gz: 4e52926f26dc216852bae81f780b48103a5625fe
 SHA512:
-  metadata.gz: d9f00987987456c79446bab56247fc3c23cb91263d42e1d30957b539851952a5564c9f744e165132120ade41529834d949c1af6918d960c546e2cd76dafc5b74
-  data.tar.gz: 77b5a354059d60f59b1f9c8f2f138f02a6817dd391ec7e05d8915998bfa0d98ae6aa1296c97dadc88ff8597e47aeb56122a1e8b526792b28e99b27dd662ff702
+  metadata.gz: 3286460b8ce4f27c31c47226b5d157c62541114f0c645b1260ff6cbe86cdd23f985bd6c180024b2812bf8b0ca650634e186f28faf0f5a87c0648a2cdd3edcff3
+  data.tar.gz: 26af31595e81983ab38e70fbc2b2d1c5101a876bfa2fcfdf9a465648e87269f42c70ee9fb580b9bfda6cfbacec18d67d36d502d235d3a22e0e7e8d5a372947af

data/README.md

@@ -80,7 +80,7 @@ This differs from the traditional approach of separate queues for jobs which
 quickly becomes cumbersome when there are for example over a hundred different
 types of jobs.
 
-The global priority based queue ensures that the servers are utilized to their
+The global priority based queue ensures that the workers are utilized to their
 capacity without requiring constant manual intervention.
 
 `rocketjob` is designed to handle hundreds of millions of concurrent jobs

data/lib/rocket_job/cli.rb

@@ -15,7 +15,7 @@ module RocketJob
       parse(argv)
     end
 
-    # Run a RocketJob::Server from the command line
+    # Run a RocketJob::Worker from the command line
     def run
       SemanticLogger.add_appender(STDOUT,  &SemanticLogger::Appender::Base.colorized_formatter) unless quiet
       boot_rails if defined?(:Rails)
@@ -24,14 +24,14 @@ module RocketJob
       opts = {}
       opts[:name]             = name if name
       opts[:max_threads]      = threads if threads
-      Server.run(opts)
+      Worker.run(opts)
     end
 
     # Initialize the Rails environment
     def boot_rails
       require File.expand_path("#{directory}/config/environment.rb")
       if Rails.configuration.eager_load
-        RocketJob::Server.logger.benchmark_info('Eager loaded Rails and all Engines') do
+        RocketJob::Worker.logger.benchmark_info('Eager loaded Rails and all Engines') do
           Rails.application.eager_load!
           Rails::Engine.subclasses.each { |engine| engine.eager_load! }
         end
@@ -53,7 +53,7 @@ module RocketJob
     # Parse command line options placing results in the corresponding instance variables
     def parse(argv)
       parser = OptionParser.new do |o|
-        o.on('-n', '--name NAME', 'Unique Name of this server instance (Default: hostname:PID)') { |arg| @name = arg }
+        o.on('-n', '--name NAME', 'Unique Name of this worker instance (Default: hostname:PID)') { |arg| @name = arg }
         o.on('-t', '--threads COUNT', 'Number of worker threads to start') { |arg| @threads = arg.to_i }
         o.on('-q', '--quiet', 'Do not write to stdout, only to logfile. Necessary when running as a daemon') { @quiet = true }
         o.on('-d', '--dir DIR', 'Directory containing Rails app, if not current directory') { |arg| @directory = arg }

data/lib/rocket_job/concerns/worker.rb

@@ -29,10 +29,10 @@ module RocketJob
         # Create a job and process it immediately in-line by this thread
         def now(method, *args, &block)
           job = build(method, *args, &block)
-          server = Server.new(name: 'inline')
-          server.started
+          worker = RocketJob::Worker.new(name: 'inline')
+          worker.started
           job.start
-          while job.running? && !job.work(server)
+          while job.running? && !job.work(worker)
           end
           job
         end
@@ -86,7 +86,7 @@ module RocketJob
       # is set in the job itself.
       #
       # Thread-safe, can be called by multiple threads at the same time
-      def work(server)
+      def work(worker)
         raise 'Job must be started before calling #work' unless running?
         begin
           # before_perform
@@ -102,7 +102,7 @@ module RocketJob
           call_method(perform_method, arguments, event: :after, log_level: log_level)
           complete!
         rescue Exception => exc
-          set_exception(server.name, exc)
+          set_exception(worker.name, exc)
           raise exc if RocketJob::Config.inline_mode
         end
         false

data/lib/rocket_job/config.rb

@@ -21,16 +21,16 @@ module RocketJob
     end
 
     # By enabling inline_mode jobs will be called in-line
-    # No server processes will be created, nor threads created
+    # No worker processes will be created, nor threads created
     sync_cattr_accessor(:inline_mode) { false }
 
-    # The maximum number of worker threads to create on any one server
+    # The maximum number of worker threads to create on any one worker
     key :max_worker_threads,         Integer, default: 10
 
-    # Number of seconds between heartbeats from Rocket Job Server processes
+    # Number of seconds between heartbeats from Rocket Job Worker processes
     key :heartbeat_seconds,          Integer, default: 15
 
-    # Maximum number of seconds a Server will wait before checking for new jobs
+    # Maximum number of seconds a Worker will wait before checking for new jobs
     key :max_poll_seconds,           Integer, default: 5
 
     # Number of seconds between checking for:
@@ -44,21 +44,21 @@ module RocketJob
     #   Not all job types support pausing in the middle
     key :re_check_seconds,           Integer, default: 60
 
-    # Limit the number of workers per job class per server
+    # Limit the number of workers per job class per worker
     #    'class_name' / group => 100
     #key :limits, Hash
 
     # Replace the MongoMapper default mongo connection for holding jobs
     def self.mongo_connection=(connection)
       connection(connection)
-      Server.connection(connection)
+      Worker.connection(connection)
       Job.connection(connection)
       Config.connection(connection)
       DirmonEntry.connection(connection)
 
       db_name = connection.db.name
       set_database_name(db_name)
-      Server.set_database_name(db_name)
+      Worker.set_database_name(db_name)
       Job.set_database_name(db_name)
       Config.set_database_name(db_name)
       DirmonEntry.set_database_name(db_name)
@@ -68,7 +68,7 @@ module RocketJob
     # Allows the records and results to be stored in a separate Mongo database
     # from the Jobs themselves.
     #
-    # It is recommended to set the work_connection to a local Mongo Server that
+    # It is recommended to set the work_connection to a local Mongo Worker that
     # is not replicated to another data center to prevent flooding the network
     # with replication of data records and results.
     # The jobs themselves can/should be replicated across data centers so that

data/lib/rocket_job/heartbeat.rb

@@ -2,13 +2,13 @@
 module RocketJob
   # Heartbeat
   #
-  # Information from the server as at it's last heartbeat
+  # Information from the worker as at it's last heartbeat
   class Heartbeat
     include MongoMapper::EmbeddedDocument
 
-    embedded_in :server
+    embedded_in :worker
 
-    # Time of the last heartbeat received from this server
+    # Time of the last heartbeat received from this worker
     key :updated_at,                 Time
 
     # Number of threads running as at the last heartbeat interval
@@ -21,9 +21,9 @@ module RocketJob
     # Process Information
     #
 
-    # Percentage utilization for the server process alone
+    # Percentage utilization for the worker process alone
     key :process_cpu,                Integer
-    # Kilo Bytes used by the server process (Virtual & Physical)
+    # Kilo Bytes used by the worker process (Virtual & Physical)
     key :process_mem_phys_kb,        Integer
     key :process_mem_virt_kb,        Integer
 

data/lib/rocket_job/job.rb

@@ -94,8 +94,8 @@ module RocketJob
     # Number of times that this job has failed to process
     key :failure_count,           Integer, default: 0
 
-    # This name of the server that this job is being processed by, or was processed by
-    key :server_name,             String
+    # This name of the worker that this job is being processed by, or was processed by
+    key :worker_name,             String
 
     #
     # Values that jobs can update during processing
@@ -196,11 +196,11 @@ module RocketJob
       ensure_index [[:created_at, 1]]
     end
 
-    # Requeue all jobs for the specified dead server
-    def self.requeue_dead_server(server_name)
+    # Requeue all jobs for the specified dead worker
+    def self.requeue_dead_worker(worker_name)
       collection.update(
-        { 'server_name' => server_name, 'state' => :running },
-        { '$unset' => { 'server_name' => true, 'started_at' => true }, '$set' => { 'state' => :queued } },
+        { 'worker_name' => worker_name, 'state' => :running },
+        { '$unset' => { 'worker_name' => true, 'started_at' => true }, '$set' => { 'state' => :queued } },
         multi: true
       )
     end
@@ -220,17 +220,18 @@ module RocketJob
       collect_output == true
     end
 
-    # Returns [Time] how long the job has taken to complete
-    # If not started then it is the time spent waiting in the queue
-    def duration
-      seconds = if completed_at
+    # Returns [Float] the number of seconds the job has taken
+    # - Elapsed seconds to process the job from when a worker first started working on it
+    #   until now if still running, or until it was completed
+    # - Seconds in the queue if queued
+    def seconds
+      if completed_at
         completed_at - (started_at || created_at)
       elsif started_at
         Time.now - started_at
       else
         Time.now - created_at
       end
-      Time.at(seconds)
     end
 
     # A job has expired if the expiry time has passed before it is started
@@ -239,28 +240,46 @@ module RocketJob
     end
 
     # Returns [Hash] status of this job
-    def status(time_zone='Eastern Time (US & Canada)')
-      h = {
-        state:                state,
-        description:          description
-      }
-      h[:started_at]         = started_at.in_time_zone(time_zone) if started_at
-
+    def as_json
+      attrs = serializable_hash(methods: :seconds)
+      attrs.delete('result') unless collect_output?
       case
-      when running? || paused?
-        h[:paused_at]        = completed_at.in_time_zone(time_zone) if paused?
-        h[:percent_complete] = percent_complete if percent_complete
-      when completed?
-        h[:completed_at]     = completed_at.in_time_zone(time_zone)
+      when running?
+        attrs.delete('completed_at')
+        attrs.delete('result')
+        attrs
+      when paused?
+        attrs.delete('completed_at')
+        attrs.delete('result')
+        # Ensure 'paused_at' appears first in the hash
+        { 'paused_at' => completed_at }.merge(attrs)
       when aborted?
-        h[:aborted_at]       = completed_at.in_time_zone(time_zone)
-        h[:percent_complete] = percent_complete if percent_complete
+        attrs.delete('completed_at')
+        attrs.delete('result')
+        { 'aborted_at' => completed_at }.merge(attrs)
       when failed?
-        h[:failed_at]        = completed_at.in_time_zone(time_zone)
-        h[:percent_complete] = percent_complete if percent_complete
-        h[:exception]        = exception.nil? ? {} : exception.attributes
+        attrs.delete('completed_at')
+        attrs.delete('result')
+        { 'failed_at' => completed_at }.merge(attrs)
+      else
+        attrs
+      end
+    end
+
+    def status(time_zone='Eastern Time (US & Canada)')
+      h = as_json
+      if seconds = h.delete('seconds')
+        h['duration'] = seconds_as_duration(seconds)
+      end
+      h.delete('perform_method') if h['perform_method'] == :perform
+      h.dup.each_pair do |k,v|
+        case
+        when v.kind_of?(Time)
+          h[k] = v.in_time_zone(time_zone).to_s
+        when v.kind_of?(BSON::ObjectId)
+          h[k] = v.to_s
+        end
       end
-      h[:duration]           = duration.strftime('%H:%M:%S')
       h
     end
 
@@ -288,6 +307,7 @@ module RocketJob
       self.arguments = arguments.collect {|i| i.is_a?(BSON::OrderedHash) ? i.with_indifferent_access : i  } if arguments.present?
     end
 
+    ############################################################################
     protected
 
     # Before events that can be overridden by child classes
@@ -320,23 +340,34 @@ module RocketJob
       self.completed_at = Time.now
     end
 
-    ############################################################################
-    protected
+    # 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}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
-    #   server_name [String]
-    #     Name of the server that will be processing this job
+    #   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(server_name, skip_job_ids = nil)
+    def self.next_job(worker_name, skip_job_ids = nil)
       query = {
         '$and' => [
           {
@@ -358,7 +389,7 @@ module RocketJob
       while doc = find_and_modify(
           query:  query,
           sort:   [['priority', 'asc'], ['created_at', 'asc']],
-          update: { '$set' => { 'server_name' => server_name, 'state' => 'running' } }
+          update: { '$set' => { 'worker_name' => worker_name, 'state' => 'running' } }
         )
         job = load(doc)
         if job.running?
@@ -381,11 +412,11 @@ module RocketJob
     private
 
     # Set exception information for this job
-    def set_exception(server_name, exc)
-      self.server_name = nil
+    def set_exception(worker_name, exc)
+      self.worker_name = nil
       self.failure_count += 1
       self.exception = JobException.from_exception(exc)
-      exception.server_name = server_name
+      exception.worker_name = worker_name
       fail! unless failed?
       logger.error("Exception running #{self.class.name}##{perform_method}", exc)
     end

data/lib/rocket_job/job_exception.rb

@@ -2,7 +2,7 @@
 module RocketJob
   # Heartbeat
   #
-  # Information from the server as at it's last heartbeat
+  # Information from the worker as at it's last heartbeat
   class JobException
     include MongoMapper::EmbeddedDocument
 
@@ -15,8 +15,8 @@ module RocketJob
     # Exception Backtrace [Array<String>]
     key :backtrace,               Array
 
-    # Name of the server on which this exception occurred
-    key :server_name,             String
+    # Name of the worker on which this exception occurred
+    key :worker_name,             String
 
     # The record within which this exception occurred
     key :record_number,           Integer

data/lib/rocket_job/version.rb

@@ -1,4 +1,4 @@
 # encoding: UTF-8
 module RocketJob #:nodoc
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/rocket_job/{server.rb → worker.rb}

@@ -3,31 +3,31 @@ require 'socket'
 require 'sync_attr'
 require 'aasm'
 module RocketJob
-  # Server
+  # Worker
   #
-  # On startup a server instance will automatically register itself
+  # On startup a worker instance will automatically register itself
   # if not already present
   #
-  # Starting a server in the foreground:
+  # Starting a worker in the foreground:
   #   - Using a Rails runner:
   #     bin/rocketjob
   #
-  # Starting a server in the background:
+  # Starting a worker in the background:
   #   - Using a Rails runner:
   #     nohup bin/rocketjob --quiet 2>&1 1>output.log &
   #
-  # Stopping a server:
-  #   - Stop the server via the Web UI
+  # Stopping a worker:
+  #   - Stop the worker via the Web UI
   #   - Send a regular kill signal to make it shutdown once all active work is complete
   #       kill <pid>
   #   - Or, use the following Ruby code:
-  #     server = RocketJob::Server.where(name: 'server name').first
-  #     server.stop!
+  #     worker = RocketJob::Worker.where(name: 'worker name').first
+  #     worker.stop!
   #
   #   Sending the kill signal locally will result in starting the shutdown process
-  #   immediately. Via the UI or Ruby code the server can take up to 15 seconds
+  #   immediately. Via the UI or Ruby code the worker can take up to 15 seconds
   #   (the heartbeat interval) to start shutting down.
-  class Server
+  class Worker
     include MongoMapper::Document
     include AASM
     include SyncAttr
@@ -36,21 +36,21 @@ module RocketJob
     # Prevent data in MongoDB from re-defining the model behavior
     #self.static_keys = true
 
-    # Unique Name of this server instance
-    #   Defaults to the `hostname` but _must_ be overriden if mutiple Server instances
+    # Unique Name of this worker instance
+    #   Defaults to the `hostname` but _must_ be overriden if mutiple Worker instances
     #   are started on the same host
     # The unique name is used on re-start to re-queue any jobs that were being processed
-    # at the time the server or host unexpectedly terminated, if any
+    # at the time the worker or host unexpectedly terminated, if any
     key :name,               String, default: -> { "#{Socket.gethostname}:#{$$}" }
 
     # The maximum number of threads that this worker should use
     #   If set, it will override the default value in RocketJob::Config
     key :max_threads,        Integer, default: -> { Config.instance.max_worker_threads }
 
-    # When this server process was started
+    # When this worker process was started
     key :started_at,         Time
 
-    # The heartbeat information for this server
+    # The heartbeat information for this worker
     one :heartbeat,          class_name: 'RocketJob::Heartbeat'
 
     # Current state
@@ -89,20 +89,20 @@ module RocketJob
 
     attr_reader :thread_pool
 
-    # Requeue any jobs being worked by this server when it is destroyed
+    # Requeue any jobs being worked by this worker when it is destroyed
     before_destroy :requeue_jobs
 
-    # Run the server process
+    # Run the worker process
     # Attributes supplied are passed to #new
     def self.run(attrs={})
-      server = new(attrs)
-      server.build_heartbeat
-      server.save!
+      worker = new(attrs)
+      worker.build_heartbeat
+      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
       logger.info "Using MongoDB Database: #{RocketJob::Job.database.name}"
-      server.run
+      worker.run
     end
 
     # Create indexes
@@ -112,40 +112,40 @@ module RocketJob
       Job.create_indexes
     end
 
-    # Destroy dead servers ( missed at least the last 4 heartbeats )
-    # Requeue jobs assigned to dead servers
-    # Destroy dead servers
-    def self.destroy_dead_servers
+    # 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
-      each do |server|
-        next if (Time.now - server.heartbeat.updated_at) < dead_seconds
-        logger.warn "Destroying server #{server.name}, and requeueing its jobs"
-        server.destroy
+      each do |worker|
+        next if (Time.now - worker.heartbeat.updated_at) < dead_seconds
+        logger.warn "Destroying worker #{worker.name}, and requeueing its jobs"
+        worker.destroy
       end
     end
 
-    # Stop all running, paused, or starting servers
+    # Stop all running, paused, or starting workers
     def self.stop_all
-      where(state: ['running', 'paused', 'starting']).each { |server| server.stop! }
+      where(state: ['running', 'paused', 'starting']).each { |worker| worker.stop! }
     end
 
-    # Pause all running servers
+    # Pause all running workers
     def self.pause_all
-      where(state: 'running').each { |server| server.pause! }
+      where(state: 'running').each { |worker| worker.pause! }
     end
 
-    # Resume all paused servers
+    # Resume all paused workers
     def self.resume_all
-      each { |server| server.resume! if server.paused? }
+      each { |worker| worker.resume! if worker.paused? }
     end
 
-    # Register a handler to perform cleanups etc. whenever a server is
+    # Register a handler to perform cleanups etc. whenever a worker is
     # explicitly destroyed
     def self.register_destroy_handler(&block)
       @@destroy_handlers << block
     end
 
-    # Returns [Boolean] whether the server is shutting down
+    # Returns [Boolean] whether the worker is shutting down
     def shutting_down?
       if self.class.shutdown
         stop! if running?
@@ -160,7 +160,7 @@ module RocketJob
       @thread_pool ||= []
     end
 
-    # Run this instance of the server
+    # Run this instance of the worker
     def run
       Thread.current.name = 'RocketJob main'
       build_heartbeat unless heartbeat
@@ -168,17 +168,17 @@ module RocketJob
       started
       adjust_thread_pool(true)
       save
-      logger.info "RocketJob Server started with #{max_threads} workers running"
+      logger.info "RocketJob Worker started with #{max_threads} workers running"
 
       count = 0
       loop do
-        # Update heartbeat so that monitoring tools know that this server is alive
+        # Update heartbeat so that monitoring tools know that this worker is alive
         set(
           'heartbeat.updated_at'      => Time.now,
           'heartbeat.current_threads' => thread_pool_count
         )
 
-        # Reload the server model every 10 heartbeats in case its config was changed
+        # Reload the worker model every 10 heartbeats in case its config was changed
         # TODO make 3 configurable
         if count >= 3
           reload
@@ -188,7 +188,7 @@ module RocketJob
           count += 1
         end
 
-        # Stop server if shutdown signal was raised
+        # Stop worker if shutdown signal was raised
         stop! if self.class.shutdown && !stopping?
 
         break if stopping?
@@ -204,9 +204,9 @@ module RocketJob
       thread_pool.each { |t| t.join }
       logger.info 'Shutdown'
     rescue Exception => exc
-      logger.error('RocketJob::Server is stopping due to an exception', exc)
+      logger.error('RocketJob::Worker is stopping due to an exception', exc)
     ensure
-      # Destroy this server instance
+      # Destroy this worker instance
       destroy
     end
 
@@ -258,7 +258,7 @@ module RocketJob
       end
     end
 
-    # Keep processing jobs until server stops running
+    # Keep processing jobs until worker stops running
     def worker(worker_id)
       Thread.current.name = "rocketjob #{worker_id}"
       logger.info 'Started'
@@ -271,7 +271,7 @@ module RocketJob
           sleep RocketJob::Config.instance.max_poll_seconds
         end
       end
-      logger.info "Stopping. Server state: #{state.inspect}"
+      logger.info "Stopping. Worker state: #{state.inspect}"
     rescue Exception => exc
       logger.fatal('Unhandled exception in job processing thread', exc)
     end
@@ -294,7 +294,7 @@ module RocketJob
       false
     end
 
-    # Requeue any jobs assigned to this server
+    # Requeue any jobs assigned to this worker
     def requeue_jobs
       stop! if running? || paused?
       @@destroy_handlers.each { |handler| handler.call(name) }

data/lib/rocketjob.rb

@@ -12,7 +12,7 @@ module RocketJob
   autoload :Heartbeat,             'rocket_job/heartbeat'
   autoload :Job,                   'rocket_job/job'
   autoload :JobException,          'rocket_job/job_exception'
-  autoload :Server,                'rocket_job/server'
+  autoload :Worker,                'rocket_job/worker'
   module Concerns
     autoload :Worker,              'rocket_job/concerns/worker'
   end

data/test/dirmon_job_test.rb

@@ -5,8 +5,8 @@ require_relative 'jobs/test_job'
 class DirmonJobTest < Minitest::Test
   context RocketJob::Jobs::DirmonJob do
     setup do
-      @server = RocketJob::Server.new
-      @server.started
+      @worker = RocketJob::Worker.new
+      @worker.started
       @dirmon_job   = RocketJob::Jobs::DirmonJob.new
       @archive_directory = '/tmp/archive_directory'
       @entry        = RocketJob::DirmonEntry.new(

data/test/job_test.rb

@@ -5,8 +5,8 @@ require_relative 'jobs/test_job'
 class JobTest < Minitest::Test
   context RocketJob::Job do
     setup do
-      @server = RocketJob::Server.new
-      @server.started
+      @worker = RocketJob::Worker.new
+      @worker.started
       @description = 'Hello World'
       @arguments   = [ 1 ]
       @job = Jobs::TestJob.new(
@@ -46,7 +46,7 @@ class JobTest < Minitest::Test
     context '#save!' do
       should 'save a blank job' do
         @job.save!
-        assert_nil   @job.server_name
+        assert_nil   @job.worker_name
         assert_nil   @job.completed_at
         assert       @job.created_at
         assert_equal @description, @job.description
@@ -66,8 +66,8 @@ class JobTest < Minitest::Test
       should 'return status for a queued job' do
         assert_equal true, @job.queued?
         h = @job.status
-        assert_equal :queued,       h[:state]
-        assert_equal @description,  h[:description]
+        assert_equal :queued,       h['state']
+        assert_equal @description,  h['description']
       end
 
       should 'return status for a failed job' do
@@ -79,17 +79,17 @@ class JobTest < Minitest::Test
         @job.fail!
         assert_equal true, @job.failed?
         h = @job.status
-        assert_equal :failed,       h[:state]
-        assert_equal @description,  h[:description]
-        assert_equal 'Test',        h[:exception][:class_name], h
-        assert_equal 'hello world', h[:exception][:message], h
+        assert_equal :failed,       h['state']
+        assert_equal @description,  h['description']
+        assert_equal 'Test',        h['exception']['class_name'], h
+        assert_equal 'hello world', h['exception']['message'], h
       end
     end
 
     context '#work' do
       should 'call default perform method' do
         @job.start!
-        assert_equal false, @job.work(@server)
+        assert_equal false, @job.work(@worker)
         assert_equal true,  @job.completed?, @job.state
         assert_equal 2,     Jobs::TestJob.result
       end
@@ -98,7 +98,7 @@ class JobTest < Minitest::Test
         @job.perform_method = :sum
         @job.arguments = [ 23, 45 ]
         @job.start!
-        assert_equal false, @job.work(@server)
+        assert_equal false, @job.work(@worker)
         assert_equal true, @job.completed?
         assert_equal 68,    Jobs::TestJob.result
       end
@@ -106,7 +106,7 @@ class JobTest < Minitest::Test
       should 'destroy on complete' do
         @job.destroy_on_complete = true
         @job.start!
-        assert_equal false, @job.work(@server)
+        assert_equal false, @job.work(@worker)
         assert_equal nil, RocketJob::Job.find_by_id(@job.id)
       end
 
@@ -118,7 +118,7 @@ class JobTest < Minitest::Test
         @job.start!
         logged = false
         Jobs::TestJob.logger.stub(:log_internal, -> level, index, message, payload, exception { logged = true if message.include?('some very noisy logging')}) do
-          assert_equal false, @job.work(@server), @job.inspect
+          assert_equal false, @job.work(@worker), @job.inspect
         end
         assert_equal false, logged
       end
@@ -133,7 +133,7 @@ class JobTest < Minitest::Test
         # Raise global log level to :info
         SemanticLogger.stub(:default_level_index, 3) do
           Jobs::TestJob.logger.stub(:log_internal, -> { logged = true }) do
-            assert_equal false, @job.work(@server)
+            assert_equal false, @job.work(@worker)
           end
         end
         assert_equal false, logged
@@ -144,7 +144,7 @@ class JobTest < Minitest::Test
         @job.perform_method = :event
         @job.arguments = [ named_parameters ]
         @job.start!
-        assert_equal false, @job.work(@server), @job.inspect
+        assert_equal false, @job.work(@worker), @job.inspect
         assert_equal true, @job.completed?
         assert_equal named_parameters.merge('before_event' => true, 'after_event' => true), @job.arguments.first
       end
@@ -157,25 +157,25 @@ class JobTest < Minitest::Test
       end
 
       should 'return nil when no jobs available' do
-        assert_equal nil, RocketJob::Job.next_job(@server.name)
+        assert_equal nil, RocketJob::Job.next_job(@worker.name)
       end
 
       should 'return the first job' do
         @job.save!
-        assert job = RocketJob::Job.next_job(@server.name), "Failed to find job"
+        assert job = RocketJob::Job.next_job(@worker.name), "Failed to find job"
         assert_equal @job.id, job.id
       end
 
       should 'Ignore future dated jobs' do
         @job.run_at = Time.now + 1.hour
         @job.save!
-        assert_equal nil, RocketJob::Job.next_job(@server.name)
+        assert_equal nil, RocketJob::Job.next_job(@worker.name)
       end
 
       should 'Process future dated jobs when time is now' do
         @job.run_at = Time.now
         @job.save!
-        assert job = RocketJob::Job.next_job(@server.name), "Failed to find future job"
+        assert job = RocketJob::Job.next_job(@worker.name), "Failed to find future job"
         assert_equal @job.id, job.id
       end
 
@@ -183,7 +183,7 @@ class JobTest < Minitest::Test
         count = RocketJob::Job.count
         @job.expires_at = Time.now - 100
         @job.save!
-        assert_equal nil, RocketJob::Job.next_job(@server.name)
+        assert_equal nil, RocketJob::Job.next_job(@worker.name)
         assert_equal count, RocketJob::Job.count
       end
 

data/test/job_worker_test.rb

@@ -0,0 +1,85 @@
+require_relative 'test_helper'
+require_relative 'jobs/test_job'
+
+# Unit Test for RocketJob::Job
+class WorkerTest < Minitest::Test
+  context RocketJob::Job do
+    [true, false].each do |inline_mode|
+      setup do
+        RocketJob::Config.inline_mode = inline_mode
+        @worker = RocketJob::Worker.new
+        @worker.started
+      end
+
+      teardown do
+        @job.destroy if @job && !@job.new_record?
+        RocketJob::Config.inline_mode = false
+      end
+
+      context '.perform_later' do
+        should "process single request (inline_mode=#{inline_mode})" do
+          @job = Jobs::TestJob.perform_later(1) do |job|
+            job.destroy_on_complete = false
+          end
+          assert_nil   @job.worker_name
+          assert_nil   @job.completed_at
+          assert       @job.created_at
+          assert_nil   @job.description
+          assert_equal false, @job.destroy_on_complete
+          assert_nil   @job.expires_at
+          assert_equal 0, @job.percent_complete
+          assert_equal 50, @job.priority
+          assert_equal 0, @job.failure_count
+          assert_nil   @job.run_at
+          assert_nil   @job.started_at
+          assert_equal :queued, @job.state
+
+          @job.worker_name = 'me'
+          @job.start
+          assert_equal false,    @job.work(@worker), @job.exception.inspect
+          assert_equal true, @job.completed?
+          assert_equal 2,    Jobs::TestJob.result
+
+          assert       @job.worker_name
+          assert       @job.completed_at
+          assert       @job.created_at
+          assert_nil   @job.description
+          assert_equal false, @job.destroy_on_complete
+          assert_nil   @job.expires_at
+          assert_equal 100, @job.percent_complete
+          assert_equal 50, @job.priority
+          assert_equal 0, @job.failure_count
+          assert_nil   @job.run_at
+          assert       @job.started_at
+        end
+      end
+
+      context '.later' do
+        should "process non default method (inline_mode=#{inline_mode})" do
+          @job = Jobs::TestJob.later(:sum, 23, 45)
+          @job.start
+          assert_equal false, @job.work(@worker), @job.exception.inspect
+          assert_equal true,  @job.completed?
+          assert_equal 68,    Jobs::TestJob.result
+        end
+      end
+
+      context '.perform_now' do
+        should "process perform (inline_mode=#{inline_mode})" do
+          @job = Jobs::TestJob.perform_now(5)
+          assert_equal true,  @job.completed?
+          assert_equal 6,     Jobs::TestJob.result
+        end
+      end
+
+      context '.now' do
+        should "process non default method (inline_mode=#{inline_mode})" do
+          @job = Jobs::TestJob.now(:sum, 23, 45)
+          assert_equal true,  @job.completed?, @job.inspect
+          assert_equal 68,    Jobs::TestJob.result
+        end
+      end
+
+    end
+  end
+end

data/test/worker_test.rb

@@ -1,85 +1,39 @@
 require_relative 'test_helper'
 require_relative 'jobs/test_job'
 
-# Unit Test for RocketJob::Job
+# Unit Test for RocketJob::Worker
 class WorkerTest < Minitest::Test
-  context RocketJob::Job do
-    [true, false].each do |inline_mode|
-      setup do
-        RocketJob::Config.inline_mode = inline_mode
-        @server = RocketJob::Server.new
-        @server.started
-      end
-
-      teardown do
-        @job.destroy if @job && !@job.new_record?
-        RocketJob::Config.inline_mode = false
-      end
-
-      context '.perform_later' do
-        should "process single request (inline_mode=#{inline_mode})" do
-          @job = Jobs::TestJob.perform_later(1) do |job|
-            job.destroy_on_complete = false
-          end
-          assert_nil   @job.server_name
-          assert_nil   @job.completed_at
-          assert       @job.created_at
-          assert_nil   @job.description
-          assert_equal false, @job.destroy_on_complete
-          assert_nil   @job.expires_at
-          assert_equal 0, @job.percent_complete
-          assert_equal 50, @job.priority
-          assert_equal 0, @job.failure_count
-          assert_nil   @job.run_at
-          assert_nil   @job.started_at
-          assert_equal :queued, @job.state
-
-          @job.server_name = 'me'
-          @job.start
-          assert_equal false,    @job.work(@server), @job.exception.inspect
-          assert_equal true, @job.completed?
-          assert_equal 2,    Jobs::TestJob.result
-
-          assert       @job.server_name
-          assert       @job.completed_at
-          assert       @job.created_at
-          assert_nil   @job.description
-          assert_equal false, @job.destroy_on_complete
-          assert_nil   @job.expires_at
-          assert_equal 100, @job.percent_complete
-          assert_equal 50, @job.priority
-          assert_equal 0, @job.failure_count
-          assert_nil   @job.run_at
-          assert       @job.started_at
-        end
-      end
+  context RocketJob::Worker do
+    setup do
+      RocketJob::Config.instance.heartbeat_seconds = 0.1
+      RocketJob::Config.instance.max_poll_seconds  = 0.1
+      @worker = RocketJob::Worker.new
+      @description = 'Hello World'
+      @arguments   = [ 1 ]
+      @job = Jobs::TestJob.new(
+        description:         @description,
+        arguments:           @arguments,
+        destroy_on_complete: false
+      )
+    end
 
-      context '.later' do
-        should "process non default method (inline_mode=#{inline_mode})" do
-          @job = Jobs::TestJob.later(:sum, 23, 45)
-          @job.start
-          assert_equal false, @job.work(@server), @job.exception.inspect
-          assert_equal true,  @job.completed?
-          assert_equal 68,    Jobs::TestJob.result
-        end
-      end
+    teardown do
+      @job.destroy if @job && !@job.new_record?
+    end
 
-      context '.perform_now' do
-        should "process perform (inline_mode=#{inline_mode})" do
-          @job = Jobs::TestJob.perform_now(5)
-          assert_equal true,  @job.completed?
-          assert_equal 6,     Jobs::TestJob.result
-        end
+    context '.config' do
+      should 'support multiple databases' do
+        assert_equal 'test_rocketjob', RocketJob::Job.collection.db.name
       end
+    end
 
-      context '.now' do
-        should "process non default method (inline_mode=#{inline_mode})" do
-          @job = Jobs::TestJob.now(:sum, 23, 45)
-          assert_equal true,  @job.completed?, @job.inspect
-          assert_equal 68,    Jobs::TestJob.result
-        end
+    context '#run' do
+      should 'run a worker' do
+        Thread.new { sleep 1; @worker.stop!}
+        @worker.run
+        assert_equal :stopping, @worker.state, @worker.inspect
       end
-
     end
+
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rocketjob
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-20 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aasm
@@ -128,14 +128,14 @@ files:
 - lib/rocket_job/job.rb
 - lib/rocket_job/job_exception.rb
 - lib/rocket_job/jobs/dirmon_job.rb
-- lib/rocket_job/server.rb
 - lib/rocket_job/version.rb
+- lib/rocket_job/worker.rb
 - lib/rocketjob.rb
 - test/config/mongo.yml
 - test/dirmon_job_test.rb
 - test/job_test.rb
+- test/job_worker_test.rb
 - test/jobs/test_job.rb
-- test/server_test.rb
 - test/test_helper.rb
 - test/worker_test.rb
 homepage: https://github.com/rocketjob/rocketjob
@@ -166,7 +166,7 @@ test_files:
 - test/config/mongo.yml
 - test/dirmon_job_test.rb
 - test/job_test.rb
+- test/job_worker_test.rb
 - test/jobs/test_job.rb
-- test/server_test.rb
 - test/test_helper.rb
 - test/worker_test.rb

data/test/server_test.rb

@@ -1,39 +0,0 @@
-require_relative 'test_helper'
-require_relative 'jobs/test_job'
-
-# Unit Test for RocketJob::Server
-class ServerTest < Minitest::Test
-  context RocketJob::Server do
-    setup do
-      RocketJob::Config.instance.heartbeat_seconds = 0.1
-      RocketJob::Config.instance.max_poll_seconds  = 0.1
-      @server = RocketJob::Server.new
-      @description = 'Hello World'
-      @arguments   = [ 1 ]
-      @job = Jobs::TestJob.new(
-        description:         @description,
-        arguments:           @arguments,
-        destroy_on_complete: false
-      )
-    end
-
-    teardown do
-      @job.destroy if @job && !@job.new_record?
-    end
-
-    context '.config' do
-      should 'support multiple databases' do
-        assert_equal 'test_rocketjob', RocketJob::Job.collection.db.name
-      end
-    end
-
-    context '#run' do
-      should 'run a server' do
-        Thread.new { sleep 1; @server.stop!}
-        @server.run
-        assert_equal :stopping, @server.state, @server.inspect
-      end
-    end
-
-  end
-end