que 0.14.3 → 1.0.0.beta

data/lib/que/adapters/connection_pool.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Que
-  module Adapters
-    class ConnectionPool < Base
-      def initialize(pool)
-        @pool = pool
-        super
-      end
-
-      def checkout(&block)
-        @pool.with(&block)
-      end
-    end
-  end
-end

data/lib/que/adapters/pg.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'monitor'
-
-module Que
-  module Adapters
-    class PG < Base
-      attr_reader :lock
-
-      def initialize(pg)
-        @pg   = pg
-        @lock = Monitor.new # Must be re-entrant.
-        super
-      end
-
-      def checkout
-        @lock.synchronize { yield @pg }
-      end
-    end
-  end
-end

data/lib/que/adapters/pond.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Que
-  module Adapters
-    class Pond < Base
-      def initialize(pond)
-        @pond = pond
-        super
-      end
-
-      def checkout(&block)
-        @pond.checkout(&block)
-      end
-    end
-  end
-end

data/lib/que/adapters/sequel.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Que
-  module Adapters
-    class Sequel < Base
-      def initialize(db)
-        @db = db
-        super
-      end
-
-      def checkout(&block)
-        @db.synchronize(&block)
-      end
-
-      def wake_worker_after_commit
-        @db.after_commit { Que.wake! }
-      end
-    end
-  end
-end

data/lib/que/railtie.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Que
-  class Railtie < Rails::Railtie
-    config.que = Que
-
-    Que.logger         = proc { Rails.logger }
-    Que.mode           = :sync if Rails.env.test?
-    Que.connection     = ::ActiveRecord if defined? ::ActiveRecord
-    Que.json_converter = :with_indifferent_access.to_proc
-
-    rake_tasks do
-      load 'que/rake_tasks.rb'
-    end
-  end
-end

data/lib/que/rake_tasks.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-namespace :que do
-  desc "Process Que's jobs using a worker pool"
-  task :work => :environment do
-    $stdout.sync = true
-
-    $stdout.puts "The que:work rake task has been deprecated and will be removed in Que 1.0. Please transition to the que command line interface instead."
-
-    if defined?(::Rails) && Rails.respond_to?(:application)
-      # ActiveSupport's dependency autoloading isn't threadsafe, and Que uses
-      # multiple threads, which means that eager loading is necessary. Rails
-      # explicitly prevents eager loading when the environment task is invoked,
-      # so we need to manually eager load the app here.
-      Rails.application.eager_load!
-    end
-
-    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
-    Que.queue_name    = ENV['QUE_QUEUE'] if ENV['QUE_QUEUE']
-    Que.mode          = :async
-
-    # When changing how signals are caught, be sure to test the behavior with
-    # the rake task in tasks/safe_shutdown.rb.
-
-    stop = false
-    %w( INT TERM ).each do |signal|
-      trap(signal) {stop = true}
-    end
-
-    at_exit do
-      $stdout.puts "Finishing Que's current jobs before exiting..."
-      Que.worker_count = 0
-      Que.mode = :off
-      $stdout.puts "Que's jobs finished, exiting..."
-    end
-
-    loop do
-      sleep 0.01
-      break if stop
-    end
-  end
-
-  desc "Migrate Que's job table to the most recent version (creating it if it doesn't exist)"
-  task :migrate => :environment do
-    Que.migrate!
-  end
-
-  desc "Drop Que's job table"
-  task :drop => :environment do
-    Que.drop!
-  end
-
-  desc "Clear Que's job table"
-  task :clear => :environment do
-    Que.clear!
-  end
-end

