que 0.3.0 → 0.4.0

data/lib/que/version.rb

@@ -1,3 +1,3 @@
 module Que
-  Version = '0.3.0'
+  Version = '0.4.0'
 end

data/lib/que/worker.rb

@@ -81,37 +81,34 @@ module Que
     def work_loop
       loop do
         job = Job.work
-
-        # Grab the lock and figure out what we should do next.
         synchronize { @state = :sleeping unless @stop || job }
-
         sleep if @state == :sleeping
         break if @stop
       end
     rescue Stop
-      # This process is shutting down; let it.
+      # This process is shutting down - let it.
     ensure
       @state = :stopped
     end
 
-    # Defaults for the Worker pool.
-    @worker_count = 0
-    @sleep_period = 5
+    # Setting Que.wake_interval = nil should ensure that the wrangler thread
+    # doesn't wake up a worker again, even if it's currently sleeping for a
+    # set period. So, we double-check that @wake_interval is set before waking
+    # 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 { loop { sleep(*@wake_interval); wake! if @wake_interval } }
 
     class << self
-      attr_reader :mode, :sleep_period, :worker_count
+      attr_reader :mode, :wake_interval
 
       def mode=(mode)
-        case mode
+        case set_mode(mode)
         when :async
-          wrangler # Make sure the wrangler thread is initialized.
-          self.worker_count = 4
-        else
-          self.worker_count = 0
+          set_worker_count 4 if worker_count.zero?
+        when :sync, :off
+          set_worker_count 0
         end
-
-        @mode = mode
-        Que.log :info, "Set mode to #{mode.inspect}"
       end
 
       def workers
@@ -119,16 +116,17 @@ module Que
       end
 
       def worker_count=(count)
-        if count > workers.count
-          (count - workers.count).times { workers << new }
-        elsif count < workers.count
-          workers.pop(workers.count - count).each(&:stop).each(&:wait_until_stopped)
-        end
+        set_mode(count > 0 ? :async : :off)
+        set_worker_count(count)
+      end
+
+      def worker_count
+        workers.count
       end
 
-      def sleep_period=(period)
-        @sleep_period = period
-        wrangler.wakeup if period
+      def wake_interval=(interval)
+        @wake_interval = interval
+        @wrangler.wakeup
       end
 
       def stop!
@@ -154,8 +152,23 @@ module Que
 
       private
 
-      def wrangler
-        @wrangler ||= Thread.new { loop { sleep(*sleep_period); wake! } }
+      def set_mode(mode)
+        if mode != @mode
+          Que.log :info, "Set mode to #{mode.inspect}"
+          @mode = mode
+        end
+      end
+
+      def set_worker_count(count)
+        if count != worker_count
+          Que.log :info, "Set worker_count to #{count.inspect}"
+
+          if count > worker_count
+            workers.push *(count - worker_count).times.map { new }
+          elsif count < worker_count
+            workers.pop(worker_count - count).each(&:stop).each(&:wait_until_stopped)
+          end
+        end
       end
     end
   end

data/spec/adapters/active_record_spec.rb

@@ -11,8 +11,7 @@ unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
   describe "Que using the ActiveRecord adapter" do
     before { Que.adapter = QUE_ADAPTERS[:active_record] }
 
-    it_behaves_like "a Que adapter"
-    it_behaves_like "a multithreaded Que adapter"
+    it_behaves_like "a multi-threaded Que adapter"
 
     it "should use the same connection that ActiveRecord does" do
       class ActiveRecordJob < Que::Job
@@ -36,32 +35,14 @@ unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
     end
 
     it "should support Rails' special extensions for times" do
-      Que::Job.queue :run_at => 1.minute.from_now
-      DB[:que_jobs].get(:run_at).should be_within(3).of Time.now + 60
-    end
-
-    it "should safely roll back in-process transactions when using Que.stop!" do
-      begin
-        class ARInterruptJob < BlockJob
-          def run
-            ActiveRecord::Base.transaction do
-              Que.execute "INSERT INTO que_jobs (job_id, job_class) VALUES (0, 'Que::Job')"
-              super
-            end
-          end
-        end
+      Que.mode = :async
+      sleep_until { Que::Worker.workers.all? &:sleeping? }
 
-        ARInterruptJob.queue
-        Que.mode = :async
-        $q1.pop
-        Que.stop!
+      Que::Job.queue :run_at => 1.minute.ago
+      DB[:que_jobs].get(:run_at).should be_within(3).of Time.now - 60
 
