que 0.4.0 → 0.5.0

data/lib/que/adapters/active_record.rb

@@ -2,7 +2,32 @@ module Que
   module Adapters
     class ActiveRecord < Base
       def checkout
-        ::ActiveRecord::Base.connection_pool.with_connection { |conn| yield conn.raw_connection }
+        checkout_activerecord_adapter { |conn| yield conn.raw_connection }
+      end
+
+      def wake_worker_after_commit
+        # Works with ActiveRecord 3.2 and 4 (possibly earlier, didn't check)
+        if in_transaction?
+          checkout_activerecord_adapter { |adapter| adapter.add_transaction_record(CommittedCallback.new) }
+        else
+          Que.wake!
+        end
+      end
+
+      class CommittedCallback
+        def has_transactional_callbacks?
+          true
+        end
+
+        def committed!
+          Que.wake!
+        end
+      end
+
+      private
+
+      def checkout_activerecord_adapter(&block)
+        ::ActiveRecord::Base.connection_pool.with_connection(&block)
       end
     end
   end

data/lib/que/adapters/base.rb

@@ -7,7 +7,7 @@ module Que
 
     class Base
       def initialize(thing = nil)
-        @statement_mutex = Mutex.new
+        @prepared_statements = {}
       end
 
       # The only method that adapters really need to implement. Should lock a
@@ -18,7 +18,7 @@ module Que
         raise NotImplementedError
       end
 
-      # Called after a job is queued in async mode, to prompts a worker to
+      # Called after a job is queued in async mode, to prompt a worker to
       # wake up after the current transaction commits. Not all adapters will
       # implement this.
       def wake_worker_after_commit
@@ -31,26 +31,19 @@ module Que
 
       def execute_prepared(name, params = [])
         checkout do |conn|
-          unless statements_prepared(conn)[name]
+          statements = @prepared_statements[conn] ||= {}
+
+          unless statements[name]
             conn.prepare("que_#{name}", SQL[name])
-            statements_prepared(conn)[name] = true
+            statements[name] = true
           end
 
           conn.exec_prepared("que_#{name}", params)
         end
       end
 
-      private
-
-      # Each adapter needs to remember which of its connections have prepared
-      # which statements. This is a shared data structure, so protect it. We
-      # assume that the hash of statements for a particular connection is only
-      # being accessed by the thread that's checked it out, though.
-      def statements_prepared(conn)
-        @statement_mutex.synchronize do
-          @statements_prepared       ||= {}
-          @statements_prepared[conn] ||= {}
-        end
+      def in_transaction?
+        checkout { |conn| conn.transaction_status != ::PG::PQTRANS_IDLE }
       end
     end
   end

data/lib/que/job.rb

@@ -1,12 +1,10 @@
-require 'multi_json'
-
 module Que
   class Job
     attr_reader :attrs
 
     def initialize(attrs)
       @attrs        = attrs
-      @attrs[:args] = Que.indifferentiate MultiJson.load(@attrs[:args])
+      @attrs[:args] = Que.indifferentiate JSON_MODULE.load(@attrs[:args])
     end
 
     # Subclasses should define their own run methods, but keep an empty one
@@ -15,10 +13,8 @@ module Que
     end
 
     def _run
-      time = Time.now
       run *attrs[:args]
       destroy unless @destroyed
-      Que.log :info, "Worked job in #{((Time.now - time) * 1000).round(1)} ms: #{inspect}"
     end
 
     private
@@ -37,7 +33,7 @@ module Que
           args << options if options.any?
         end
 
-        attrs = {:job_class => to_s, :args => MultiJson.dump(args)}
+        attrs = {:job_class => to_s, :args => JSON_MODULE.dump(args)}
 
         if time = run_at || @default_run_at && @default_run_at.call
           attrs[:run_at] = time
@@ -57,12 +53,6 @@ module Que
       end
 
       def work
-        # Job.work is typically called in a loop, where we sleep when there's
-        # no more work to be done, so its return value should reflect whether
-        # we should look for another job or not. So, return truthy if we
-        # worked a job or encountered a typical error while working a job, and
-        # falsy if we found nothing to do or hit a connection error.
-
         # Since we're taking session-level advisory locks, we have to hold the
         # same connection throughout the process of getting a job, working it,
         # deleting it, and removing the lock.
