workhorse 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0cf16c2d211462d7875c56595c5d624ff30b8cfe
-  data.tar.gz: 4772dce847b5b7aa51f1931baa7a878d34bc0e06
+  metadata.gz: da01b73fc0a4be6598393d2c4b0fbbd917c83233
+  data.tar.gz: 637033b135c6f8fb1c4ad178c05954ba3d495a22
 SHA512:
-  metadata.gz: ca5aec71e437a2e151fa0b3356185c44bc12cb60cf09d817097e15307320247083eab40553da836e3dff911cfb98747c1a991755a72d30bb84f7bbd714544a55
-  data.tar.gz: 1dcfe3bda9f7c1a6d7dac78bf6a795cadb0a59248ec1da72e3a0fba89b91745b7053938f0f2a4570bf48155ae233968399b01a48e6620a53927f59b54444add2
+  metadata.gz: cb5a848ac259293e090c931d3faed8baa23a96087a5724802855340f60a85256e0da57ca30c4b2b600694330fa35d760f2320cd41a6ed3f7a2c88b253f50c8ed
+  data.tar.gz: 8d20351d7fcd8bde6f05eb186efd3b9f64e488d1e3da91b62b489e2564b6df7a2a23983cdb74243c1fc086ec97d504088a2ee5b430b661feb8c2c08065205651

data/CHANGELOG.md

@@ -1,9 +1,27 @@
 # Workhorse Change log
 
-## 0.2.0 - 2017-12-19
+## 0.3.0 – 2017-12-27
+
+### Added
+
+* Option `perform_at` to set earliest execution time of a job
+* Stock job for clean-up of succeeded jobs
+* Example for safe scheduling of repeating jobs
+
+### Changed
+
+* Improved help text output for the daemon
+* Polling intervals can now be multiples of 0.1 instead of integers
+
+### Fixed
+
+* Respect queues even when no job of that queue is running
+* Initial migration now works for both Oracle and MySQL
+
+## 0.2.0 – 2017-12-19
 
 * Adds support for job-level priorities
 
-## 0.1.0 - 2017-12-18
+## 0.1.0 – 2017-12-18
 
 * First feature-complete production release

data/FAQ.md

@@ -66,6 +66,12 @@ Make sure to always start the worker in *production mode*, i.e.:
 RAILS_ENV=production bin/workhorse.rb start
 ```
 
+## I'm getting "No live threads left. Deadlock?" exceptions
+
+Make sure the Worker is logging somewhere and check the logs. Typically there is
+an underlying error that leads to the exception, e.g. missing migration in
+production mode.
+
 ## Why does workhorse not support timeouts?
 
 Generic timeout implementations are [a dangerous thing](http://www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/) in Ruby. This is why we decided against providing this feature in Workhorse and recommend to implement the timeouts inside of your jobs - i.e. via network timeouts.

data/README.md

@@ -11,21 +11,23 @@ How it works:
 
 * Jobs are instances of classes that support the `perform` method.
 * Jobs are persisted in the database using ActiveRecord.
+* Each job has a priority, the default being 0. Jobs with higher priorities
+  (lower is higher, 0 the highest) get processed first.
+* Each job can be set to execute after a certain date / time.
 * You can start one or more worker processes.
 * Each worker is configurable as to which queue(s) it processes. Jobs in the
   same queue never run simultaneously. Jobs with no queue can always run in
   parallel.
-* Each job has a priority, the default being 0. Jobs with higher priorities
-  (lower is higher, 0 the highest) get processed first.
-* Each worker polls the database and spawns a number of threads to execute jobs
-  of different queues simultaneously.
+* Each worker polls the database and spawns a configurable number of threads to
+  execute jobs of different queues simultaneously.
 
 What it does not do:
 
 * It does not spawn new processes on the fly. Jobs are run in separate threads
   but not in separate processes (unless you manually start multiple worker
   processes).
-* It does not support retries, timeouts, and timed execution.
+* It does not support
+  [timeouts](FAQ.md#why-does-workhorse-not-support-timeouts) and timed execution.
 
 ## Installation
 
@@ -35,8 +37,8 @@ What it does not do:
   MySQL with InnoDB, PostgreSQL, or Oracle).
 * If you are planning on using the daemons handler:
   * An operating system and file system that supports file locking.
-  * MRI ruby (aka "c ruby") as jRuby does not support `fork`. See the
-    [FAQ](FAQ.md##im-using-jruby-how-can-i-use-the-daemon-handler) for possible workarounds.
+  * MRI ruby (aka "CRuby") as jRuby does not support `fork`. See the
+    [FAQ](FAQ.md#im-using-jruby-how-can-i-use-the-daemon-handler) for possible workarounds.
 
 ### Installing under Rails
 
@@ -51,7 +53,7 @@ What it does not do:
 2. Run the install generator:
 
    ```bash