-        DB[:que_jobs].where(:job_id => 0).should be_empty
-      ensure
-        # Que.stop! can affect DB connections in an unpredictable fashion, so
-        # force a reconnection for the sake of the other specs.
-        ActiveRecord::Base.establish_connection(QUE_URL)
-      end
+      Que.wake_interval = 0.005.seconds
+      sleep_until { DB[:que_jobs].empty? }
     end
   end
 end

data/spec/adapters/connection_pool_spec.rb

@@ -7,6 +7,5 @@ QUE_ADAPTERS[:connection_pool] = Que.adapter
 describe "Que using the ConnectionPool adapter" do
   before { Que.adapter = QUE_ADAPTERS[:connection_pool] }
 
-  it_behaves_like "a Que adapter"
-  it_behaves_like "a multithreaded Que adapter"
+  it_behaves_like "a multi-threaded Que adapter"
 end

data/spec/adapters/pg_spec.rb

@@ -2,4 +2,38 @@ require 'spec_helper'
 
 describe "Que using a bare PG connection" do
   it_behaves_like "a Que adapter"
+
+  it "should synchronize access to that connection" do
+    lock   = Que.adapter.lock
+    q1, q2 = Queue.new, Queue.new
+
+    thread1 = Thread.new do
+      Que.adapter.checkout do
+        q1.push nil
+        q2.pop
+      end
+    end
+
+    q1.pop
+
+    thread2 = Thread.new do
+      Que.adapter.checkout do
+        q1.push nil
+        q2.pop
+      end
+    end
+
+    sleep_until { thread2.status == 'sleep' }
+
+    thread1.should be_alive
+    thread2.should be_alive
+
+    lock.send(:instance_variable_get, :@mon_owner).should == thread1
+    q2.push nil
+    q1.pop
+    lock.send(:instance_variable_get, :@mon_owner).should == thread2
+    q2.push nil
+    thread1.join
+    thread2.join
+  end
 end

data/spec/adapters/sequel_spec.rb

@@ -6,8 +6,7 @@ QUE_ADAPTERS[:sequel] = Que.adapter
 describe "Que using the Sequel adapter" do
   before { Que.adapter = QUE_ADAPTERS[:sequel] }
 
-  it_behaves_like "a Que adapter"
-  it_behaves_like "a multithreaded Que adapter"
+  it_behaves_like "a multi-threaded Que adapter"
 
   it "should use the same connection that Sequel does" do
     class SequelJob < Que::Job
@@ -23,33 +22,22 @@ describe "Que using the Sequel adapter" do
     $pid1.should == $pid2
   end
 
-  it "should safely roll back in-process transactions when using Que.stop!" do
-    begin
-      class SequelInterruptJob < BlockJob
-        def run
-          SEQUEL_ADAPTER_DB.transaction do
-            Que.execute "INSERT INTO que_jobs (job_id, job_class) VALUES (0, 'Que::Job')"
-            super
-          end
-        end
-      end
+  it "should wake up a Worker after queueing a job in async mode, waiting for a transaction to commit if necessary" do
+    Que.mode = :async
+    sleep_until { Que::Worker.workers.all? &:sleeping? }
+
+    # Wakes a worker immediately when not in a transaction.
+    Que::Job.queue
+    sleep_until { Que::Worker.workers.all?(&:sleeping?) && DB[:que_jobs].empty? }
 
-      SequelInterruptJob.queue
-      Que.mode = :async
-      $q1.pop
-      Que.stop!
-
-      DB[:que_jobs].where(:job_id => 0).should be_empty
-    ensure
-      # Que.stop! can affect DB connections in an unpredictable fashion, and
-      # Sequel's built-in reconnection logic may not be able to recover them.
-      # So, force a reconnection for the sake of the other specs...
-      SEQUEL_ADAPTER_DB.disconnect
-
-      # ...and that's not even foolproof, because threads may have died with
-      # connections checked out.
-      SEQUEL_ADAPTER_DB.pool.allocated.each_value(&:close)
-      SEQUEL_ADAPTER_DB.pool.allocated.clear
+    SEQUEL_ADAPTER_DB.transaction do
+      Que::Job.queue
+      Que::Worker.workers.each { |worker| worker.should be_sleeping }
     end
+    sleep_until { Que::Worker.workers.all?(&:sleeping?) && DB[:que_jobs].empty? }
+
+    # Do nothing when queueing with a specific :run_at.
+    BlockJob.queue :run_at => Time.now
+    Que::Worker.workers.each { |worker| worker.should be_sleeping }
   end
 end

data/spec/spec_helper.rb

@@ -2,23 +2,30 @@ require 'que'
 require 'uri'
 require 'pg'
 require 'json'
+require 'logger'
 
 Dir['./spec/support/**/*.rb'].sort.each &method(:require)
 
 
