queue_classic 3.2.0.RC1 → 4.0.0.pre.alpha1

data/sql/downgrade_from_4_0_0.sql

@@ -0,0 +1,88 @@
+DO $$DECLARE r record;
+BEGIN
+  -- If jsonb type is available, do nothing as we're downgrading from 4.0.0
+  IF EXISTS (SELECT 1 FROM pg_type WHERE typname = 'jsonb') THEN
+   -- do nothing - it should already be already jsonb
+  -- Otherwise, use json type for the args column if available
+  ELSIF EXISTS (SELECT 1 FROM pg_type WHERE typname = 'json') THEN
+    -- this should only happen if someone downgrades QC and their database < pg 9.4
+    ALTER TABLE queue_classic_jobs ALTER COLUMN args TYPE json USING args::json;
+  END IF;
+
+
+END$$;
+
+
+--
+-- Re install the lock_head function
+--
+
+-- We are declaring the return type to be queue_classic_jobs.
+-- This is ok since I am assuming that all of the users added queues will
+-- have identical columns to queue_classic_jobs.
+-- When QC supports queues with columns other than the default, we will have to change this.
+
+CREATE OR REPLACE FUNCTION lock_head(q_name varchar, top_boundary integer)
+RETURNS SETOF queue_classic_jobs AS $$
+DECLARE
+  unlocked bigint;
+  relative_top integer;
+  job_count integer;
+BEGIN
+  -- The purpose is to release contention for the first spot in the table.
+  -- The select count(*) is going to slow down dequeue performance but allow
+  -- for more workers. Would love to see some optimization here...
+
+  EXECUTE 'SELECT count(*) FROM '
+    || '(SELECT * FROM queue_classic_jobs '
+    || ' WHERE locked_at IS NULL'
+    || ' AND q_name = '
+    || quote_literal(q_name)
+    || ' AND scheduled_at <= '
+    || quote_literal(now())
+    || ' LIMIT '
+    || quote_literal(top_boundary)
+    || ') limited'
+  INTO job_count;
+
+  SELECT TRUNC(random() * (top_boundary - 1))
+  INTO relative_top;
+
+  IF job_count < top_boundary THEN
+    relative_top = 0;
+  END IF;
+
+  LOOP
+    BEGIN
+      EXECUTE 'SELECT id FROM queue_classic_jobs '
+        || ' WHERE locked_at IS NULL'
+        || ' AND q_name = '
+        || quote_literal(q_name)
+        || ' AND scheduled_at <= '
+        || quote_literal(now())
+        || ' ORDER BY id ASC'
+        || ' LIMIT 1'
+        || ' OFFSET ' || quote_literal(relative_top)
+        || ' FOR UPDATE NOWAIT'
+      INTO unlocked;
+      EXIT;
+    EXCEPTION
+      WHEN lock_not_available THEN
+        -- do nothing. loop again and hope we get a lock
+    END;
+  END LOOP;
+
+  RETURN QUERY EXECUTE 'UPDATE queue_classic_jobs '
+    || ' SET locked_at = (CURRENT_TIMESTAMP),'
+    || ' locked_by = (select pg_backend_pid())'
+    || ' WHERE id = $1'
+    || ' AND locked_at is NULL'
+    || ' RETURNING *'
+  USING unlocked;
+
+  RETURN;
+END $$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION lock_head(tname varchar) RETURNS SETOF queue_classic_jobs AS $$ BEGIN
+  RETURN QUERY EXECUTE 'SELECT * FROM lock_head($1,10)' USING tname;
+END $$ LANGUAGE plpgsql;

data/sql/update_to_3_0_0.sql

@@ -1,10 +1,10 @@
 DO $$DECLARE r record;
 BEGIN
-	BEGIN
-		ALTER TABLE queue_classic_jobs ADD COLUMN created_at timestamptz default now();
-	EXCEPTION
-		WHEN duplicate_column THEN RAISE NOTICE 'column created_at already exists in queue_classic_jobs.';
-	END;
+  BEGIN
+    ALTER TABLE queue_classic_jobs ADD COLUMN created_at timestamptz DEFAULT now();
+  EXCEPTION
+    WHEN duplicate_column THEN RAISE NOTICE 'column created_at already exists in queue_classic_jobs.';
+  END;
 END$$;
 
 DO $$DECLARE r record;

data/sql/update_to_3_1_0.sql

@@ -1,9 +1,9 @@
 DO $$DECLARE r record;
 BEGIN