data/lib/que/sql.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-module Que
-  SQL = {
-    # Locks a job using a Postgres recursive CTE [1].
-    #
-    # As noted by the Postgres documentation, it may be slightly easier to
-    # think about this expression as iteration rather than recursion, despite
-    # the `RECURSION` nomenclature defined by the SQL standards committee.
-    # Recursion is used here so that jobs in the table can be iterated one-by-
-    # one until a lock can be acquired, where a non-recursive `SELECT` would
-    # have the undesirable side-effect of locking multiple jobs at once. i.e.
-    # Consider that the following would have the worker lock *all* unlocked
-    # jobs:
-    #
-    #   SELECT (j).*, pg_try_advisory_lock((j).job_id) AS locked
-    #   FROM que_jobs AS j;
-    #
-    # The CTE will initially produce an "anchor" from the non-recursive term
-    # (i.e. before the `UNION`), and then use it as the contents of the
-    # working table as it continues to iterate through `que_jobs` looking for
-    # a lock. The jobs table has a sort on (priority, run_at, job_id) which
-    # allows it to walk the jobs table in a stable manner. As noted above, the
-    # recursion examines one job at a time so that it only ever acquires a
-    # single lock.
-    #
-    # The recursion has two possible end conditions:
-    #
-    # 1. If a lock *can* be acquired, it bubbles up to the top-level `SELECT`
-    #    outside of the `job` CTE which stops recursion because it is
-    #    constrained with a `LIMIT` of 1.
-    #
-    # 2. If a lock *cannot* be acquired, the recursive term of the expression
-    #    (i.e. what's after the `UNION`) will return an empty result set
-    #    because there are no more candidates left that could possibly be
-    #    locked. This empty result automatically ends recursion.
-    #
-    # Note that this query can be easily modified to lock any number of jobs
-    # by tweaking the LIMIT clause in the main SELECT statement.
-    #
-    # [1] http://www.postgresql.org/docs/devel/static/queries-with.html
-    #
-    # Thanks to RhodiumToad in #postgresql for help with the original version
-    # of the job lock CTE.
-    :lock_job => %{
-      WITH RECURSIVE jobs AS (
-        SELECT (j).*, pg_try_advisory_lock((j).job_id) AS locked
-        FROM (
-          SELECT j
-          FROM que_jobs AS j
-          WHERE queue = $1::text
-          AND run_at <= now()
-          ORDER BY priority, run_at, job_id
-          LIMIT 1
-        ) AS t1
-        UNION ALL (
-          SELECT (j).*, pg_try_advisory_lock((j).job_id) AS locked
-          FROM (
-            SELECT (
-              SELECT j
-              FROM que_jobs AS j
-              WHERE queue = $1::text
-              AND run_at <= now()
-              AND (priority, run_at, job_id) > (jobs.priority, jobs.run_at, jobs.job_id)
-              ORDER BY priority, run_at, job_id
-              LIMIT 1
-            ) AS j
-            FROM jobs
-            WHERE jobs.job_id IS NOT NULL
-            LIMIT 1
-          ) AS t1
-        )
-      )
-      SELECT queue, priority, run_at, job_id, job_class, args, error_count
-      FROM jobs
-      WHERE locked
-      LIMIT 1
-    }.freeze,
-
-    :check_job => %{
-      SELECT 1 AS one
-      FROM   que_jobs
-      WHERE  queue    = $1::text
-      AND    priority = $2::smallint
-      AND    run_at   = $3::timestamptz
-      AND    job_id   = $4::bigint
-    }.freeze,
-
-    :set_error => %{
-      UPDATE que_jobs
-      SET error_count = error_count + 1,
-          run_at      = now() + $1::bigint * '1 second'::interval,
-          last_error  = $2::text
-      WHERE queue     = $3::text
-      AND   priority  = $4::smallint
-      AND   run_at    = $5::timestamptz
-      AND   job_id    = $6::bigint
-    }.freeze,
-
-    :insert_job => %{
-      INSERT INTO que_jobs
-      (queue, priority, run_at, job_class, args)
-      VALUES
-      (coalesce($1, '')::text, coalesce($2, 100)::smallint, coalesce($3, now())::timestamptz, $4::text, coalesce($5, '[]')::json)
-      RETURNING *
-    }.freeze,
-
-    :destroy_job => %{
-      DELETE FROM que_jobs
-      WHERE queue    = $1::text
-      AND   priority = $2::smallint
-      AND   run_at   = $3::timestamptz
-      AND   job_id   = $4::bigint
-    }.freeze,
-
-    :job_stats => %{
-      SELECT queue,
-             job_class,
-             count(*)                    AS count,
-             count(locks.job_id)         AS count_working,
-             sum((error_count > 0)::int) AS count_errored,
-             max(error_count)            AS highest_error_count,
-             min(run_at)                 AS oldest_run_at
-      FROM que_jobs
-      LEFT JOIN (
-        SELECT (classid::bigint << 32) + objid::bigint AS job_id
-        FROM pg_locks
-        WHERE locktype = 'advisory'
-      ) locks USING (job_id)
-      GROUP BY queue, job_class
-      ORDER BY count(*) DESC
-    }.freeze,
-
-    :worker_states_95 => %{
-      SELECT que_jobs.*,
-             pg.pid          AS pg_backend_pid,
-             pg.state        AS pg_state,
-             pg.state_change AS pg_state_changed_at,
-             pg.query        AS pg_last_query,
-             pg.query_start  AS pg_last_query_started_at,
-             pg.xact_start   AS pg_transaction_started_at,
-             pg.waiting      AS pg_waiting_on_lock
-      FROM que_jobs
-      JOIN (
-        SELECT (classid::bigint << 32) + objid::bigint AS job_id, pg_stat_activity.*
-        FROM pg_locks
-        JOIN pg_stat_activity USING (pid)
-        WHERE locktype = 'advisory'
-      ) pg USING (job_id)
-    }.freeze,
-
-    :worker_states_96 => %{
-      SELECT que_jobs.*,
-             pg.pid                         AS pg_backend_pid,
-             pg.state                       AS pg_state,
-             pg.state_change                AS pg_state_changed_at,
-             pg.query                       AS pg_last_query,
-             pg.query_start                 AS pg_last_query_started_at,
-             pg.xact_start                  AS pg_transaction_started_at,
-             pg.wait_event_type IS NOT NULL AS pg_waiting_on_lock
-      FROM que_jobs
-      JOIN (
-        SELECT (classid::bigint << 32) + objid::bigint AS job_id, pg_stat_activity.*
-        FROM pg_locks
-        JOIN pg_stat_activity USING (pid)
-        WHERE locktype = 'advisory'
-      ) pg USING (job_id)
-    }.freeze,
-  }.freeze
-end