+
 # Handy constants for initializing PG connections:
 QUE_URL = ENV['DATABASE_URL'] || 'postgres://postgres:@localhost/que-test'
 
 NEW_PG_CONNECTION = proc do
   uri = URI.parse(QUE_URL)
-  PG::Connection.open :host     => uri.host,
-                      :user     => uri.user,
-                      :password => uri.password,
-                      :port     => uri.port || 5432,
-                      :dbname   => uri.path[1..-1]
+  pg = PG::Connection.open :host     => uri.host,
+                           :user     => uri.user,
+                           :password => uri.password,
+                           :port     => uri.port || 5432,
+                           :dbname   => uri.path[1..-1]
+
+  # Avoid annoying NOTICE messages in specs.
+  pg.async_exec "SET client_min_messages TO 'warning'"
+  pg
 end
 
 
+
 # Adapters track which statements have been prepared for their connections,
 # and if Que.connection= is called before each spec, we're constantly creating
 # new adapters and losing that information, which is bad. So instead, we hang
@@ -31,59 +38,64 @@ Que.connection = NEW_PG_CONNECTION.call
 QUE_ADAPTERS = {:pg => Que.adapter}
 
 
-# We use Sequel to introspect the database in specs.
+
+# We use Sequel to examine the database in specs.
 require 'sequel'
 DB = Sequel.connect(QUE_URL)
 DB.drop_table? :que_jobs
 DB.run Que::SQL[:create_table]
 
 
+
 # Set up a dummy logger.
 Que.logger = $logger = Object.new
+$logger_mutex = Mutex.new # Protect against rare errors on Rubinius/JRuby.
 
 def $logger.messages
   @messages ||= []
 end
 
 def $logger.method_missing(m, message)
-  messages << message
+  $logger_mutex.synchronize { messages << message }
 end
 
 
-# Clean up between specs.
-RSpec.configure do |config|
-  config.before do
-    DB[:que_jobs].delete
-    Que.adapter = QUE_ADAPTERS[:pg]
-    Que.mode = :off
-    Que.sleep_period = nil
-    $logger.messages.clear
+
+# Helper to display spec descriptions.
+description_builder = -> hash do
+  if g = hash[:example_group]
+    "#{description_builder.call(g)} #{hash[:description_args].first}"
+  else
+    hash[:description_args].first
   end
 end
 
+stdout = Logger.new(STDOUT)
 
-# Optionally log to STDOUT which spec is running at the moment. This is loud,
-# but helpful in tracking down what spec is hanging, if any.
-if ENV['LOG_SPEC']
-  require 'logger'
-  logger = Logger.new(STDOUT)
+RSpec.configure do |config|
+  config.around do |spec|
+    # Figure out which spec is about to run, for logging purposes.
+    data = example.metadata
+    desc = description_builder.call(data)
+    line = "rspec #{data[:file_path]}:#{data[:line_number]}"
 
-  description_builder = -> hash do
-    if g = hash[:example_group]
-      "#{description_builder.call(g)} #{hash[:description_args].first}"
-    else
-      hash[:description_args].first
-    end
-  end
+    # Optionally log to STDOUT which spec is about to run. This is noisy, but
+    # helpful in identifying hanging specs.
+    stdout.info "Running spec: #{desc} @ #{line}" if ENV['LOG_SPEC']
 
-  RSpec.configure do |config|
-    config.around do |example|
-      data = example.metadata
-      desc = description_builder.call(data)
-      line = "rspec #{data[:file_path]}:#{data[:line_number]}"
-      logger.info "Running spec: #{desc} @ #{line}"
+    $logger.messages.clear
+    Que.adapter = QUE_ADAPTERS[:pg]
+
+    spec.run
+
+    DB[:que_jobs].delete
+    Que.mode = :off
+    Que.wake_interval = nil
+    sleep_until { Que::Worker.workers.all?(&:sleeping?) }
 
-      example.run
+    # A bit of lint: make sure that no advisory locks are left open.
+    unless DB[:pg_locks].where(:locktype => 'advisory').empty?
+      stdout.info "Advisory lock left open: #{desc} @ #{line}"
     end
   end
 end

data/spec/support/shared_examples/adapter.rb

@@ -1,8 +1,21 @@
 shared_examples "a Que adapter" do
-  it "should allow a Postgres connection to be checked out" do
+  it "should be able to execute arbitrary SQL and return indifferent hashes" do
+    result = Que.execute("SELECT 1 AS one")
+    result.should == [{'one'=>'1'}]
+    result.first[:one].should == '1'
+  end
+
+  it "should be able to queue and work a job" do
+    Que::Job.queue
+    Que::Job.work.should be_an_instance_of Que::Job
+  end
+
+  it "should yield the same Postgres connection for the duration of the block" do
     Que.adapter.checkout do |conn|