@@ -79,12 +69,13 @@ module Que
               # Note that there is currently no spec for this behavior, since
               # I'm not sure how to reliably commit a transaction that deletes
               # the job in a separate thread between lock_job and check_job.
-              return true if Que.execute(:check_job, job.values_at(:priority, :run_at, :job_id)).none?
-
-              run_job(job)
+              if Que.execute(:check_job, job.values_at(:priority, :run_at, :job_id)).none?
+                {:event => :job_race_condition}
+              else
+                {:event => :job_worked, :job => run_job(job).attrs}
+              end
             else
-              Que.log :info, "No jobs available..."
-              nil
+              {:event => :job_unavailable}
             end
           rescue => error
             begin
@@ -105,12 +96,7 @@ module Que
               Que.error_handler.call(error) rescue nil
             end
 
-            # If it's a garden variety error, we can just return true, pick up
-            # another job, no big deal. If it's a PG::Error, though, assume
-            # it's a disconnection or something and that we shouldn't just hit
-            # the database again right away. We could be a lot more
-            # sophisticated about what errors we delay for, though.
-            return !error.is_a?(PG::Error)
+            return {:event => :job_errored, :error => error, :job => job}
           ensure
             # Clear the advisory lock we took when locking the job. Important
             # to do this so that they don't pile up in the database. Again, if

data/lib/que/migrations.rb

@@ -0,0 +1,78 @@
+module Que
+  module Migrations
+    # In order to ship a schema change, add the relevant up and down sql files
+    # to the migrations directory, and bump the version both here and in the
+    # add_que generator template.
+    CURRENT_VERSION = 2
+
+    class << self
+      def migrate!(options = {:version => CURRENT_VERSION})
+        transaction do
+          version = options[:version]
+
+          if (current = db_version) == version
+            return
+          elsif current < version
+            direction = 'up'
+            steps = ((current + 1)..version).to_a
+          elsif current > version
+            direction = 'down'
+            steps = ((version + 1)..current).to_a.reverse
+          end
+
+          steps.each do |step|
+            Que.execute File.read("#{File.dirname(__FILE__)}/migrations/#{step}-#{direction}.sql")
+          end
+
+          set_db_version(version)
+        end
+      end
+
+      def db_version
+        result = Que.execute <<-SQL
+          SELECT relname, description
+          FROM pg_class
+          LEFT JOIN pg_description ON pg_description.objoid = pg_class.oid
+          WHERE relname = 'que_jobs'
+        SQL
+
+        if result.none?
+          # No table in the database at all.
+          0
+        elsif (d = result.first[:description]).nil?
+          # There's a table, it was just created before the migration system existed.
+          1
+        else
+          d.to_i
+        end
+      end
+
+      def set_db_version(version)
+        i = version.to_i
+        Que.execute "COMMENT ON TABLE que_jobs IS '#{i}'" unless i.zero?
+      end
+
+      def transaction
+        Que.adapter.checkout do
+          if Que.adapter.in_transaction?
+            yield
+          else
+            begin
+              Que.execute "BEGIN"
+              yield
+            rescue => error
+              raise
+            ensure
+              # Handle a raised error or a killed thread.
+              if error || Thread.current.status == 'aborting'
+                Que.execute "ROLLBACK"
+              else
+                Que.execute "COMMIT"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/que/migrations/1-down.sql

@@ -0,0 +1 @@
+DROP TABLE que_jobs;

data/lib/que/migrations/1-up.sql

@@ -0,0 +1,12 @@
+CREATE TABLE que_jobs
+(
+  priority    integer     NOT NULL DEFAULT 1,
+  run_at      timestamptz NOT NULL DEFAULT now(),
+  job_id      bigserial   NOT NULL,
+  job_class   text        NOT NULL,
+  args        json        NOT NULL DEFAULT '[]'::json,
+  error_count integer     NOT NULL DEFAULT 0,
+  last_error  text,
+
+  CONSTRAINT que_jobs_pkey PRIMARY KEY (priority, run_at, job_id)
+);

data/lib/que/migrations/2-down.sql

@@ -0,0 +1 @@
+ALTER TABLE que_jobs ALTER COLUMN priority SET DEFAULT 1;

data/lib/que/migrations/2-up.sql

