workhorse 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf7da416379ae17a4defae96289beca3c4dd1d58
-  data.tar.gz: 5b4e9cb886632f4a78982506747e1bcbdef1a7f3
+  metadata.gz: 1a6e6801d5faf896ac2c0ac4fdee3b769239c475
+  data.tar.gz: 68d7918cc11af8be1961c807dd6230dd7158ae0a
 SHA512:
-  metadata.gz: c7f8b1730ada8f2613b63ee87bf570acae14fe057bfd2650ba1ea4daa479f641a99f6d77e74b2f9484cd62aedc2899a2fd5fed8b138b09b52a2191855439d884
-  data.tar.gz: ee19f3e7a11eafda737333a7c41b6a83444e927c37033d8230adb26987c8bbd60c17346da5e4abfa61521500991b9856dc5fba91f5f37368fc72941a8fce60d6
+  metadata.gz: 1a7d958df73684464a58f66b8a6ceedfa464601ebf7ecb7de5a31ebd77c00ba9d71aa7d5b9581eca68567066e3e4f1696eadb46a2c2aec40d8cb2837b28ff88e
+  data.tar.gz: fbec1a172427cfccb678cf56ea5a688c68af5efc9040b0139e73e9445a7c27b6a0a04418f4dde89eb9891814c095e0f454349c16c2772cf2087bd024e15c4eb3

data/FAQ.md

