que 0.7.1 → 0.7.2

checksums.yaml

@@ -1,15 +1,7 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZjYzZDkwOTBkNmUxYjIxZjVkZGEzOTRiZjBmOWQ1OWZiNjUxOTRkYw==
-  data.tar.gz: !binary |-
-    MzIyOTk0ZTE1NGIzMTIwOGEzM2ZkZTAyMzM1NDE5ZDM0YjcwZTUxMQ==
-SHA512:
-  metadata.gz: !binary |-
-    OGVmMTc2MzNlYjkyNTQwYzhiNDZmMDJlOTdhMDViOGFhYzYzMzgzMGQ0MzY5
-    YzY1OTIzYjg5YmZjZDcyNjJkOWM2ZmY4MWFjNjQ0YmYzODQ4NmM5Y2I0Yjhi
-    Y2Q0YTkwYTk4NDlmNDM1Y2E5OWJlYWE1OWE2MDY5YzIxYTQ0ZWE=
-  data.tar.gz: !binary |-
-    NzlmZWZmY2RjZjc0OGJkNzJhODA5NWY5ZmZkYzY0M2VlMTk5M2NkODQyMmQ1
-    OWYzNjExYmMxMTdmYzQ5NGQ1NTBlNzY3NTA2MjQ5ZDQwZDM3M2FmMTY2ODUz
-    OTVjZjA0ZGVhM2VmZTFkMTViMmI2M2ZmYWM3M2U0N2Y4N2QyNmU=
+--- 
+SHA1: 
+  metadata.gz: 87a3655974bbd2d2524ccfc8527bbb949d1a1e4b
+  data.tar.gz: 183e2c344f8e25c3961def7cf9f2f1a6e86235d7
+SHA512: 
+  metadata.gz: fe9145ad097ba517f9a1978b8061bb263df0b83c1295c7673da02d757642b08371295bef139ad910e1c00dbd66edd2949dc3a3b26a097c8b50a3d91011cf0efb
+  data.tar.gz: 0e048d4c3c6cfdd135c0eb353c74677409eb2e9d83c7137652bf049ab3a5f305526f10e230ef0209607f33d418f3ddfa77eb8e7414e494844e2885e94de10710

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.7.2 (2014-05-18)
+
+*   Fix issue wherein intermittent worker wakeups would not work after forking (#44).
+
 ### 0.7.1 (2014-04-29)
 
 *   Fix errors with prepared statements when ActiveRecord reconnects to the database. (dvrensk)

data/README.md

@@ -4,16 +4,16 @@
 
 Que is a queue for Ruby and PostgreSQL that manages jobs using [advisory locks](http://www.postgresql.org/docs/current/static/explicit-locking.html#ADVISORY-LOCKS), which gives it several advantages over other RDBMS-backed queues:
 
-* **Concurrency** - Workers don't block each other when trying to lock jobs, as often occurs with "SELECT FOR UPDATE"-style locking. This allows for very high throughput with a large number of workers.
-* **Efficiency** - Locks are held in memory, so locking a job doesn't incur a disk write. These first two points are what limit performance with other queues - all workers trying to lock jobs have to wait behind one that's persisting its UPDATE on a locked_at column to disk (and the disks of however many other servers your database is synchronously replicating to). Under heavy load, Que's bottleneck is CPU, not I/O.
-* **Safety** - If a Ruby process dies, the jobs it's working won't be lost, or left in a locked or ambiguous state - they immediately become available for any other worker to pick up.
+  * **Concurrency** - Workers don't block each other when trying to lock jobs, as often occurs with "SELECT FOR UPDATE"-style locking. This allows for very high throughput with a large number of workers.
+  * **Efficiency** - Locks are held in memory, so locking a job doesn't incur a disk write. These first two points are what limit performance with other queues - all workers trying to lock jobs have to wait behind one that's persisting its UPDATE on a locked_at column to disk (and the disks of however many other servers your database is synchronously replicating to). Under heavy load, Que's bottleneck is CPU, not I/O.
+  * **Safety** - If a Ruby process dies, the jobs it's working won't be lost, or left in a locked or ambiguous state - they immediately become available for any other worker to pick up.
 
 Additionally, there are the general benefits of storing jobs in Postgres, alongside the rest of your data, rather than in Redis or a dedicated queue:
 
-* **Transactional Control** - Queue a job along with other changes to your database, and it'll commit or rollback with everything else. If you're using ActiveRecord or Sequel, Que can piggyback on their connections, so setup is simple and jobs are protected by the transactions you're already using.
-* **Atomic Backups** - Your jobs and data can be backed up together and restored as a snapshot. If your jobs relate to your data (and they usually do), there's no risk of jobs falling through the cracks during a recovery.
-* **Fewer Dependencies** - If you're already using Postgres (and you probably should be), a separate queue is another moving part that can break.
-* **Security** - Postgres' support for SSL connections keeps your data safe in transport, for added protection when you're running workers on cloud platforms that you can't completely control.
+  * **Transactional Control** - Queue a job along with other changes to your database, and it'll commit or rollback with everything else. If you're using ActiveRecord or Sequel, Que can piggyback on their connections, so setup is simple and jobs are protected by the transactions you're already using.
+  * **Atomic Backups** - Your jobs and data can be backed up together and restored as a snapshot. If your jobs relate to your data (and they usually do), there's no risk of jobs falling through the cracks during a recovery.
+  * **Fewer Dependencies** - If you're already using Postgres (and you probably should be), a separate queue is another moving part that can break.
+  * **Security** - Postgres' support for SSL connections keeps your data safe in transport, for added protection when you're running workers on cloud platforms that you can't completely control.
 
 Que's primary goal is reliability. You should be able to leave your application running indefinitely without worrying about jobs being lost due to a lack of transactional support, or left in limbo due to a crashing process. Que does everything it can to ensure that jobs you queue are performed exactly once (though the occasional repetition of a job can be impossible to avoid - see the docs on [how to write a reliable job](https://github.com/chanks/que/blob/master/docs/writing_reliable_jobs.md)).
 
@@ -21,10 +21,9 @@ Que's secondary goal is performance. It won't be able to match the speed or thro
 
 Que also includes a worker pool, so that multiple threads can process jobs in the same process. It can even do this in the background of your web process - if you're running on Heroku, for example, you don't need to run a separate worker dyno.
 
-*Please keep an eye out for problems when running Que in production. It's still new compared to other RDBMS-backed queues, and there may be issues that haven't been ironed out yet. Bug reports are welcome.*
-
 Que is tested on Ruby 2.0, Rubinius and JRuby (with the `jruby-pg` gem, which is [not yet functional with ActiveRecord](https://github.com/chanks/que/issues/4#issuecomment-29561356)). It requires Postgres 9.2+ for the JSON datatype.
 
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -39,70 +38,78 @@ Or install it yourself as:
 
     $ gem install que
 
+
 ## Usage
 
 The following assumes you're using Rails 4.0 and ActiveRecord. *Que hasn't been tested with versions of Rails before 4.0, and may or may not work with them.* See the [/docs directory](https://github.com/chanks/que/blob/master/docs) for instructions on using Que [outside of Rails](https://github.com/chanks/que/blob/master/docs/advanced_setup.md), and with [Sequel](https://github.com/chanks/que/blob/master/docs/using_sequel.md) or [no ORM](https://github.com/chanks/que/blob/master/docs/using_plain_connections.md), among other things.
 
 First, generate and run a migration for the job table.
 
-    rails generate que:install
-    rake db:migrate
+    $ bin/rails generate que:install
+    $ bin/rake db:migrate
 
 Create a class for each type of job you want to run:
 
-    # app/jobs/charge_credit_card.rb
-    class ChargeCreditCard < Que::Job
-      # Default settings for this job. These are optional - without them, jobs
-      # will default to priority 100 and run immediately.
-      @priority = 10
-      @run_at = proc { 1.minute.from_now }
-
-      def run(user_id, options)
-        # Do stuff.
-        user = User[user_id]
-        card = CreditCard[options[:credit_card_id]]
-
-        ActiveRecord::Base.transaction do
-          # Write any changes you'd like to the database.
-          user.update_attributes :charged_at => Time.now
-
-          # It's best to destroy the job in the same transaction as any other
-          # changes you make. Que will destroy the job for you after the run
-          # method if you don't do it yourself, but if your job writes to the
-          # DB but doesn't destroy the job in the same transaction, it's
-          # possible that the job could be repeated in the event of a crash.
-          destroy
-        end
-      end
-    end
 
-Queue your job. Again, it's best to do this in a transaction with other changes you're making. Also note that any arguments you pass will be serialized to JSON and back again, so stick to simple types (strings, integers, floats, hashes, and arrays).
+``` ruby
+# app/jobs/charge_credit_card.rb
+class ChargeCreditCard < Que::Job
+  # Default settings for this job. These are optional - without them, jobs
+  # will default to priority 100 and run immediately.
+  @priority = 10
+  @run_at = proc { 1.minute.from_now }
+
+  def run(user_id, options)
+    # Do stuff.
+    user = User[user_id]
+    card = CreditCard[options[:credit_card_id]]
 
     ActiveRecord::Base.transaction do
-      # Persist credit card information
-      card = CreditCard.create(params[:credit_card])
-      ChargeCreditCard.enqueue(current_user.id, :credit_card_id => card.id)
+      # Write any changes you'd like to the database.
+      user.update_attributes :charged_at => Time.now
+
+      # It's best to destroy the job in the same transaction as any other
+      # changes you make. Que will destroy the job for you after the run
+      # method if you don't do it yourself, but if your job writes to the
+      # DB but doesn't destroy the job in the same transaction, it's
+      # possible that the job could be repeated in the event of a crash.
+      destroy
     end
+  end
+end
+```
+
+Queue your job. Again, it's best to do this in a transaction with other changes you're making. Also note that any arguments you pass will be serialized to JSON and back again, so stick to simple types (strings, integers, floats, hashes, and arrays).
+
+``` ruby
+ActiveRecord::Base.transaction do
+  # Persist credit card information
+  card = CreditCard.create(params[:credit_card])
+  ChargeCreditCard.enqueue(current_user.id, :credit_card_id => card.id)
+end
+```
 
 You can also add options to run the job after a specific time, or with a specific priority:
 
-    # The default priority is 100, and a lower number means a higher priority. 5 would be very important.
-    ChargeCreditCard.enqueue current_user.id, :credit_card_id => card.id, :run_at => 1.day.from_now, :priority => 5
+``` ruby
+# The default priority is 100, and a lower number means a higher priority. 5 would be very important.
+ChargeCreditCard.enqueue current_user.id, :credit_card_id => card.id, :run_at => 1.day.from_now, :priority => 5
+```
 
 To determine what happens when a job is queued, you can set Que's mode in your application configuration. There are a few options for the mode:
 
-* `config.que.mode = :off` - In this mode, queueing a job will simply insert it into the database - the current process will make no effort to run it. You should use this if you want to use a dedicated process to work tasks (there's a rake task to do this, see below). This is the default when running `rails console`.
-* `config.que.mode = :async` - In this mode, a pool of background workers is spun up, each running in their own thread. This is the default when running `rails server`. See the docs for [more information on managing workers](https://github.com/chanks/que/blob/master/docs/managing_workers.md).
-* `config.que.mode = :sync` - In this mode, any jobs you queue will be run in the same thread, synchronously (that is, `MyJob.enqueue` runs the job and won't return until it's completed). This makes your application's behavior easier to test, so it's the default in the test environment.
+  * `config.que.mode = :off` - In this mode, queueing a job will simply insert it into the database - the current process will make no effort to run it. You should use this if you want to use a dedicated process to work tasks (there's a rake task to do this, see below). This is the default when running `bin/rails console`.
+  * `config.que.mode = :async` - In this mode, a pool of background workers is spun up, each running in their own thread. This is the default when running `bin/rails server`. See the docs for [more information on managing workers](https://github.com/chanks/que/blob/master/docs/managing_workers.md).
+  * `config.que.mode = :sync` - In this mode, any jobs you queue will be run in the same thread, synchronously (that is, `MyJob.enqueue` runs the job and won't return until it's completed). This makes your application's behavior easier to test, so it's the default in the test environment.
 
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
+  1. Fork it
+  2. Create your feature branch (`git checkout -b my-new-feature`)
+  3. Commit your changes (`git commit -am 'Add some feature'`)
+  4. Push to the branch (`git push origin my-new-feature`)
+  5. Create new Pull Request
+  
 A note on running specs - Que's worker system is multithreaded and therefore prone to race conditions (especially on Rubinius). As such, if you've touched that code, a single spec run passing isn't a guarantee that any changes you've made haven't introduced bugs. One thing I like to do before pushing changes is rerun the specs many times and watching for hangs. You can do this from the command line with something like:
 
     for i in {1..1000}; do rspec -b --seed $i; done

data/docs/using_sequel.md

@@ -23,5 +23,5 @@ Then you can safely use the same database object to transactionally protect your
     # In your controller action:
     DB.transaction do
       @user = User.create(params[:user])
-      MyJob.queue :user_id => @user.id
+      MyJob.enqueue :user_id => @user.id
     end

data/lib/que/version.rb

@@ -1,3 +1,3 @@
 module Que
-  Version = '0.7.1'
+  Version = '0.7.2'
 end

data/lib/que/worker.rb

@@ -110,12 +110,6 @@ module Que
     # a worker, and make sure to wake up the wrangler when @wake_interval is
     # changed in Que.wake_interval= below.
     @wake_interval = 5
-    @wrangler = Thread.new do
-      loop do
-        sleep *@wake_interval
-        wake! if @wake_interval
-      end
-    end
 
     class << self
       attr_reader :mode, :wake_interval
@@ -136,6 +130,7 @@ module Que
       def worker_count=(count)
         set_mode(count > 0 ? :async : :off)
         set_worker_count(count)
+        wrangler # Make sure the wrangler thread has been instantiated.
       end
 
       def worker_count
@@ -144,7 +139,7 @@ module Que
 
       def wake_interval=(interval)
         @wake_interval = interval
-        @wrangler.wakeup
+        wrangler.wakeup
       end
 
       def wake!
@@ -157,6 +152,15 @@ module Que
 
       private
 
+      def wrangler
+        @wrangler ||= Thread.new do
+          loop do
+            sleep *@wake_interval
+            wake! if @wake_interval
+          end
+        end
+      end
+
       def set_mode(mode)
         if mode != @mode
           Que.log :event => 'mode_change', :value => mode.to_s

data/spec/adapters/active_record_spec.rb

@@ -39,6 +39,8 @@ unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
 
       it "should recreate the prepared statements" do
         expect { Que::Job.enqueue }.not_to raise_error
+
+        DB[:que_jobs].count.should == 2
       end
 
       it "should work properly even in a transaction" do

metadata

@@ -1,36 +1,36 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: que
-version: !ruby/object:Gem::Version
-  version: 0.7.1
+version: !ruby/object:Gem::Version 
+  version: 0.7.2
 platform: ruby
-authors:
+authors: 
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-30 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-05-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
+      - !ruby/object:Gem::Version 
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
 description: A job queue that uses PostgreSQL's advisory locks for speed and reliability.
-email:
+email: 
 - christopher.m.hanks@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .rspec
 - .travis.yml
@@ -103,30 +103,32 @@ files:
 - tasks/rspec.rb
 - tasks/safe_shutdown.rb
 homepage: https://github.com/chanks/que
-licenses:
+licenses: 
 - MIT
 metadata: {}
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - &id002 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A PostgreSQL-based Job Queue
-test_files:
+test_files: 
 - spec/adapters/active_record_spec.rb
 - spec/adapters/connection_pool_spec.rb
 - spec/adapters/pg_spec.rb