@@ -0,0 +1,3 @@
+-- 1 was a bad default. Starting from there, you couldn't tweak some jobs to
+-- be more important without going into negative priorities, which is weird.
+ALTER TABLE que_jobs ALTER COLUMN priority SET DEFAULT 100;

data/lib/que/railtie.rb

@@ -3,7 +3,7 @@ module Que
     config.que = Que
 
     Que.mode       = :sync if Rails.env.test?
-    Que.connection = ::ActiveRecord if defined?(::ActiveRecord)
+    Que.connection = ::ActiveRecord if defined? ::ActiveRecord
 
     rake_tasks do
       load 'que/rake_tasks.rb'
@@ -16,8 +16,13 @@ module Que
         # Only start up the worker pool if running as a server.
         Que.mode ||= :async if defined? Rails::Server
 
-        # When the process exits, safely interrupt any jobs that are still running.
-        at_exit { Que.stop! }
+        at_exit do
+          if Que.mode == :async
+            $stdout.puts "Finishing Que's current jobs before exiting..."
+            Que.mode = :off
+            $stdout.puts "Que's jobs finished, exiting..."
+          end
+        end
       end
     end
   end

data/lib/que/rake_tasks.rb

@@ -3,19 +3,23 @@ namespace :que do
   task :work => :environment do
     require 'logger'
 
-    Que.logger       = Logger.new(STDOUT)
-    Que.worker_count = (ENV['WORKER_COUNT'] || 4).to_i
+    Que.logger        = Logger.new(STDOUT)
+    Que.logger.level  = Logger.const_get((ENV['QUE_LOG_LEVEL'] || 'INFO').upcase)
+    Que.worker_count  = (ENV['QUE_WORKER_COUNT'] || 4).to_i
+    Que.wake_interval = (ENV['QUE_WAKE_INTERVAL'] || 0.1).to_f
 
     # When changing how signals are caught, be sure to test the behavior with
     # the rake task in tasks/safe_shutdown.rb.
-    at_exit do
-      puts "Stopping Que..."
-      Que.stop!
-    end
 
     stop = false
     trap('INT'){stop = true}
 
+    at_exit do
+      $stdout.puts "Finishing Que's current jobs before exiting..."
+      Que.mode = :off
+      $stdout.puts "Que's jobs finished, exiting..."
+    end
+
     loop do
       sleep 0.01
       break if stop

data/lib/que/sql.rb

@@ -55,7 +55,7 @@ module Que
       INSERT INTO que_jobs
       (priority, run_at, job_class, args)
       VALUES
-      (coalesce($1, 1)::integer, coalesce($2, 'now')::timestamptz, $3::text, coalesce($4, '[]')::json)
+      (coalesce($1, 100)::integer, coalesce($2, 'now')::timestamptz, $3::text, coalesce($4, '[]')::json)
       RETURNING *
     }.freeze,
 
@@ -99,34 +99,6 @@ module Que
         JOIN pg_stat_activity USING (pid)
         WHERE locktype = 'advisory'
       ) pg USING (job_id)
-    }.freeze,
-
-    :create_table => %{
-      CREATE TABLE que_jobs
-      (
-        priority    integer     NOT NULL DEFAULT 1,
-        run_at      timestamptz NOT NULL DEFAULT now(),
-        job_id      bigserial   NOT NULL,
-        job_class   text        NOT NULL,
-        args        json        NOT NULL DEFAULT '[]'::json,
-        error_count integer     NOT NULL DEFAULT 0,
-        last_error  text,
-
-        CONSTRAINT que_jobs_pkey PRIMARY KEY (priority, run_at, job_id)
-      )
     }.freeze
-
-    # Note: if schema changes to the que_jobs table become necessary later on,
-    # a simple versioning scheme would be:
-
-    # Set version:
-    # COMMENT ON TABLE que_jobs IS '2'
-
-    # Get version:
-    # SELECT description
-    # FROM pg_description
-    # JOIN pg_class
-    # ON pg_description.objoid = pg_class.oid
-    # WHERE relname = 'que_jobs'
   }
 end

data/lib/que/version.rb

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

data/lib/que/worker.rb

@@ -8,9 +8,6 @@ module Que
     # synchronize access to it.
     include MonitorMixin
 
-    # A custom exception to immediately kill a worker and its current job.
-    class Stop < Interrupt; end
-
     attr_reader :thread, :state
 
     def initialize