data/spec/adapters/active_record_spec.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-# Don't run these specs in JRuby until jruby-pg is compatible with ActiveRecord.
-unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-
-  require 'spec_helper'
-  require 'active_record'
-
-  if ActiveRecord.version.release >= Gem::Version.new('4.2') && ActiveRecord.version.release < Gem::Version.new('5.0')
-    ActiveRecord::Base.raise_in_transactional_callbacks = true
-  end
-  ActiveRecord::Base.establish_connection(QUE_URL)
-
-  Que.connection = ActiveRecord
-  QUE_ADAPTERS[:active_record] = Que.adapter
-
-  describe "Que using the ActiveRecord adapter" do
-    before { Que.adapter = QUE_ADAPTERS[:active_record] }
-
-    it_behaves_like "a multi-threaded Que adapter"
-
-    it "should use the same connection that ActiveRecord does" do
-      begin
-        class ActiveRecordJob < Que::Job
-          def run
-            $pid1 = Integer(Que.execute("select pg_backend_pid()").first['pg_backend_pid'])
-            $pid2 = Integer(ActiveRecord::Base.connection.select_value("select pg_backend_pid()"))
-          end
-        end
-
-        ActiveRecordJob.enqueue
-        Que::Job.work
-
-        $pid1.should == $pid2
-      ensure
-        $pid1 = $pid2 = nil
-      end
-    end
-
-    context "if the connection goes down and is reconnected" do
-      around do |example|
-        Que::Job.enqueue
-        ::ActiveRecord::Base.connection_pool.with_connection do |conn|
-          ActiveRecord::Base.connection.reconnect!
-          example.run
-        end
-      end
-
-      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
-        ActiveRecord::Base.transaction do
-          expect { Que::Job.enqueue }.not_to raise_error
-        end
-
-        DB[:que_jobs].count.should == 2
-      end
-
-      it "should log this extraordinary event" do
-        pending
-        $logger.messages.clear
-        Que::Job.enqueue
-
-        if $logger.messages.count != 1
-          puts $logger.messages.inspect
-        end
-
-        $logger.messages.count.should == 1
-        message = JSON.load($logger.messages.first)
-        message['lib'].should == 'que'
-        message['event'].should == 'reprepare_statement'
-        message['name'].should == 'insert_job'
-      end
-    end
-
-    it "should instantiate args as ActiveSupport::HashWithIndifferentAccess" do
-      begin
-        # Mimic the setting in the Railtie.
-        Que.json_converter = :with_indifferent_access.to_proc
-
-        ArgsJob.enqueue :param => 2
-        Que::Job.work
-        $passed_args.first[:param].should == 2
-        $passed_args.first.should be_an_instance_of ActiveSupport::HashWithIndifferentAccess
-      ensure
-        Que.json_converter = Que::INDIFFERENTIATOR
-      end
-    end
-
-    it "should support Rails' special extensions for times" do
-      Que.mode = :async
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-
-      Que::Job.enqueue :run_at => 1.minute.ago
-      DB[:que_jobs].get(:run_at).should be_within(3).of Time.now - 60
-
-      Que.wake_interval = 0.005.seconds
-      sleep_until { DB[:que_jobs].empty? }
-    end
-
-    it "should wake up a Worker after queueing a job in async mode, waiting for a transaction to commit if necessary" do
-      pending
-
-      Que.mode = :async
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-
-      # Wakes a worker immediately when not in a transaction.
-      Que::Job.enqueue
-      sleep_until { Que::Worker.workers.all?(&:sleeping?) && DB[:que_jobs].empty? }
-
-      # Wakes a worker on transaction commit when in a transaction.
-      ActiveRecord::Base.transaction do
-        Que::Job.enqueue
-        Que::Worker.workers.each { |worker| worker.should be_sleeping }
-      end
-      sleep_until { Que::Worker.workers.all?(&:sleeping?) && DB[:que_jobs].empty? }
-
-      # Does nothing when in a nested transaction.
-      # TODO: ideally this would wake after the outer transaction commits
-      if ActiveRecord.version.release >= Gem::Version.new('5.0')
-        ActiveRecord::Base.transaction do
-          ActiveRecord::Base.transaction(requires_new: true) do
-            Que::Job.enqueue
-            Que::Worker.workers.each { |worker| worker.should be_sleeping }
-          end
-        end
-      end
-
-      # Do nothing when queueing with a specific :run_at.
-      BlockJob.enqueue :run_at => Time.now
-      Que::Worker.workers.each { |worker| worker.should be_sleeping }
-    end
-
-    it "should be able to survive an ActiveRecord::Rollback without raising an error" do
-      ActiveRecord::Base.transaction do
-        Que::Job.enqueue
-        raise ActiveRecord::Rollback, "Call tech support!"
-      end
-      DB[:que_jobs].count.should be 0
-    end
-
-    it "should be able to tell when it's in an ActiveRecord transaction" do
-      Que.adapter.should_not be_in_transaction
-      ActiveRecord::Base.transaction do
-        Que.adapter.should be_in_transaction
-      end
-    end
-
-    it "should not leak connections to other databases when using ActiveRecord's multiple database support" do
-      class SecondDatabaseModel < ActiveRecord::Base
-        establish_connection(QUE_URL)
-      end
-
-      SecondDatabaseModel.clear_active_connections!
-      SecondDatabaseModel.connection_handler.active_connections?.should == false
-
-      class SecondDatabaseModelJob < Que::Job
-        def run(*args)
-          SecondDatabaseModel.connection.execute("SELECT 1")
-        end
-      end
-
-      SecondDatabaseModelJob.enqueue
-      Que::Job.work
-
-      SecondDatabaseModel.connection_handler.active_connections?.should == false
-    end
-  end
-end