-      conn.async_exec("SELECT 1 AS one").to_a.should == [{'one' => '1'}]
-      conn.server_version.should > 0
+      conn.should be_a PG::Connection
+      pid1 = Que.execute "SELECT pg_backend_pid()"
+      pid2 = Que.execute "SELECT pg_backend_pid()"
+      pid1.should == pid2
     end
   end
 

data/spec/support/shared_examples/{multithreaded_adapter.rb → multi_threaded_adapter.rb}

@@ -1,4 +1,6 @@
-shared_examples "a multithreaded Que adapter" do
+shared_examples "a multi-threaded Que adapter" do
+  it_behaves_like "a Que adapter"
+
   it "should allow multiple threads to check out their own connections" do
     one = nil
     two = nil

data/spec/unit/helper_spec.rb

@@ -1,15 +1,10 @@
 require 'spec_helper'
 
 describe Que, 'helpers' do
-  it "should be able to run arbitrary SQL" do
-    Que.execute("SELECT 1 AS one").to_a.should == [{'one' => '1'}]
-  end
-
   it "should be able to drop and create the jobs table" do
     DB.table_exists?(:que_jobs).should be true
     Que.drop!
     DB.table_exists?(:que_jobs).should be false
-    Que.execute "SET client_min_messages TO 'warning'" # Avoid annoying NOTICE messages.
     Que.create!
     DB.table_exists?(:que_jobs).should be true
   end

data/spec/unit/pool_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 describe "Managing the Worker pool" do
   it "should log mode changes" do
+    Que.mode = :sync
     Que.mode = :off
-    $logger.messages.should == ["[Que] Set mode to :off"]
+    $logger.messages.should == ["[Que] Set mode to :sync", "[Que] Set mode to :off"]
   end
 
   it "Que.stop! should do nothing if there are no workers running" do
@@ -40,18 +41,51 @@ describe "Managing the Worker pool" do
   describe "Que.mode = :async" do
     it "should spin up 4 workers" do
       Que.mode = :async
-      workers = Que::Worker.workers
-      workers.count.should be 4
-      sleep_until { workers.all?(&:sleeping?) }
+      Que.worker_count.should be 4
+      sleep_until { Que::Worker.workers.all?(&:sleeping?) }
+
+      $logger.messages.should == ["[Que] Set mode to :async", "[Que] Set worker_count to 4"] + ["[Que] No jobs available..."] * 4
+    end
+
+    it "should be done automatically when setting a worker count" do
+      Que.worker_count = 2
+      Que.mode.should == :async
+      Que.worker_count.should == 2
+      sleep_until { Que::Worker.workers.all?(&:sleeping?) }
+
+      $logger.messages.should == ["[Que] Set mode to :async", "[Que] Set worker_count to 2"] + ["[Que] No jobs available..."] * 2
+    end
+
+    it "should not affect the number of workers if a worker_count has already been set" do
+      Que.worker_count = 1
+      Que.mode = :async
+      Que.worker_count.should be 1
+      sleep_until { Que::Worker.workers.all?(&:sleeping?) }
+
+      $logger.messages.should == ["[Que] Set mode to :async", "[Que] Set worker_count to 1", "[Que] No jobs available..."]
+    end
+
+    it "then Que.worker_count = 0 should set the mode to :off" do
+      Que.mode = :async
+      Que.worker_count.should be 4
+
+      sleep_until { Que::Worker.workers.all?(&:sleeping?) }
+
+      Que.worker_count = 0
+      Que.worker_count.should == 0
+      Que.mode.should == :off
+
+      $logger.messages.should == ["[Que] Set mode to :async", "[Que] Set worker_count to 4"] + ["[Que] No jobs available..."] * 4 + ["[Que] Set mode to :off", "[Que] Set worker_count to 0"]
     end
 
     it "then Que.worker_count = 2 should gracefully decrease the number of workers" do
       Que.mode = :async
       workers = Que::Worker.workers.dup
       workers.count.should be 4
+      sleep_until { Que::Worker.workers.all?(&:sleeping?) }
 
       Que.worker_count = 2
-      Que::Worker.workers.count.should be 2
+      Que.worker_count.should be 2
       sleep_until { Que::Worker.workers.all?(&:sleeping?) }
 
       workers[0..1].should == Que::Worker.workers
@@ -59,6 +93,8 @@ describe "Managing the Worker pool" do
         worker.should be_an_instance_of Que::Worker
         worker.thread.status.should == false
       end