@@ -24,15 +21,7 @@ module Que
     end
 
     def sleeping?
-      synchronize do
-        if @state == :sleeping
-          # There's a very small period of time between when the Worker marks
-          # itself as sleeping and when it actually goes to sleep. Only report
-          # true when we're certain the thread is sleeping.
-          wait until @thread.status == 'sleep'
-          true
-        end
-      end
+      synchronize { _sleeping? }
     end
 
     def working?
@@ -51,20 +40,10 @@ module Que
       end
     end
 
-    # #stop informs the worker that it should shut down after its next job,
-    # while #stop! kills the job and worker immediately. #stop! is bad news
-    # because its results are unpredictable (it can leave the DB connection
-    # in an unusable state), so it should only be used when we're shutting
-    # down the whole process anyway and side effects aren't a big deal.
+    # This needs to be called when trapping a signal, so it can't lock the monitor.
     def stop
-      synchronize do
-        @stop = true
-        @thread.wakeup if sleeping?
-      end
-    end
-
-    def stop!
-      @thread.raise Stop
+      @stop = true
+      @thread.wakeup if _sleeping?
     end
 
     def wait_until_stopped
@@ -78,15 +57,47 @@ module Que
       sleep 0.0001
     end
 
+    def _sleeping?
+      if @state == :sleeping
+        # There's a very small period of time between when the Worker marks
+        # itself as sleeping and when it actually goes to sleep. Only report
+        # true when we're certain the thread is sleeping.
+        wait until @thread.status == 'sleep'
+        true
+      end
+    end
+
     def work_loop
       loop do
-        job = Job.work
-        synchronize { @state = :sleeping unless @stop || job }
+        time   = Time.now
+        cycle  = nil
+        result = Job.work
+
+        case result[:event]
+        when :job_unavailable
+          cycle = false
+          result[:level] = :debug
+        when :job_race_condition
+          cycle = true
+          result[:level] = :debug
+        when :job_worked
+          cycle = true
+          result[:elapsed] = (Time.now - time).round(5)
+        when :job_errored
+          # For PG::Errors, assume we had a problem reaching the database, and
+          # don't hit it again right away.
+          cycle = !result[:error].is_a?(PG::Error)
+          result[:error] = {:class => result[:error].class.to_s, :message => result[:error].message}
+        else
+          raise "Unknown Event: #{result[:event].inspect}"
+        end
+
+        Que.log(result)
+
+        synchronize { @state = :sleeping unless cycle || @stop }
         sleep if @state == :sleeping
         break if @stop
       end
-    rescue Stop
-      # This process is shutting down - let it.
     ensure
       @state = :stopped
     end
@@ -97,7 +108,12 @@ 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 { loop { sleep(*@wake_interval); wake! if @wake_interval } }
+    @wrangler = Thread.new do
+      loop do
+        sleep *@wake_interval
+        wake! if @wake_interval
+      end
+    end
 
     class << self
       attr_reader :mode, :wake_interval
@@ -129,19 +145,6 @@ module Que
         @wrangler.wakeup
       end
 
-      def stop!
-        # The behavior of Worker#stop! is unpredictable - what it does is
-        # dependent on what the Worker is currently doing. Sometimes it won't
-        # work the first time, so we need to try again, but sometimes it'll
-        # never do anything, so we can't repeat indefinitely. So, compromise.
-        5.times do
-          break if workers.select(&:alive?).each(&:stop!).none?
-          sleep 0.001
-        end
-
-        workers.clear
-      end
-
       def wake!
         workers.find &:wake!
       end
@@ -154,17 +157,17 @@ module Que
 
       def set_mode(mode)
         if mode != @mode
-          Que.log :info, "Set mode to #{mode.inspect}"
+          Que.log :event => 'mode_change', :value => mode.to_s
           @mode = mode
         end
       end
 
       def set_worker_count(count)
         if count != worker_count
-          Que.log :info, "Set worker_count to #{count.inspect}"
+          Que.log :event => 'worker_count_change', :value => count.to_s
 
           if count > worker_count
-            workers.push *(count - worker_count).times.map { new }
+            workers.push *(count - worker_count).times.map{new}
           elsif count < worker_count
             workers.pop(worker_count - count).each(&:stop).each(&:wait_until_stopped)
           end