-	BEGIN
-		ALTER TABLE queue_classic_jobs ADD COLUMN scheduled_at timestamptz default now();
-		CREATE INDEX idx_qc_on_scheduled_at_only_unlocked ON queue_classic_jobs (scheduled_at, id) WHERE locked_at IS NULL;
-	EXCEPTION
-		WHEN duplicate_column THEN RAISE NOTICE 'column scheduled_at already exists in queue_classic_jobs.';
-	END;
+  BEGIN
+    ALTER TABLE queue_classic_jobs ADD COLUMN scheduled_at timestamptz DEFAULT now();
+    CREATE INDEX idx_qc_on_scheduled_at_only_unlocked ON queue_classic_jobs (scheduled_at, id) WHERE locked_at IS NULL;
+  EXCEPTION
+    WHEN duplicate_column THEN RAISE NOTICE 'column scheduled_at already exists in queue_classic_jobs.';
+  END;
 END$$;

data/sql/update_to_4_0_0.sql

@@ -0,0 +1,6 @@
+DO $$DECLARE r record;
+BEGIN
+  ALTER TABLE queue_classic_jobs ALTER COLUMN args TYPE jsonb USING args::jsonb;
+  DROP FUNCTION IF EXISTS lock_head(tname varchar);
+  DROP FUNCTION IF EXISTS lock_head(q_name varchar, top_boundary integer);
+END$$;

data/test/benchmark_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'helper'
 
 if ENV["QC_BENCHMARK"]

data/test/config_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'helper'
 
 class ConfigTest < QCTest

data/test/helper.rb

@@ -1,6 +1,16 @@
+# frozen_string_literal: true
+
 require "bundler"
+require "minitest/reporters"
+
 Bundler.setup :default, :test
 
+if ENV['CIRCLECI'] == "true"
+  Minitest::Reporters.use! Minitest::Reporters::JUnitReporter.new
+else
+  Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+end
+
 ENV["DATABASE_URL"] ||= "postgres:///queue_classic_test"
 
 require_relative '../lib/queue_classic'
@@ -58,4 +68,28 @@ class QCTest < Minitest::Test
   ensure
     original_environment.each { |name, value| ENV[name] = value }
   end
+
+  def stub_any_instance(class_name, method_name, definition)
+    new_method_name = "new_#{method_name}"
+    original_method_name = "original_#{method_name}"
+
+    method_present = class_name.instance_methods(false).include? method_name
+
+    if method_present
+      class_name.send(:alias_method, original_method_name, method_name)
+      class_name.send(:define_method, new_method_name, definition)
+      class_name.send(:alias_method, method_name, new_method_name)
+
+      yield
+    else
+      message = "#{class_name} does not have method #{method_name}."
+      message << "\nAvailable methods: #{class_name.instance_methods(false)}"
+      raise ArgumentError.new message
+    end
+  ensure
+    if method_present
+      class_name.send(:alias_method, method_name, original_method_name)
+      class_name.send(:undef_method, new_method_name)
+    end
+  end
 end

data/test/lib/queue_classic_rails_connection_test.rb

@@ -1,15 +1,14 @@
+# frozen_string_literal: true
+
 require File.expand_path("../../helper.rb", __FILE__)
 
 class QueueClassicRailsConnectionTest < QCTest
   def before_setup
-    Object.send :const_set, :ActiveRecord, Module.new
-    ActiveRecord.const_set :Base, Module.new
-
     @original_conn_adapter = QC.default_conn_adapter
     QC.default_conn_adapter = nil
   end
 
-  def after_teardown
+  def before_teardown
     ActiveRecord.send :remove_const, :Base
     Object.send :remove_const, :ActiveRecord
 
@@ -18,12 +17,14 @@ class QueueClassicRailsConnectionTest < QCTest
 
   def test_uses_active_record_connection_if_exists
     connection = get_connection
-    assert connection.verify
+    QC.default_conn_adapter.execute('SELECT 1;')
+    connection.verify
   end
 
   def test_does_not_use_active_record_connection_if_env_var_set
     with_env 'QC_RAILS_DATABASE' => 'false' do
       connection = get_connection
+      QC.default_conn_adapter.execute('SELECT 1;')
       assert_raises(MockExpectationError) { connection.verify }
     end
   end
@@ -31,8 +32,10 @@ class QueueClassicRailsConnectionTest < QCTest
   private
   def get_connection
     connection = Minitest::Mock.new