-   bin/rails generate workhorse:install
+   bundle exec rails generate workhorse:install
    ```
 
    This generates:
@@ -100,10 +102,87 @@ at job execution.
 If you do not want to pass any params to the operation, just omit the second hash:
 
 ```ruby
-Workhorse.enqueue_op Operations::Jobs::CleanUpDatabase, queue: :maintenance,
-priority: 2
+Workhorse.enqueue_op Operations::Jobs::CleanUpDatabase, queue: :maintenance, priority: 2
 ```
 
+### Scheduling
+
+Workhorse has no out-of-the-box functionality to support scheduling of regular
+jobs, such as maintenance or backup jobs. There are two primary ways of
+achieving regular execution:
+
+1. Rescheduling by the same job after successful execution and setting
+   `perform_at`
+
+   This is simple to set up and requires no additional dependencies. However,
+   the time taken to execute a job and the time delay caused by the polling
+   interval cannot easily be factored into the calculation of the interval,
+   leading to a slight shift in effective execution date. (This can be mitigated
+   by scheduling the job before knowing whether the current run will succeed.
+   Proceed down this path at your own peril!)
+
+   *Example:* A job that takes 5 seconds to run and is set to reschedule itself
+   after 10 minutes is started at 12:00 sharp. After one hour it will be set to
+   execute at 13:00:30 at the earliest.
+
+   In its most basic form, the `perform` method of a job would look as follows:
+
+   ```ruby
+   class MyJob
+     def perform
+       # Do all the work
+
+       # Perform again after 10 minutes (600 seconds)
+       Workhorse.enqueue MyJob.new, perform_at: Time.now + 600
+     end
+   end
+   ```
+
+2. Using an external scheduler
+
+   A more elaborate setup requires an external scheduler, but which can still be
+   called from Ruby. One such scheduler is
+   [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler). A small
+   example of an adapted `bin/workhorse.rb` to accommodate for the additional
+   cog in the mechanism is given below:
+
+   ```ruby
+   #!/usr/bin/env ruby
+   
+   require './config/environment'
+   
+   Workhorse::Daemon::ShellHandler.run do
+     worker = Workhorse::Worker.new(pool_size: 5, polling_interval: 10, logger: Rails.logger)
+     scheduler = Rufus::Scheduler.new
+   
+     worker.start
+   
+     scheduler.cron '0/10 * * * *' do
+       Workhorse.enqueue Workhorse::Jobs::CleanupSucceededJobs.new
+     end
+   
+     Signal.trap 'TERM' do
+       scheduler.shutdown
+       Thread.new do
+         worker.shutdown
+       end.join
+     end
+   
+     scheduler.join
+     worker.wait
+   end
+   ```
+
+   This allows starting and stopping the daemon with the usual interface.
+   Note that the scheduler is handled like a Workhorse worker, the consequence
+   of which is that only one 'worker' should be started by the ShellHandler.
+   Otherwise there would be multiple jobs scheduled at the same time.
+
+   Please refer to the documentation on
+   [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) (or the
+   scheduler of your choice) for further options concerning the timing of the
+   jobs.
+
 ## Configuring and starting workers
 
 Workers poll the database for new jobs and execute them in one or more threads.
@@ -143,7 +222,7 @@ For this case, the workhorse install routine automatically creates the file
 The script can be called as follows:
 
 ```bash