+
+      $logger.messages.should == ["[Que] Set mode to :async", "[Que] Set worker_count to 4"] + ["[Que] No jobs available..."] * 4 + ["[Que] Set worker_count to 2"]
     end
 
     it "then Que.worker_count = 6 should gracefully increase the number of workers" do
@@ -66,11 +102,14 @@ describe "Managing the Worker pool" do
       workers = Que::Worker.workers.dup
       workers.count.should be 4
 
+      sleep_until { Que::Worker.workers.all?(&:sleeping?) }
       Que.worker_count = 6
-      Que::Worker.workers.count.should be 6
-      sleep_until { workers.all?(&:sleeping?) }
+      Que.worker_count.should be 6
+      sleep_until { Que::Worker.workers.all?(&:sleeping?) }
 
       workers.should == Que::Worker.workers[0..3]
+
+      $logger.messages.should == ["[Que] Set mode to :async", "[Que] Set worker_count to 4"] + ["[Que] No jobs available..."] * 4 + ["[Que] Set worker_count to 6"] + ["[Que] No jobs available..."] * 2
     end
 
     it "then Que.mode = :off should gracefully shut down workers" do
@@ -78,19 +117,22 @@ describe "Managing the Worker pool" do
       workers = Que::Worker.workers.dup
       workers.count.should be 4
 
+      sleep_until { Que::Worker.workers.all?(&:sleeping?) }
       Que.mode = :off
-      Que::Worker.workers.length.should be 0
+      Que.worker_count.should be 0
 
       workers.count.should be 4
       workers.each { |worker| worker.thread.status.should be false }
+
+      $logger.messages.should == ["[Que] Set mode to :async", "[Que] Set worker_count to 4"] + ["[Que] No jobs available..."] * 4 + ["[Que] Set mode to :off", "[Que] Set worker_count to 0"]
     end
 
-    it "then Que::Worker.wake! should wake up a single worker" do
+    it "then Que.wake! should wake up a single worker" do
       Que.mode = :async
       sleep_until { Que::Worker.workers.all? &:sleeping? }
 
       BlockJob.queue
-      Que::Worker.wake!
+      Que.wake!
 
       $q1.pop
       Que::Worker.workers.first.should be_working
@@ -102,7 +144,13 @@ describe "Managing the Worker pool" do
       DB[:que_jobs].count.should be 0
     end
 
-    it "then Que::Worker.wake_all! should wake up all workers" do
+    it "then Que.wake! should be thread-safe" do
+      Que.mode = :async
+      threads = 4.times.map { Thread.new { 100.times { Que.wake! } } }
+      threads.each(&:join)
+    end
+
+    it "then Que.wake_all! should wake up all workers" do
       # This spec requires at least four connections.
       Que.adapter = QUE_ADAPTERS[:connection_pool]
 
@@ -110,7 +158,7 @@ describe "Managing the Worker pool" do
       sleep_until { Que::Worker.workers.all? &:sleeping? }
 
       4.times { BlockJob.queue }
-      Que::Worker.wake_all!
+      Que.wake_all!
       4.times { $q1.pop }
 
       Que::Worker.workers.each{ |worker| worker.should be_working }
@@ -120,17 +168,18 @@ describe "Managing the Worker pool" do
       DB[:que_jobs].count.should be 0
     end if QUE_ADAPTERS[:connection_pool]
 
-    it "should poke a worker every Que.sleep_period seconds" do
-      begin
-        Que.mode = :async
+    it "then Que.wake_all! should be thread-safe" do
+      Que.mode = :async
+      threads = 4.times.map { Thread.new { 100.times { Que.wake_all! } } }
+      threads.each(&:join)
+    end
 
-        sleep_until { Que::Worker.workers.all? &:sleeping? }
-        Que.sleep_period = 0.01 # 10 ms
-        Que::Job.queue
-        sleep_until { DB[:que_jobs].count == 0 }
-      ensure
-        Que.sleep_period = nil
-      end
+    it "should wake a worker every Que.wake_interval seconds" do
+      Que.mode = :async
+      sleep_until { Que::Worker.workers.all? &:sleeping? }
+      Que.wake_interval = 0.01 # 10 ms
+      Que::Job.queue
+      sleep_until { DB[:que_jobs].count == 0 }
     end
 
     it "then Que.stop! should interrupt all running jobs" do
@@ -145,7 +194,10 @@ describe "Managing the Worker pool" do
         $q1.pop
         Que.stop!
       ensure
-        pg.close if pg
+        if pg
+          # Closing the connection can raise a NullPointerException on JRuby.
+          pg.close rescue nil
+        end
       end
     end
   end