-    connection.expect(:raw_connection, QC::ConnAdapter.new.connection)
+    connection.expect(:raw_connection, QC::ConnAdapter.new(active_record_connection_share: true).connection)
 
+    Object.send :const_set, :ActiveRecord, Module.new
+    ActiveRecord.const_set :Base, Module.new
     ActiveRecord::Base.define_singleton_method(:connection) do
       connection
     end

data/test/lib/queue_classic_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path("../../helper.rb", __FILE__)
 
 class QueueClassicTest < QCTest

data/test/queue_test.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require_relative 'helper'
 
 class QueueTest < QCTest
 
-  ResetError = Class.new(PGError)
+  ResetError = Class.new(PG::Error)
 
   def test_enqueue
     QC.enqueue("Klass.method")
@@ -62,6 +64,20 @@ class QueueTest < QCTest
   def test_count
     QC.enqueue("Klass.method")
     assert_equal(1, QC.count)
+
+    QC.enqueue("Klass.method")
+    assert_equal(2, QC.count)
+    assert_equal(2, QC.count_ready)
+    assert_equal(0, QC.count_scheduled)
+
+    QC.enqueue_in(60, "Klass.method")
+    assert_equal(3, QC.count)
+    assert_equal(2, QC.count_ready)
+    assert_equal(1, QC.count_scheduled)
+
+    assert_raises(ArgumentError) do
+      QC.count(:potatoes)
+    end
   end
 
   def test_delete
@@ -105,13 +121,57 @@ class QueueTest < QCTest
     queue.enqueue("Klass.method")
     assert_equal(1, queue.count)
     conn = queue.conn_adapter.connection
-    def conn.exec(*args); raise(PGError); end
+    def conn.exec(*args); raise(PG::Error); end
     def conn.reset(*args); raise(ResetError)  end
     # We ensure that the reset method is called on the connection.
     assert_raises(PG::Error, ResetError) {queue.enqueue("Klass.other_method")}
     queue.conn_adapter.disconnect
   end
 
+  def test_enqueue_retry
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    conn = queue.conn_adapter.connection
+    conn.exec('select pg_terminate_backend(pg_backend_pid())') rescue nil
+    queue.enqueue("Klass.method")
+    assert_equal(1, queue.count)
+    queue.conn_adapter.disconnect
+  end
+
+  def test_enqueue_stops_retrying_on_permanent_error
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    conn = queue.conn_adapter.connection
+    conn.exec('select pg_terminate_backend(pg_backend_pid())') rescue nil
+    # Simulate permanent connection error
+    def conn.exec(*args); raise(PG::Error); end
+    # Ensure that the error is reraised on second time
+    assert_raises(PG::Error) {queue.enqueue("Klass.other_method")}
+    queue.conn_adapter.disconnect
+  end
+
+  def test_enqueue_in_retry
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    conn = queue.conn_adapter.connection
+    conn.exec('select pg_terminate_backend(pg_backend_pid())') rescue nil
+    queue.enqueue_in(10,"Klass.method")
+    assert_equal(1, queue.count)
+    queue.conn_adapter.disconnect
+  end
+
+  def test_enqueue_in_stops_retrying_on_permanent_error
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    conn = queue.conn_adapter.connection
+    conn.exec('select pg_terminate_backend(pg_backend_pid())') rescue nil
+    # Simulate permanent connection error
+    def conn.exec(*args); raise(PG::Error); end
+    # Ensure that the error is reraised on second time
+    assert_raises(PG::Error) {queue.enqueue_in(10,"Klass.method")}
+    queue.conn_adapter.disconnect
+  end
+
   def test_custom_default_queue
     queue_class = Class.new do
       attr_accessor :jobs

data/test/rails-tests/.gitignore

@@ -0,0 +1,2 @@
+vendor/
+qctest*/

data/test/rails-tests/rails523.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+set -e
+
+# remove any old folder, should only matter locally
+rm -rf qctest523
+
+# install rails but not with much stuff
+gem install rails -v 5.2.3
+rails new qctest523 --api --database=postgresql --skip-test-unit --skip-keeps --skip-spring --skip-sprockets --skip-javascript --skip-turbolinks
+cd qctest523
+
+# get the db setup, run any default migrations
+bundle install
+bundle exec rails db:drop:all
+bundle exec rails db:create
+bundle exec rails db:migrate
+bundle exec rails db:setup
+
+# install qc --> gem file, bundle, add ourselves and migrate.
+echo "gem 'queue_classic', path: '../../../'" >> Gemfile
+bundle install
+bundle exec rails generate queue_classic:install
+bundle exec rails db:migrate