-RAILS_ENV=production bin/workhorse.rb start|stop|status|watch|restart|usage
+RAILS_ENV=production bundle exec bin/workhorse.rb start|stop|status|watch|restart|usage
 ```
 
 #### Background and customization

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/generators/workhorse/templates/create_table_jobs.rb

@@ -15,11 +15,24 @@ class CreateTableJobs < ActiveRecord::Migration[4.2]
       t.text :last_error, limit: 4_294_967_295
 
       t.integer :priority, null: false
+      t.datetime :perform_at, null: true
 
       t.timestamps null: false
     end
 
-    add_index :jobs, :queue
-    add_index :jobs, :state
+    if oracle?
+      add_index :jobs, :queue
+      add_index :jobs, :state
+    else
+      add_index :jobs, :queue, length: 191
+      add_index :jobs, :state, length: 191
+    end
+    add_index :jobs, :perform_at
+  end
+
+  private
+
+  def oracle?
+    ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
   end
 end

data/lib/workhorse.rb

@@ -37,6 +37,7 @@ require 'workhorse/poller'
 require 'workhorse/pool'
 require 'workhorse/worker'
 require 'workhorse/jobs/run_rails_op'
+require 'workhorse/jobs/cleanup_succeeded_jobs'
 
 # Daemon functionality is not available on java platforms
 if RUBY_PLATFORM != 'java'

data/lib/workhorse/daemon/shell_handler.rb

@@ -44,6 +44,28 @@ module Workhorse
       warn <<~USAGE
         Usage: #{$PROGRAM_NAME} start|stop|status|watch|restart|usage
 
+        Options:
+
+          start
+            Start the daemon
+
+          stop
+            Stop the daemon
+
+          status
+            Query the status of the daemon. Exit with status 1 if any worker is
+            not running.
+
+          watch
+            Checks the status (running or stopped) and whether it is as
+            expected. Starts the daemon if it is expected to run but is not.
+
+          restart
+            Shortcut for consecutive 'stop' and 'start'.
+
+          usage
+            Show this message
+
         Exit status:
          0  if OK,
          1  if at least one worker has an unexpected status,

data/lib/workhorse/enqueuer.rb

@@ -1,10 +1,11 @@
 module Workhorse
   module Enqueuer
     # Enqueue any object that is serializable and has a `perform` method
-    def enqueue(job, queue: nil, priority: 0)
+    def enqueue(job, queue: nil, priority: 0, perform_at: Time.now)
       return DbJob.create!(
         queue: queue,
         priority: priority,
+        perform_at: perform_at,
         handler: Marshal.dump(job)
       )
     end

data/lib/workhorse/jobs/cleanup_succeeded_jobs.rb

@@ -0,0 +1,24 @@
+module Workhorse::Jobs
+  class CleanupSucceededJobs
+    # Instantiates a new cleanup job
+    #
+    # @param max_age [Integer] The maximal age of jobs to retain, in days. Will
+    #   be evaluated at perform time.
+    def initialize(max_age: 14)
+      @max_age = max_age
+    end
+
+    def perform
+      age_limit = seconds_ago(@max_age)
+      Workhorse::DbJob.where(
+        'STATE = ? AND UPDATED_AT <= ?', Workhorse::DbJob::STATE_SUCCEEDED, age_limit
+      ).delete_all
+    end
+
+    private
+
+    def seconds_ago(days)
+      Time.now - days * 24 * 60 * 60
+    end
+  end
+end

data/lib/workhorse/poller.rb

@@ -1,10 +1,13 @@
 module Workhorse
   class Poller
     attr_reader :worker
+    attr_reader :table
 
     def initialize(worker)
       @worker = worker
       @running = false
+      @table = Workhorse::DbJob.arel_table
+      @is_oracle = ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
     end
 
     def running?
@@ -44,8 +47,8 @@ module Workhorse
       remaining = worker.polling_interval
 
       while running? && remaining > 0
-        Kernel.sleep 1
-        remaining -= 1
+        Kernel.sleep 0.1
+        remaining -= 0.1
       end
     end
 
@@ -70,10 +73,8 @@ module Workhorse
       end
     end
 
+    # Returns an Array of #{Workhorse::DbJob}s that can be started
     def queued_db_jobs(limit)
-      table = Workhorse::DbJob.arel_table
-      is_oracle = ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
-
       # ---------------------------------------------------------------
       # Lock all queued jobs that are waiting
       # ---------------------------------------------------------------
@@ -87,9 +88,100 @@ module Workhorse
       # ---------------------------------------------------------------
       # Select jobs to execute
       # ---------------------------------------------------------------
+      #
+      # Construct selects for each queue which then are UNIONed for the final
+      # set. This is required because we only want the first job of each queue
+      # to be posted.
+      union_parts = []
+      valid_queues.each do |queue|
+        # Start with a fresh select, as we now know the allowed queues
+        select = valid_ordered_select
+        select = select.where(table[:queue].eq(queue))
+
+        # Get the maximum amount possible for no-queue jobs. This gives us the
+        # smallest possible set from which to draw the final set of jobs without
+        # any presumptions on the order.
+        record_number = queue.nil? ? limit : 1
+
+        union_parts << agnostic_limit(select, record_number)
+      end
+
+      return [] if union_parts.empty?
+
+      # Combine the jobs of each queue in a giant UNION chain. Arel does not
+      # support this directly, as it does not generate parentheses around the
+      # subselects.
+      # Furthermore, add the alias directly instead of using Arel `as`, because
+      # it uses the keyword 'AS' in SQL generated for Oracle, which is invalid
+      # for table aliases.
+      union_query_sql = '('
+      union_query_sql += '(' + union_parts.shift.to_sql + ')'
+      union_parts.each do |part|
+        union_query_sql += ' UNION (' + part.to_sql + ')'
+      end
+      union_query_sql += ') subselect'
+
+      # Create a new SelectManager to work with, using the UNION as data source
+      select = Arel::SelectManager.new(Arel.sql(union_query_sql))
+      select = order(select.project(Arel.star))
+
+      # Limit number of records
+      select = agnostic_limit(select, limit)
+
+      # Wrap the entire query in an other subselect to enable locking under
+      # Oracle SQL. As MySQL is able to lock the records without this additional
+      # complication, only do this when using the Oracle backend.
+      if @is_oracle
+        select = Arel::SelectManager.new(Arel.sql('(' + select.to_sql + ')'))
+        select = table.project(Arel.star).where(table[:id].in(select.project(:id)))
+      end
+
+      select = select.lock
+
+      return Workhorse::DbJob.find_by_sql(select.to_sql)
+    end
 
-      # Fetch all waiting jobs of the correct queues
-      select = table.project(Arel.sql('*')).where(table[:state].eq(:waiting))
+    # Returns a fresh Arel select manager containing all waiting jobs, ordered
+    # with {#order}.
+    #
+    # @return [Arel::SelectManager] the select manager
+    def valid_ordered_select
+      select = table.project(table[Arel.star])
+      select = select.where(table[:state].eq(:waiting))
+      select = select.where(table[:perform_at].lteq(Time.now).or(table[:perform_at].eq(nil)))
+      return order(select)
+    end
+
+    # Orders the records by execution order (first to last)
+    #
+    # @param select [Arel::SelectManager] the select manager to sort
+    # @return [Arel::SelectManager] the passed select manager with sorting on
+    #   top
+    def order(select)
+      select.order(Arel.sql('priority').asc).order(Arel.sql('created_at').asc)
+    end
+
+    # Limits the number of records
+    #
+    # @param select [Arel::SelectManager] the select manager on which to apply
+    #   the limit
+    # @param number [Integer] the maximum number of records to return
+    # @return [Arel::SelectManager] the resultant select manager
+    def agnostic_limit(select, number)
+      return select.where(Arel.sql('ROWNUM').lteq(number)) if @is_oracle
+      return select.take(number)
+    end
+
+    # Returns an Array of queue names for which a job may be posted
+    #
+    # This is done in multiple steps. First, all queues with jobs that are in
+    # progress are removed. Second, restrict to only queues for which we may
+    # post jobs. Third, extract the queue names of the remaining queues and
+    # return them in an Array.
+    #
+    # @return [Array] an array of unique queue names
+    def valid_queues
+      select = valid_ordered_select
 
       # Restrict queues that are currently in progress
       bad_queries_select = table.project(table[:queue])
@@ -97,7 +189,8 @@ module Workhorse
                                 .distinct
       select = select.where(table[:queue].not_in(bad_queries_select))
 
-      # Restrict queues to "open" ones
+      # Restrict queues to valid ones as indicated by the options given to the
+      # worker
       unless worker.queues.empty?
         if worker.queues.include?(nil)
           where = table[:queue].eq(nil)
@@ -112,19 +205,11 @@ module Workhorse
         select = select.where(where)
       end
 
-      # Order by creation date
-      select = select.order(table[:priority].asc).order(table[:created_at].asc)
-
-      # Limit number of records
-      if is_oracle
-        select = select.where(Arel.sql('ROWNUM').lteq(limit))
-      else
-        select = select.take(limit)
-      end
-
-      select = select.lock
-
-      return Workhorse::DbJob.find_by_sql(select.to_sql)
+      # Get the names of all valid queues. The extra project here allows
+      # selecting the last value in each row of the resulting array and getting
+      # the queue name.
+      queues = select.project(:queue)
+      return Workhorse::DbJob.find_by_sql(queues.to_sql).map(&:queue).uniq
     end
   end
 end

data/lib/workhorse/worker.rb

@@ -29,8 +29,7 @@ module Workhorse
     #   number of given queues + 1.
     # @param polling_interval [Integer] Interval in seconds the database will
     #   be polled for new jobs. Set this as high as possible to avoid
-    #   unnecessary database load Set this as high as possible to avoid
-    #   unnecessary database load.
+    #   unnecessary database load. Defaults to 5 minutes.
     # @param auto_terminate [Boolean] Whether to automatically shut down the
     #   worker properly on INT and TERM signals.
     # @param quiet [Boolean] If this is set to `false`, the worker will also log
@@ -38,7 +37,7 @@ module Workhorse
     # @param logger [Logger] An optional logger the worker will append to. This
     #   can be any instance of ruby's `Logger` but is commonly set to
     #   `Rails.logger`.
-    def initialize(queues: [], pool_size: nil, polling_interval: 5, auto_terminate: true, quiet: true, logger: nil)
+    def initialize(queues: [], pool_size: nil, polling_interval: 300, auto_terminate: true, quiet: true, logger: nil)
       @queues = queues
       @pool_size = pool_size || queues.size + 1
       @polling_interval = polling_interval
@@ -51,7 +50,9 @@ module Workhorse
       @poller = Workhorse::Poller.new(self)
       @logger = logger
 
-      fail 'Polling interval must be an integer.' unless @polling_interval.is_a?(Integer)
+      unless (@polling_interval / 0.1).round(2).modulo(1) == 0.0
+        fail 'Polling interval must be a multiple of 0.1.'
+      end
 
       check_rails_env if defined?(Rails)
     end

data/test/lib/db_schema.rb

@@ -16,7 +16,12 @@ ActiveRecord::Schema.define do
     t.text :last_error, limit: 4_294_967_295
 
     t.integer :priority, null: false
+    t.datetime :perform_at, null: true
 
     t.timestamps null: false
   end
+
+  add_index :jobs, :queue, length: 191
+  add_index :jobs, :state, length: 191
+  add_index :jobs, :perform_at
 end

data/test/workhorse/enqueuer_test.rb

@@ -36,9 +36,9 @@ class Workhorse::EnqueuerTest < WorkhorseTest
   def test_op
     Workhorse.enqueue_op DummyRailsOpsOp, { queue: :q1 }, foo: :bar
 
-    w = Workhorse::Worker.new(queues: [:q1])
+    w = Workhorse::Worker.new(queues: [:q1], polling_interval: 0.2)
     w.start
-    sleep 1
+    sleep 0.2
     w.shutdown
 
     assert_equal 'succeeded', Workhorse::DbJob.first.state

data/test/workhorse/performer_test.rb

@@ -4,13 +4,11 @@ class Workhorse::WorkerTest < WorkhorseTest
   # This test makes sure that concurrent jobs always work in different database
   # connections.
   def test_db_connections
-    w = Workhorse::Worker.new polling_interval: 1, pool_size: 5
     2.times do
       Workhorse.enqueue DbConnectionTestJob.new
     end
-    w.start
-    sleep 1
-    w.shutdown
+
+    work 0.2, polling_interval: 0.2
 
     assert_equal 2, DbConnectionTestJob.db_connections.count
     assert_equal 2, DbConnectionTestJob.db_connections.uniq.count

data/test/workhorse/poller_test.rb

@@ -4,9 +4,9 @@ class Workhorse::PollerTest < WorkhorseTest
   def test_interruptable_sleep
     w = Workhorse::Worker.new(polling_interval: 60)
     w.start
-    sleep 0.5
+    sleep 0.1
 
-    Timeout.timeout(1.5) do
+    Timeout.timeout(0.15) do
       w.shutdown
     end
   end

data/test/workhorse/pool_test.rb

@@ -7,21 +7,21 @@ class Workhorse::PoolTest < WorkhorseTest
 
       4.times do |_i|
         p.post do
-          sleep 0.5
+          sleep 0.2
         end
       end
 
       sleep 0.1
       assert_equal 1, p.idle
 
-      sleep 0.5
+      sleep 0.2
       assert_equal 5, p.idle
     end
   end
 
   def test_overflow
     with_pool 5 do |p|
-      5.times { p.post { sleep 0.5 } }
+      5.times { p.post { sleep 0.2 } }
 
       exception = assert_raises do
         p.post { sleep 1 }

data/test/workhorse/worker_test.rb

@@ -2,16 +2,16 @@ require 'test_helper'
 
 class Workhorse::WorkerTest < WorkhorseTest
   def test_idle
-    with_worker(pool_size: 5, polling_interval: 1) do |w|
+    with_worker(pool_size: 5, polling_interval: 0.2) do |w|
       assert_equal 5, w.idle
 
-      sleep 0.5
-      Workhorse.enqueue BasicJob.new(sleep_time: 1)
+      sleep 0.1
+      Workhorse.enqueue BasicJob.new(sleep_time: 0.2)
 
-      sleep 1
+      sleep 0.2
       assert_equal 4, w.idle
 
-      sleep 1
+      sleep 0.2
       assert_equal 5, w.idle
     end
   end
@@ -30,12 +30,12 @@ class Workhorse::WorkerTest < WorkhorseTest
   end
 
   def test_perform
-    with_worker(polling_interval: 1) do
+    with_worker(polling_interval: 0.2) do
       sleep 0.1
       Workhorse.enqueue BasicJob.new(sleep_time: 0.1)
       assert_equal 'waiting', Workhorse::DbJob.first.state
 
-      sleep 1
+      sleep 0.3
     end
 
     assert_equal 'succeeded', Workhorse::DbJob.first.state
@@ -54,24 +54,24 @@ class Workhorse::WorkerTest < WorkhorseTest
   end
 
   def test_term
-    with_worker do |w|
+    with_worker(polling_interval: 0.2) do |w|
       Process.kill 'TERM', Process.pid
-      sleep 1
+      sleep 0.2
       w.assert_state! :shutdown
     end
   end
 
   def test_int
-    with_worker do |w|
+    with_worker(polling_interval: 0.2) do |w|
       Process.kill 'INT', Process.pid
-      sleep 1
+      sleep 0.2
       w.assert_state! :shutdown
     end
   end
 
   def test_no_queues
     enqueue_in_multiple_queues
-    work 1
+    work 0.2, polling_interval: 0.2
 
     jobs = Workhorse::DbJob.order(queue: :asc).to_a
     assert_equal 'succeeded', jobs[0].state
@@ -81,7 +81,7 @@ class Workhorse::WorkerTest < WorkhorseTest
 
   def test_nil_queue
     enqueue_in_multiple_queues
-    work 1, queues: [nil]
+    work 0.2, queues: [nil], polling_interval: 0.2
 
     jobs = Workhorse::DbJob.order(queue: :asc).to_a
     assert_equal 'succeeded', jobs[0].state
@@ -91,7 +91,7 @@ class Workhorse::WorkerTest < WorkhorseTest
 
   def test_queues_with_nil
     enqueue_in_multiple_queues
-    work 1, queues: [nil, :q1]
+    work 0.2, queues: [nil, :q1], polling_interval: 0.2
 
     jobs = Workhorse::DbJob.order(queue: :asc).to_a
     assert_equal 'succeeded', jobs[0].state
@@ -101,7 +101,7 @@ class Workhorse::WorkerTest < WorkhorseTest
 
   def test_queues_without_nil
     enqueue_in_multiple_queues
-    work 1, queues: %i[q1 q2]
+    work 0.2, queues: %i[q1 q2], polling_interval: 0.2
 
     jobs = Workhorse::DbJob.order(queue: :asc).to_a
     assert_equal 'waiting',   jobs[0].state
@@ -109,6 +109,33 @@ class Workhorse::WorkerTest < WorkhorseTest
     assert_equal 'succeeded', jobs[2].state
   end
 
+  def test_multiple_queued_same_queue
+    # One queue
+    Workhorse.enqueue BasicJob.new(sleep_time: 0.2), queue: :q1
+    Workhorse.enqueue BasicJob.new(sleep_time: 0.2), queue: :q1
+
+    work 0.2, polling_interval: 0.2
+
+    jobs = Workhorse::DbJob.all.to_a
+    assert_equal 'succeeded', jobs[0].state
+    assert_equal 'waiting',   jobs[1].state
+
+    # Two queues
+    Workhorse::DbJob.delete_all
+    Workhorse.enqueue BasicJob.new(sleep_time: 0.2), queue: :q1
+    Workhorse.enqueue BasicJob.new(sleep_time: 0.2), queue: :q1
+    Workhorse.enqueue BasicJob.new(sleep_time: 0.2), queue: :q2
+    Workhorse.enqueue BasicJob.new(sleep_time: 0.2), queue: :q2
+
+    work 0.2, polling_interval: 0.2
+
+    jobs = Workhorse::DbJob.order(queue: :asc).to_a
+    assert_equal 'succeeded', jobs[0].state
+    assert_equal 'waiting',   jobs[1].state
+    assert_equal 'succeeded', jobs[2].state
+    assert_equal 'waiting',   jobs[3].state
+  end
+
   def test_order_with_priorities
     Workhorse.enqueue BasicJob.new(some_param: 6, sleep_time: 0), priority: 4
     Workhorse.enqueue BasicJob.new(some_param: 4, sleep_time: 0), priority: 3
@@ -118,10 +145,29 @@ class Workhorse::WorkerTest < WorkhorseTest
     Workhorse.enqueue BasicJob.new(some_param: 1, sleep_time: 0), priority: 0
 
     BasicJob.results.clear
-    work 6.5, pool_size: 1
+    work 1.3, pool_size: 1, polling_interval: 0.2
     assert_equal (1..6).to_a, BasicJob.results
   end
 
+  def test_polling_interval
+    w = Workhorse::Worker.new(polling_interval: 1)
+    w = Workhorse::Worker.new(polling_interval: 1.1)
+    err = assert_raises do
+      w = Workhorse::Worker.new(polling_interval: 1.12)
+    end
+    assert_equal 'Polling interval must be a multiple of 0.1.', err.message
+  end
+
+  def test_perform_at
+    Workhorse.enqueue BasicJob.new(sleep_time: 0), perform_at: Time.now
+    Workhorse.enqueue BasicJob.new(sleep_time: 0), perform_at: Time.now + 600
+    work 0.1, polling_interval: 0.1
+
+    jobs = Workhorse::DbJob.all.to_a
+    assert_equal 'succeeded', jobs[0].state
+    assert_equal 'waiting',   jobs[1].state
+  end
+
   private
 
   def enqueue_in_multiple_queues

data/workhorse.gemspec

@@ -1,16 +1,16 @@
 # -*- encoding: utf-8 -*-
-# stub: workhorse 0.2.0 ruby lib
+# stub: workhorse 0.3.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "workhorse".freeze
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Sitrox".freeze]
-  s.date = "2017-12-19"
-  s.files = [".gitignore".freeze, ".releaser_config".freeze, ".rubocop.yml".freeze, ".travis.yml".freeze, "CHANGELOG.md".freeze, "FAQ.md".freeze, "Gemfile".freeze, "LICENSE".freeze, "README.md".freeze, "RUBY_VERSION".freeze, "Rakefile".freeze, "VERSION".freeze, "bin/rubocop".freeze, "lib/generators/workhorse/install_generator.rb".freeze, "lib/generators/workhorse/templates/bin/workhorse.rb".freeze, "lib/generators/workhorse/templates/config/initializers/workhorse.rb".freeze, "lib/generators/workhorse/templates/create_table_jobs.rb".freeze, "lib/workhorse.rb".freeze, "lib/workhorse/daemon.rb".freeze, "lib/workhorse/daemon/shell_handler.rb".freeze, "lib/workhorse/db_job.rb".freeze, "lib/workhorse/enqueuer.rb".freeze, "lib/workhorse/jobs/run_rails_op.rb".freeze, "lib/workhorse/performer.rb".freeze, "lib/workhorse/poller.rb".freeze, "lib/workhorse/pool.rb".freeze, "lib/workhorse/worker.rb".freeze, "test/lib/db_schema.rb".freeze, "test/lib/jobs.rb".freeze, "test/lib/test_helper.rb".freeze, "test/workhorse/enqueuer_test.rb".freeze, "test/workhorse/performer_test.rb".freeze, "test/workhorse/poller_test.rb".freeze, "test/workhorse/pool_test.rb".freeze, "test/workhorse/worker_test.rb".freeze, "workhorse.gemspec".freeze]
-  s.rubygems_version = "2.6.14".freeze
+  s.date = "2017-12-27"
+  s.files = [".gitignore".freeze, ".releaser_config".freeze, ".rubocop.yml".freeze, ".travis.yml".freeze, "CHANGELOG.md".freeze, "FAQ.md".freeze, "Gemfile".freeze, "LICENSE".freeze, "README.md".freeze, "RUBY_VERSION".freeze, "Rakefile".freeze, "VERSION".freeze, "bin/rubocop".freeze, "lib/generators/workhorse/install_generator.rb".freeze, "lib/generators/workhorse/templates/bin/workhorse.rb".freeze, "lib/generators/workhorse/templates/config/initializers/workhorse.rb".freeze, "lib/generators/workhorse/templates/create_table_jobs.rb".freeze, "lib/workhorse.rb".freeze, "lib/workhorse/daemon.rb".freeze, "lib/workhorse/daemon/shell_handler.rb".freeze, "lib/workhorse/db_job.rb".freeze, "lib/workhorse/enqueuer.rb".freeze, "lib/workhorse/jobs/cleanup_succeeded_jobs.rb".freeze, "lib/workhorse/jobs/run_rails_op.rb".freeze, "lib/workhorse/performer.rb".freeze, "lib/workhorse/poller.rb".freeze, "lib/workhorse/pool.rb".freeze, "lib/workhorse/worker.rb".freeze, "test/lib/db_schema.rb".freeze, "test/lib/jobs.rb".freeze, "test/lib/test_helper.rb".freeze, "test/workhorse/enqueuer_test.rb".freeze, "test/workhorse/performer_test.rb".freeze, "test/workhorse/poller_test.rb".freeze, "test/workhorse/pool_test.rb".freeze, "test/workhorse/worker_test.rb".freeze, "workhorse.gemspec".freeze]
+  s.rubygems_version = "2.7.2".freeze
   s.summary = "Multi-threaded job backend with database queuing for ruby.".freeze
   s.test_files = ["test/lib/db_schema.rb".freeze, "test/lib/jobs.rb".freeze, "test/lib/test_helper.rb".freeze, "test/workhorse/enqueuer_test.rb".freeze, "test/workhorse/performer_test.rb".freeze, "test/workhorse/poller_test.rb".freeze, "test/workhorse/pool_test.rb".freeze, "test/workhorse/worker_test.rb".freeze]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: workhorse
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sitrox
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-19 00:00:00.000000000 Z
+date: 2017-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -178,6 +178,7 @@ files:
 - lib/workhorse/daemon/shell_handler.rb
 - lib/workhorse/db_job.rb
 - lib/workhorse/enqueuer.rb
+- lib/workhorse/jobs/cleanup_succeeded_jobs.rb
 - lib/workhorse/jobs/run_rails_op.rb
 - lib/workhorse/performer.rb
 - lib/workhorse/poller.rb