@@ -0,0 +1,59 @@
+# Workhorse FAQ
+
+## Why should I use workhorse over *X*?
+
+There exist a variety of job backends for ruby,
+[delayed_job](https://github.com/collectiveidea/delayed_job) probably being the
+closest one to workhorse.
+
+Some key advantages we feel workhorse has over other Gems:
+
+- Workhorse is less than 500 lines of code at its core. The code is supposed to
+  be easily readable, understandable, and modifiable.
+
+- Workhorse allows you to run multiple jobs simultaneously *in the same
+  process*.
+  This capability is what inspired the creation of workhorse in the first place.
+
+We encourage you to have a look at the other projects as well and carefully
+figure out which one best suits your needs.
+
+## My code is not thread safe. How can I use workhorse safely?
+
+Job code that is not thread safe can not be executed safely in multiple threads
+of the same process. In these cases, set the `pool_size` to `1` and, if you
+still want to execute multiple jobs simultaneously, the daemon `count` to a
+number greater than `1`:
+
+```ruby
+Workhorse::Daemon::ShellHandler.run count: 5 do
+  Workhorse::Worker.start_and_wait(pool_size: 1)
+end
+```
+
+## I'm using jRuby. How can I use the daemon handler?
+
+As java processes in general can not be forked safely, the daemon handler
+provided with this Gem does not support jRuby platforms.
+
+If your jRuby application consists of one single application process, it is
+recommended to just start the job backend in the same process:
+
+```ruby
+worker = Workhorse::Worker.new(pool_size: 5)
+worker.start
+```
+
+This code is non-blocking, which means that it will run as long as the process
+is up. Make sure to trap `INT` and `TERM` and call `worker.shutdown` when the
+process stops.
+
+If you have multiple application processes though, you may want to start the
+worker in a separate process. For this purpose, adapt the startup script
+`bin/workhorse.rb` so that it is blocking:
+
+```ruby
+Workhorse::Worker.start_and_wait(pool_size: 5)
+```
+
+This can then be started and "daemonized" using standard linux tools.

data/README.md

@@ -3,34 +3,38 @@
 
 # Workhorse
 
-**This Gem is still in an early stage of development. Please not use this in production yet.**
-
 Multi-threaded job backend with database queuing for ruby.
 
 ## Introduction
 
-What it is:
+How it works:
 
 * Jobs are instances of classes that support the `perform` method.
 * Jobs are persisted in the database using ActiveRecord.
 * You can start one or more worker processes.
-* Each worker is configurable as to which queue(s) it 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 worker polls the database and spawns a number of threads to execute jobs
   of different queues simultaneously.
 
-What it isn't:
+What it does not do:
 
-* It cannot spawn new processes. Jobs are run in separate threads but not in
-  separate processes (unless you start multiple worker processes manually).
-* It does not support retries.
+* 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.
 
 ## Installation
 
 ### Requirements
 
 * A database and table handler that properly supports row-level locking (such as
-  MySQL with InnoDB, PostgreSQL or Oracle).
-* An operating system and file system that supports file locking.
+  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.
 
 ### Installing under Rails
 
@@ -40,6 +44,8 @@ What it isn't:
    gem 'workhorse'
    ```
 
+   Install it using `bundle install` as usual.
+
 2. Run the install generator:
 
    ```bash
@@ -48,18 +54,19 @@ What it isn't:
 
    This generates:
 
-   * A database migration for creating the `jobs` table
-   * An initializer `config/initializers/workhorse.rb` for global configuration
-   * A daemon worker script under `bin/workhorse.rb`
+   * A database migration for creating a table named `jobs`
+   * The initializer `config/initializers/workhorse.rb` for global configuration
+   * The daemon worker script `bin/workhorse.rb`
 
-   Please customize the configuration files to your liking.
+   Please customize the initializer and worker script to your liking.
 
 ## Queuing jobs
 
 ### Basic jobs
 
 Workhorse can handle any jobs that support the `perform` method and are
-serializable. To queue a basic job, use the static method `Workhorse.enqueue`:
+serializable. To queue a basic job, use the static method `Workhorse.enqueue`.
+You can optionally pass a queue name.
 
 ```ruby
 class MyJob
@@ -75,11 +82,6 @@ end
 Workhorse.enqueue MyJob.new('John'), queue: :test
 ```
 
-In the above example, we also specify a queue named `:test`. This means that
-this job will never run simoultaneously with other jobs in the same queue. If no
-queue is given, the job can always be executed simoultaneously with any other
-job.
-
 ### RailsOps operations
 
 Workhorse allows you to easily queue
@@ -87,16 +89,16 @@ Workhorse allows you to easily queue
 method `Workhorse.enqueue_op`:
 
 ```ruby
-Workhorse.enqueue Operations::Jobs::CleanUpDatabase, quiet: true
+Workhorse.enqueue_op Operations::Jobs::CleanUpDatabase, { quiet: true }, queue: :maintenance
 ```
 
 Params passed using the second argument will be used for operation instantiation
 at job execution.
 
-You can also specify a queue:
+If you do not want to pass any params to the operation, just omit the second hash:
 
 ```ruby
-Workhorse.enqueue Operations::Jobs::CleanUpDatabase, { quiet: true }, queue: :maintenance
+Workhorse.enqueue_op Operations::Jobs::CleanUpDatabase, queue: :maintenance
 ```
 
 ## Configuring and starting workers
@@ -105,12 +107,12 @@ Workers poll the database for new jobs and execute them in one or more threads.
 Typically, one worker is started per process. While you can start workers
 manually, either in your main application process(es) or in a separate one,
 workhorse also provides you with a convenient way of starting one or multiple
-worker processes as a daemon.
+worker processes as daemons.
 
 ### Start workers manually
 
-Workers are created by instantiatating, configuring and starting a new
-`Workhorse::Worker` instance.
+Workers are created by instantiating, configuring, and starting a new
+`Workhorse::Worker` instance:
 
 ```ruby
 Workhorse::Worker.start_and_wait(
@@ -121,38 +123,30 @@ Workhorse::Worker.start_and_wait(
 )
 ```
 
-See [code
-documentation](http://www.rubydoc.info/github/sitrox/workhorse/Workhorse%2FWorker:initialize)
-for more information on the arguments.
+See [code documentation](http://www.rubydoc.info/github/sitrox/workhorse/Workhorse%2FWorker:initialize)
+for more information on the arguments. All arguments passed to `start_and_wait`
+are passed to the initialize. All arguments passed to `start_and_wait` are
+in turn passed to the initializer of `Workhorse::Worker`.
 
 ### Start workers using a daemon script
 
-Using `Workhorse::Daemon` (`Workhorse::Daemon::ShellHandler`), you can spawn one
-or multiple worker processes automatically. This is useful for cases where you
-want the workers to exist in separate processes as opposed to in your main
-application process(es).
+Using `Workhorse::Daemon::ShellHandler`, you can spawn one or multiple worker
+processes automatically. This is useful for cases where you want the workers to
+exist in separate processes as opposed to your main application process(es).
 
-For this case, the workhorse install routine automatically creates a file called
-`bin/workhorse.rb` which can be used to start one or more worker processes.
+For this case, the workhorse install routine automatically creates the file
+`bin/workhorse.rb`, which can be used to start one or more worker processes.
 
-To start the daemon:
+The script can be called as follows:
 
 ```bash
-bin/workhorse.rb start[|stop|status|watch|restart|usage]
+bin/workhorse.rb start|stop|status|watch|restart|usage
 ```
 
 #### Background and customization
 
-The daemon-part allows you to run arbitrary code as a daemon:
-
-```ruby
-Workhorse::Daemon::ShellHandler.run count: 5 do
-  # This runs as a daemon and will be started 5 times
-end
-```
-
-Within this shell handler, you can now instantiate, configure and start a worker
-as described under *Start workers manually*:
+Within the shell handler, you can instantiate, configure, and start a worker as
+described under [Start workers manually](#start-workers-manually):
 
 ```ruby
 Workhorse::Daemon::ShellHandler.run count: 5 do
@@ -162,11 +156,16 @@ Workhorse::Daemon::ShellHandler.run count: 5 do
 end
 ```
 
+## Frequently asked questions
+
+Please consult the [FAQ](FAQ.md).
+
 ## Roadmap
 
 * [ ] ActiveJob integration for Rails
 * [ ] Job timeouts
+* [ ] Job priorities
 
 ## Copyright
 
-Copyright (c) 2017 Sitrox. See `LICENSE` for further details.
+Copyright © 2017 Sitrox. See `LICENSE` for further details.

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/generators/workhorse/templates/config/initializers/workhorse.rb

@@ -2,9 +2,12 @@ Workhorse.setup do |config|
   # Set this to false in order to prevent jobs from being automatically
   # wrapped into a transaction. The built-in workhorse logic will still run
   # in transactions.
-  config.perform_jobs_in_tx = true
+  #
+  # config.perform_jobs_in_tx = true
 
-  # Enable this to specify an alternative callback for handling transactions.
+  # Enable and configure this to specify an alternative callback for handling
+  # transactions.
+  #
   # config.tx_callback = proc do |&block|
   #   ActiveRecord::Base.transaction&(&block)
   # end

data/lib/workhorse.rb

@@ -2,7 +2,11 @@ require 'socket'
 require 'active_support/all'
 require 'active_record'
 
+require 'workhorse/enqueuer'
+
 module Workhorse
+  extend Workhorse::Enqueuer
+
   @set_up = false
 
   # Returns the performer currently performing the active job. This can only be
@@ -28,7 +32,6 @@ module Workhorse
 end
 
 require 'workhorse/db_job'
-require 'workhorse/enqueuer'
 require 'workhorse/performer'
 require 'workhorse/poller'
 require 'workhorse/pool'

data/lib/workhorse/enqueuer.rb

@@ -1,7 +1,7 @@
 module Workhorse
-  class Enqueuer
+  module Enqueuer
     # Enqueue any object that is serializable and has a `perform` method
-    def self.enqueue(job, queue: nil)
+    def enqueue(job, queue: nil)
       return DbJob.create!(
         queue: queue,
         handler: Marshal.dump(job)
@@ -9,14 +9,27 @@ module Workhorse
     end
 
     # Enqueue an ActiveJob job
-    def self.enqueue_active_job(job)
+    def enqueue_active_job(job)
       enqueue job, queue: job.queue_name
     end
 
     # Enqueue the execution of an operation by its class and params
-    def self.enqueue_op(cls, params, queue: nil)
-      job = Workhorse::Jobs::RunRailsOp.new(cls, params)
-      enqueue job, queue: queue
+    def enqueue_op(cls, *args)
+      case args.size
+      when 0
+        workhorse_args = {}
+        op_args = {}
+      when 1
+        workhorse_args = args.first
+        op_args = {}
+      when 2
+        workhorse_args, op_args = *args
+      else
+        fail ArgumentError, "wrong number of arguments (#{args.size + 1} for 2..3)"
+      end
+
+      job = Workhorse::Jobs::RunRailsOp.new(cls, op_args)
+      enqueue job, workhorse_args
     end
   end
 end

data/lib/workhorse/poller.rb

@@ -51,7 +51,12 @@ module Workhorse
 
     def poll
       Workhorse.tx_callback.call do
+        # As we are the only thread posting into the worker pool, it is safe to
+        # get the number of idle threads without mutex synchronization. The
+        # actual number of idle workers at time of posting can only be larger
+        # than or equal to the number we get here.
         idle = worker.idle
+
         worker.log "Polling DB for jobs (#{idle} available threads)...", :debug
 
         unless idle.zero?
@@ -70,7 +75,7 @@ module Workhorse
       is_oracle = ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
 
       # ---------------------------------------------------------------
-      # Lock all queued jobs that are not complete
+      # Lock all queued jobs that are waiting
       # ---------------------------------------------------------------
       Workhorse::DbJob.connection.execute(
         Workhorse::DbJob.select('null').where(
@@ -93,11 +98,17 @@ module Workhorse
       select = select.where(table[:queue].not_in(bad_queries_select))
 
       # Restrict queues to "open" ones
-      if worker.queues.any?
-        where = table[:queue].in(worker.queues.reject(&:nil?))
+      unless worker.queues.empty?
         if worker.queues.include?(nil)
-          where = where.or(table[:queue].eq(nil))
+          where = table[:queue].eq(nil)
+          remaining_queues = worker.queues.reject(&:nil?)
+          unless remaining_queues.empty?
+            where = where.or(table[:queue].in(remaining_queues))
+          end
+        else
+          where = table[:queue].in(worker.queues)
         end
+
         select = select.where(where)
       end
 

data/lib/workhorse/pool.rb

@@ -19,7 +19,7 @@ module Workhorse
     # Posts a new work unit to the pool.
     def post
       mutex.synchronize do
-        if @active_threads.value >= @size
+        if idle.zero?
           fail 'All threads are busy.'
         end
 
@@ -42,10 +42,14 @@ module Workhorse
       @size - @active_threads.value
     end
 
-    # Shuts down the pool
+    def wait
+      @executor.wait_for_termination
+    end
+
+    # Shuts down the pool and waits for termination.
     def shutdown
       @executor.shutdown
-      @executor.wait_for_termination
+      wait
     end
   end
 end

data/lib/workhorse/worker.rb

@@ -88,9 +88,13 @@ module Workhorse
     # properly finished before this method returns. Subsequent calls to this
     # method are ignored.
     def shutdown
+      # This is safe to be checked outside of the mutex as 'shutdown' is the
+      # final state this worker can be in.
+      return if @state == :shutdown
+
       mutex.synchronize do
-        return if @state == :shutdown
         assert_state! :running
+
         log 'Shutting down'
         @state = :shutdown
 
@@ -107,6 +111,7 @@ module Workhorse
     def wait
       assert_state! :running
       @poller.wait
+      @pool.wait
     end
 
     def idle
@@ -133,10 +138,14 @@ module Workhorse
     def trap_termination
       SHUTDOWN_SIGNALS.each do |signal|
         Signal.trap(signal) do
+          # Start a new thread as certain functionality (such as logging) is not
+          # available from within a trap context. As "shutdown" terminates
+          # quickly when called multiple times, this does not pose a risk of
+          # keeping open a big number of "shutdown threads".
           Thread.new do
             log "\nCaught #{signal}, shutting worker down..."
             shutdown
-          end
+          end.join
         end
       end
     end

data/test/lib/test_helper.rb

@@ -22,7 +22,6 @@ class WorkhorseTest < ActiveSupport::TestCase
   end
 end
 
-ActiveRecord::Base.logger = Logger.new('debug.log')
 ActiveRecord::Base.establish_connection adapter: 'mysql2', database: 'workhorse', username: 'travis', password: '', pool: 10, host: :localhost
 
 require 'db_schema'

data/test/workhorse/enqueuer_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 class Workhorse::EnqueuerTest < WorkhorseTest
   def test_basic
     assert_equal 0, Workhorse::DbJob.all.count
-    Workhorse::Enqueuer.enqueue BasicJob.new
+    Workhorse.enqueue BasicJob.new
     assert_equal 1, Workhorse::DbJob.all.count
 
     db_job = Workhorse::DbJob.first
@@ -20,7 +20,7 @@ class Workhorse::EnqueuerTest < WorkhorseTest
 
   def test_with_queue
     assert_equal 0, Workhorse::DbJob.all.count
-    Workhorse::Enqueuer.enqueue BasicJob.new, queue: :q1
+    Workhorse.enqueue BasicJob.new, queue: :q1
     assert_equal 1, Workhorse::DbJob.all.count
 
     db_job = Workhorse::DbJob.first
@@ -28,15 +28,25 @@ class Workhorse::EnqueuerTest < WorkhorseTest
   end
 
   def test_op
-    Workhorse::Enqueuer.enqueue_op DummyRailsOpsOp, { foo: :bar }, queue: :q1
+    Workhorse.enqueue_op DummyRailsOpsOp, { queue: :q1 }, foo: :bar
 
     w = Workhorse::Worker.new(queues: [:q1])
     w.start
-    sleep 1.5
+    sleep 1
     w.shutdown
 
     assert_equal 'succeeded', Workhorse::DbJob.first.state
 
     assert_equal [{ foo: :bar }], DummyRailsOpsOp.results
   end
+
+  def test_op_without_params
+    Workhorse.enqueue_op DummyRailsOpsOp, queue: :q1
+    assert_equal 'q1', Workhorse::DbJob.first.queue
+  end
+
+  def test_op_without_params_and_queue
+    Workhorse.enqueue_op DummyRailsOpsOp
+    assert_nil Workhorse::DbJob.first.queue
+  end
 end

data/test/workhorse/performer_test.rb

@@ -6,10 +6,10 @@ class Workhorse::WorkerTest < WorkhorseTest
   def test_db_connections
     w = Workhorse::Worker.new polling_interval: 1, pool_size: 5
     5.times do
-      Workhorse::Enqueuer.enqueue DbConnectionTestJob.new
+      Workhorse.enqueue DbConnectionTestJob.new
     end
     w.start
-    sleep 2
+    sleep 1
     w.shutdown
 
     assert_equal 5, DbConnectionTestJob.db_connections.count

data/test/workhorse/poller_test.rb

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

data/test/workhorse/pool_test.rb

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

data/test/workhorse/worker_test.rb

@@ -6,12 +6,12 @@ class Workhorse::WorkerTest < WorkhorseTest
     w.start
     assert_equal 5, w.idle
 
-    Workhorse::Enqueuer.enqueue BasicJob.new(sleep_time: 3)
+    Workhorse.enqueue BasicJob.new(sleep_time: 0.5)
 
-    sleep 2
+    sleep 0.1
     assert_equal 4, w.idle
 
-    sleep 3
+    sleep 0.5
     assert_equal 5, w.idle
 
     w.shutdown
@@ -29,16 +29,16 @@ class Workhorse::WorkerTest < WorkhorseTest
     w.shutdown
     w.shutdown # Should be ignored
 
-    Workhorse::Enqueuer.enqueue BasicJob.new
+    Workhorse.enqueue BasicJob.new
   end
 
   def test_perform
     w = Workhorse::Worker.new polling_interval: 1
-    Workhorse::Enqueuer.enqueue BasicJob.new
+    Workhorse.enqueue BasicJob.new(sleep_time: 0.1)
     assert_equal 'waiting', Workhorse::DbJob.first.state
 
     w.start
-    sleep 2
+    sleep 1
     w.shutdown
 
     assert_equal 'succeeded', Workhorse::DbJob.first.state
@@ -47,10 +47,10 @@ class Workhorse::WorkerTest < WorkhorseTest
   def test_params
     BasicJob.results.clear
 
-    Workhorse::Enqueuer.enqueue BasicJob.new(some_param: 5)
+    Workhorse.enqueue BasicJob.new(some_param: 5, sleep_time: 0)
     w = Workhorse::Worker.new polling_interval: 1
     w.start
-    sleep 2
+    sleep 0.5
     w.shutdown
 
     assert_equal 'succeeded', Workhorse::DbJob.first.state
@@ -79,17 +79,27 @@ class Workhorse::WorkerTest < WorkhorseTest
 
   def test_no_queues
     enqueue_in_multiple_queues
-    work 3, queues: [nil, :q1]
+    work 1
 
     jobs = Workhorse::DbJob.order(queue: :asc).to_a
     assert_equal 'succeeded', jobs[0].state
     assert_equal 'succeeded', jobs[1].state
+    assert_equal 'succeeded', jobs[2].state
+  end
+
+  def test_nil_queue
+    enqueue_in_multiple_queues
+    work 1, queues: [nil]
+
+    jobs = Workhorse::DbJob.order(queue: :asc).to_a
+    assert_equal 'succeeded', jobs[0].state
+    assert_equal 'waiting',   jobs[1].state
     assert_equal 'waiting',   jobs[2].state
   end
 
   def test_queues_with_nil
     enqueue_in_multiple_queues
-    work 3, queues: [nil, :q1]
+    work 1, queues: [nil, :q1]
 
     jobs = Workhorse::DbJob.order(queue: :asc).to_a
     assert_equal 'succeeded', jobs[0].state
@@ -99,7 +109,7 @@ class Workhorse::WorkerTest < WorkhorseTest
 
   def test_queues_without_nil
     enqueue_in_multiple_queues
-    work 3, queues: %i[q1 q2]
+    work 1, queues: %i[q1 q2]
 
     jobs = Workhorse::DbJob.order(queue: :asc).to_a
     assert_equal 'waiting',   jobs[0].state
@@ -110,8 +120,8 @@ class Workhorse::WorkerTest < WorkhorseTest
   private
 
   def enqueue_in_multiple_queues
-    Workhorse::Enqueuer.enqueue BasicJob.new(some_param: nil)
-    Workhorse::Enqueuer.enqueue BasicJob.new(some_param: :q1), queue: :q1
-    Workhorse::Enqueuer.enqueue BasicJob.new(some_param: :q2), queue: :q2
+    Workhorse.enqueue BasicJob.new(some_param: nil)
+    Workhorse.enqueue BasicJob.new(some_param: :q1), queue: :q1
+    Workhorse.enqueue BasicJob.new(some_param: :q2), queue: :q2
   end
 end

data/workhorse.gemspec

@@ -1,55 +1,54 @@
 # -*- encoding: utf-8 -*-
-# stub: workhorse 0.0.2 ruby lib
 
 Gem::Specification.new do |s|
-  s.name = "workhorse".freeze
-  s.version = "0.0.2"
+  s.name = "workhorse"
+  s.version = "0.0.3"
 
-  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-14"
-  s.files = [".gitignore".freeze, ".releaser_config".freeze, ".rubocop.yml".freeze, ".travis.yml".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.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]
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sitrox"]
+  s.date = "2017-12-18"
+  s.files = [".gitignore", ".releaser_config", ".rubocop.yml", ".travis.yml", "FAQ.md", "Gemfile", "LICENSE", "README.md", "RUBY_VERSION", "Rakefile", "VERSION", "bin/rubocop", "lib/generators/workhorse/install_generator.rb", "lib/generators/workhorse/templates/bin/workhorse.rb", "lib/generators/workhorse/templates/config/initializers/workhorse.rb", "lib/generators/workhorse/templates/create_table_jobs.rb", "lib/workhorse.rb", "lib/workhorse/daemon.rb", "lib/workhorse/daemon/shell_handler.rb", "lib/workhorse/db_job.rb", "lib/workhorse/enqueuer.rb", "lib/workhorse/jobs/run_rails_op.rb", "lib/workhorse/performer.rb", "lib/workhorse/poller.rb", "lib/workhorse/pool.rb", "lib/workhorse/worker.rb", "test/lib/db_schema.rb", "test/lib/jobs.rb", "test/lib/test_helper.rb", "test/workhorse/enqueuer_test.rb", "test/workhorse/performer_test.rb", "test/workhorse/poller_test.rb", "test/workhorse/pool_test.rb", "test/workhorse/worker_test.rb", "workhorse.gemspec"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "2.0.14.1"
+  s.summary = "Multi-threaded job backend with database queuing for ruby."
+  s.test_files = ["test/lib/db_schema.rb", "test/lib/jobs.rb", "test/lib/test_helper.rb", "test/workhorse/enqueuer_test.rb", "test/workhorse/performer_test.rb", "test/workhorse/poller_test.rb", "test/workhorse/pool_test.rb", "test/workhorse/worker_test.rb"]
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<bundler>.freeze, ["~> 1.3"])
-      s.add_development_dependency(%q<rake>.freeze, [">= 0"])
-      s.add_development_dependency(%q<rubocop>.freeze, ["= 0.51.0"])
-      s.add_development_dependency(%q<minitest>.freeze, [">= 0"])
-      s.add_development_dependency(%q<mysql2>.freeze, ["~> 0.3.13"])
-      s.add_development_dependency(%q<benchmark-ips>.freeze, [">= 0"])
-      s.add_runtime_dependency(%q<activesupport>.freeze, [">= 0"])
-      s.add_runtime_dependency(%q<activerecord>.freeze, [">= 0"])
-      s.add_runtime_dependency(%q<schemacop>.freeze, ["~> 2.0"])
-      s.add_runtime_dependency(%q<concurrent-ruby>.freeze, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.3"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<rubocop>, ["= 0.51.0"])
+      s.add_development_dependency(%q<minitest>, [">= 0"])
+      s.add_development_dependency(%q<mysql2>, ["~> 0.3.13"])
+      s.add_development_dependency(%q<benchmark-ips>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_runtime_dependency(%q<schemacop>, ["~> 2.0"])
+      s.add_runtime_dependency(%q<concurrent-ruby>, [">= 0"])
     else
-      s.add_dependency(%q<bundler>.freeze, ["~> 1.3"])
-      s.add_dependency(%q<rake>.freeze, [">= 0"])
-      s.add_dependency(%q<rubocop>.freeze, ["= 0.51.0"])
-      s.add_dependency(%q<minitest>.freeze, [">= 0"])
-      s.add_dependency(%q<mysql2>.freeze, ["~> 0.3.13"])
-      s.add_dependency(%q<benchmark-ips>.freeze, [">= 0"])
-      s.add_dependency(%q<activesupport>.freeze, [">= 0"])
-      s.add_dependency(%q<activerecord>.freeze, [">= 0"])
-      s.add_dependency(%q<schemacop>.freeze, ["~> 2.0"])
-      s.add_dependency(%q<concurrent-ruby>.freeze, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.3"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<rubocop>, ["= 0.51.0"])
+      s.add_dependency(%q<minitest>, [">= 0"])
+      s.add_dependency(%q<mysql2>, ["~> 0.3.13"])
+      s.add_dependency(%q<benchmark-ips>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<schemacop>, ["~> 2.0"])
+      s.add_dependency(%q<concurrent-ruby>, [">= 0"])
     end
   else
-    s.add_dependency(%q<bundler>.freeze, ["~> 1.3"])
-    s.add_dependency(%q<rake>.freeze, [">= 0"])
-    s.add_dependency(%q<rubocop>.freeze, ["= 0.51.0"])
-    s.add_dependency(%q<minitest>.freeze, [">= 0"])
-    s.add_dependency(%q<mysql2>.freeze, ["~> 0.3.13"])
-    s.add_dependency(%q<benchmark-ips>.freeze, [">= 0"])
-    s.add_dependency(%q<activesupport>.freeze, [">= 0"])
-    s.add_dependency(%q<activerecord>.freeze, [">= 0"])
-    s.add_dependency(%q<schemacop>.freeze, ["~> 2.0"])
-    s.add_dependency(%q<concurrent-ruby>.freeze, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.3"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<rubocop>, ["= 0.51.0"])
+    s.add_dependency(%q<minitest>, [">= 0"])
+    s.add_dependency(%q<mysql2>, ["~> 0.3.13"])
+    s.add_dependency(%q<benchmark-ips>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<schemacop>, ["~> 2.0"])
+    s.add_dependency(%q<concurrent-ruby>, [">= 0"])
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: workhorse
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Sitrox
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-14 00:00:00.000000000 Z
+date: 2017-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -160,6 +160,7 @@ files:
 - ".releaser_config"
 - ".rubocop.yml"
 - ".travis.yml"
+- FAQ.md
 - Gemfile
 - LICENSE
 - README.md