data/test/worker_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'helper'
 
 module TestObject
@@ -121,16 +123,16 @@ class WorkerTest < QCTest
     t.join
   end
 
-  def test_worker_uses_one_conn
-    skip "This test is broken and needs to be fixed."
-
+  def test_worker_reuses_conn
     QC.enqueue("TestObject.no_args")
+    count = QC.default_conn_adapter.execute("SELECT count(*) from pg_stat_activity where datname = current_database()")["count"].to_i;
     worker = TestWorker.new
     worker.work
-    assert_equal(
-      1,
-      QC.default_conn_adapter.execute("SELECT count(*) from pg_stat_activity where datname = current_database()")["count"].to_i,
-      "Multiple connections found -- are there open connections to #{ QC.default_conn_adapter.send(:db_url) } in other terminals?"
+
+    new_count = QC.default_conn_adapter.execute("SELECT count(*) from pg_stat_activity where datname = current_database()")["count"].to_i;
+    assert(
+      new_count == count,
+      "Worker should not initialize new connections to #{ QC.default_conn_adapter.send(:db_url) }."
     )
   end
 
@@ -176,15 +178,6 @@ class WorkerTest < QCTest
     assert_equal(0, worker.failed_count)
   end
 
-  def test_init_worker_with_arg
-    with_database 'postgres:///invalid' do
-      conn = PG::Connection.connect(dbname: 'queue_classic_test')
-      QC::Worker.new connection: conn
-
-      conn.close
-    end
-  end
-
   def test_init_worker_with_database_url
     with_database ENV['DATABASE_URL'] || ENV['QC_DATABASE_URL'] do
       worker = QC::Worker.new
@@ -197,7 +190,135 @@ class WorkerTest < QCTest
 
   def test_init_worker_without_conn
     with_database nil do
-      assert_raises(ArgumentError) { QC::Worker.new }
+      assert_raises(ArgumentError) do
+        worker = QC::Worker.new
+        QC.enqueue("TestObject.no_args")
+        worker.lock_job
+      end
+    end
+  end
+
+  def test_worker_unlocks_job_on_signal_exception
+    job_details = QC.enqueue("Kernel.eval", "raise SignalException.new('INT')")
+    worker = TestWorker.new
+
+    unlocked = nil
+
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        worker.work
+      rescue SignalException
+      ensure
+        assert unlocked, "SignalException failed to unlock the job in the queue."
+      end
+    end
+  end
+
+  def test_worker_unlocks_job_on_system_exit
+    job_details = QC.enqueue("Kernel.eval", "raise SystemExit.new")
+    worker = TestWorker.new
+
+    unlocked = nil
+
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        worker.work
+      rescue SystemExit
+      ensure
+        assert unlocked, "SystemExit failed to unlock the job in the queue."
+      end
+    end
+  end
+
+  def test_worker_does_not_unlock_jobs_on_syntax_error
+    job_details = QC.enqueue("Kernel.eval", "bad syntax")
+    worker = TestWorker.new
+
+    unlocked = nil
+
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        errors = capture_stderr_output do
+          worker.work
+        end
+      ensure
+        message = ["SyntaxError unexpectedly unlocked the job in the queue."]
+        message << "Errors:\n#{errors}" unless errors.empty?
+        refute unlocked, message.join("\n")
+      end
+    end
+  end
+
+  def test_worker_does_not_unlock_jobs_on_load_error
+    job_details = QC.enqueue("Kernel.eval", "require 'not_a_real_file'")
+    worker = TestWorker.new
+
+    unlocked = nil
+
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        errors = capture_stderr_output do
+          worker.work
+        end
+      ensure
+        message = ["LoadError unexpectedly unlocked the job in the queue."]
+        message << "Errors:\n#{errors}" unless errors.empty?
+        refute unlocked, message.join("\n")
+      end
+    end
+  end
+
+  def test_worker_does_not_unlock_jobs_on_no_memory_error
+    job_details = QC.enqueue("Kernel.eval", "raise NoMemoryError.new")
+    worker = TestWorker.new
+
+    unlocked = nil
+
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        errors = capture_stderr_output do
+          worker.work
+        end
+      ensure
+        message = ["NoMemoryError unexpectedly unlocked the job in the queue."]
+        message << "Errors:\n#{errors}" unless errors.empty?
+        refute unlocked, message.join("\n")
+      end
     end
   end