with_advisory_lock 4.0.0 → 5.0.0

data/gemfiles/{activerecord_5.2.gemfile → activerecord_7.0.gemfile}

@@ -2,12 +2,14 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 5.1.0"
+gem "activerecord", "~> 7.0.0"
 
 platforms :ruby do
+  gem "sqlite3"
   gem "mysql2"
+  gem "trilogy"
+  gem "activerecord-trilogy-adapter"
   gem "pg"
-  gem "sqlite3"
 end
 
 platforms :jruby do

data/gemfiles/activerecord_7.1.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 7.1.0"
+
+platforms :ruby do
+  gem "sqlite3"
+  gem "mysql2"
+  gem "trilogy"
+  gem "pg"
+end
+
+gemspec path: "../"

data/lib/with_advisory_lock/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'zlib'
 
 module WithAdvisoryLock
@@ -19,17 +21,18 @@ module WithAdvisoryLock
   LockStackItem = Struct.new(:name, :shared)
 
   class Base
-    attr_reader :connection, :lock_name, :timeout_seconds, :shared, :transaction
+    attr_reader :connection, :lock_name, :timeout_seconds, :shared, :transaction, :disable_query_cache
 
     def initialize(connection, lock_name, options)
       options = { timeout_seconds: options } unless options.respond_to?(:fetch)
-      options.assert_valid_keys :timeout_seconds, :shared, :transaction
+      options.assert_valid_keys :timeout_seconds, :shared, :transaction, :disable_query_cache
 
       @connection = connection
       @lock_name = lock_name
       @timeout_seconds = options.fetch(:timeout_seconds, nil)
       @shared = options.fetch(:shared, false)
       @transaction = options.fetch(:transaction, false)
+      @disable_query_cache = options.fetch(:disable_query_cache, false)
     end
 
     def lock_str
@@ -51,6 +54,16 @@ module WithAdvisoryLock
     end
 
     def with_advisory_lock_if_needed(&block)
+      if disable_query_cache
+        return lock_and_yield do
+          ActiveRecord::Base.uncached(&block)
+        end
+      end
+
+      lock_and_yield(&block)
+    end
+
+    def lock_and_yield(&block)
       if already_locked?
         Result.new(true, yield)
       elsif timeout_seconds == 0
@@ -75,6 +88,7 @@ module WithAdvisoryLock
       while @timeout_seconds.nil? || Time.now < give_up_at
         r = yield_with_lock(&block)
         return r if r.lock_was_acquired?
+
         # Randomizing sleep time may help reduce contention.
         sleep(rand(0.05..0.15))
       end

data/lib/with_advisory_lock/concern.rb

@@ -1,16 +1,27 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module WithAdvisoryLock
   module Concern
     extend ActiveSupport::Concern
-    delegate :with_advisory_lock, :advisory_lock_exists?, to: 'self.class'
+    delegate :with_advisory_lock, :with_advisory_lock!, :advisory_lock_exists?, to: 'self.class'
 
-    module ClassMethods
+    class_methods do
       def with_advisory_lock(lock_name, options = {}, &block)
         result = with_advisory_lock_result(lock_name, options, &block)
         result.lock_was_acquired? ? result.result : false
       end
 
+      def with_advisory_lock!(lock_name, options = {}, &block)
+        result = with_advisory_lock_result(lock_name, options, &block)
+        unless result.lock_was_acquired?
+          raise WithAdvisoryLock::FailedToAcquireLock, lock_name
+        end
+
+        result.result
+      end
+
       def with_advisory_lock_result(lock_name, options = {}, &block)
         impl = impl_class.new(connection, lock_name, options)
         impl.with_advisory_lock_if_needed(&block)

data/lib/with_advisory_lock/database_adapter_support.rb

@@ -1,11 +1,18 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
   class DatabaseAdapterSupport
+    # Caches nested lock support by MySQL reported version
+    @@mysql_nl_cache       = {}
+    @@mysql_nl_cache_mutex = Mutex.new
+
     def initialize(connection)
-      @sym_name = connection.adapter_name.downcase.to_sym
+      @connection = connection
+      @sym_name   = connection.adapter_name.downcase.to_sym
     end
 
     def mysql?
-      %i[mysql mysql2].include? @sym_name
+      %i[mysql2 trilogy].include? @sym_name
     end
 
     def postgresql?
@@ -13,7 +20,7 @@ module WithAdvisoryLock
     end
 
     def sqlite?
-      :sqlite3 == @sym_name
+      @sym_name == :sqlite3
     end
   end
 end

data/lib/with_advisory_lock/failed_to_acquire_lock.rb

@@ -0,0 +1,7 @@
+module WithAdvisoryLock
+  class FailedToAcquireLock < StandardError
+    def initialize(lock_name)
+      super("Failed to acquire lock #{lock_name}")
+    end
+  end
+end

data/lib/with_advisory_lock/flock.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 
 module WithAdvisoryLock
@@ -19,9 +21,8 @@ module WithAdvisoryLock
     end
 
     def try_lock
-      if transaction
-        raise ArgumentError, 'transaction level locks are not supported on SQLite'
-      end
+      raise ArgumentError, 'transaction level locks are not supported on SQLite' if transaction
+
       0 == file_io.flock((shared ? File::LOCK_SH : File::LOCK_EX) | File::LOCK_NB)
     end
 

data/lib/with_advisory_lock/mysql.rb

@@ -1,17 +1,12 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
   class MySQL < Base
-    # See http://dev.mysql.com/doc/refman/5.0/en/miscellaneous-functions.html#function_get-lock
+    # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock
     def try_lock
-      unless lock_stack.empty?
-        raise NestedAdvisoryLockError.new(
-          "MySQL doesn't support nested Advisory Locks",
-          lock_stack.dup
-        )
-      end
       raise ArgumentError, 'shared locks are not supported on MySQL' if shared
-      if transaction
-        raise ArgumentError, 'transaction level locks are not supported on MySQL'
-      end
+      raise ArgumentError, 'transaction level locks are not supported on MySQL' if transaction
+
       execute_successful?("GET_LOCK(#{quoted_lock_str}, 0)")
     end
 
@@ -21,12 +16,7 @@ module WithAdvisoryLock
 
     def execute_successful?(mysql_function)
       sql = "SELECT #{mysql_function} AS #{unique_column_name}"
-      connection.select_value(sql).to_i > 0
-    end
-
-    # MySQL doesn't support nested locks:
-    def already_locked?
-      lock_stack.last == lock_stack_item
+      connection.select_value(sql).to_i.positive?
     end
 
     # MySQL wants a string as the lock key.

data/lib/with_advisory_lock/postgresql.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
   class PostgreSQL < Base
     # See http://www.postgresql.org/docs/9.1/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS
@@ -8,10 +10,12 @@ module WithAdvisoryLock
 
     def release_lock
       return if transaction
+
       pg_function = "pg_advisory_unlock#{shared ? '_shared' : ''}"
       execute_successful?(pg_function)
     rescue ActiveRecord::StatementInvalid => e
       raise unless e.message =~ / ERROR: +current transaction is aborted,/
+
       begin
         connection.rollback_db_transaction
         execute_successful?(pg_function)
@@ -21,20 +25,18 @@ module WithAdvisoryLock
     end
 
     def execute_successful?(pg_function)
-      comment = lock_name.gsub(/(\/\*)|(\*\/)/, '--')
+      comment = lock_name.to_s.gsub(%r{(/\*)|(\*/)}, '--')
       sql = "SELECT #{pg_function}(#{lock_keys.join(',')}) AS #{unique_column_name} /* #{comment} */"
       result = connection.select_value(sql)
       # MRI returns 't', jruby returns true. YAY!
-      (result == 't' || result == true)
+      ['t', true].include?(result)
     end
 
     # PostgreSQL wants 2 32bit integers as the lock key.
     def lock_keys
-      @lock_keys ||= begin
-        [stable_hashcode(lock_name), ENV['WITH_ADVISORY_LOCK_PREFIX']].map do |ea|
-          # pg advisory args must be 31 bit ints
-          ea.to_i & 0x7fffffff
-        end
+      @lock_keys ||= [stable_hashcode(lock_name), ENV['WITH_ADVISORY_LOCK_PREFIX']].map do |ea|
+        # pg advisory args must be 31 bit ints
+        ea.to_i & 0x7fffffff
       end
     end
   end

data/lib/with_advisory_lock/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
-  VERSION = Gem::Version.new('4.0.0')
+  VERSION = Gem::Version.new('5.0.0')
 end

data/lib/with_advisory_lock.rb

@@ -1,5 +1,6 @@
 require 'with_advisory_lock/version'
 require 'active_support'
+require_relative 'with_advisory_lock/failed_to_acquire_lock'
 
 module WithAdvisoryLock
   extend ActiveSupport::Autoload
@@ -9,7 +10,6 @@ module WithAdvisoryLock
   autoload :DatabaseAdapterSupport
   autoload :Flock
   autoload :MySQL, 'with_advisory_lock/mysql'
-  autoload :NestedAdvisoryLockError
   autoload :PostgreSQL, 'with_advisory_lock/postgresql'
 end
 

data/test/concern_test.rb

@@ -1,20 +1,33 @@
-require 'minitest_helper'
+# frozen_string_literal: true
 
-describe "with_advisory_lock.concern" do
-  it "adds with_advisory_lock to ActiveRecord classes" do
-    assert Tag.respond_to?(:with_advisory_lock)
+require 'test_helper'
+
+class WithAdvisoryLockConcernTest < GemTestCase
+  test 'adds with_advisory_lock to ActiveRecord classes' do
+    assert_respond_to(Tag, :with_advisory_lock)
   end
 
-  it "adds with_advisory_lock to ActiveRecord instances" do
-    assert Label.new.respond_to?(:with_advisory_lock)
+  test 'adds with_advisory_lock to ActiveRecord instances' do
+    assert_respond_to(Label.new, :with_advisory_lock)
   end
 
-  it "adds advisory_lock_exists? to ActiveRecord classes" do
-    assert Tag.respond_to?(:advisory_lock_exists?)
+  test 'adds advisory_lock_exists? to ActiveRecord classes' do
+    assert_respond_to(Tag, :advisory_lock_exists?)
   end
 
-  it "adds advisory_lock_exists? to ActiveRecord classes" do
-    assert Label.new.respond_to?(:advisory_lock_exists?)
+  test 'adds advisory_lock_exists? to ActiveRecord instances' do
+    assert_respond_to(Label.new, :advisory_lock_exists?)
   end
+end
 
+class ActiveRecordQueryCacheTest < GemTestCase
+  test 'does not disable quary cache by default' do
+    ActiveRecord::Base.expects(:uncached).never
+    Tag.with_advisory_lock('lock') { Tag.first }
+  end
+
+  test 'can disable ActiveRecord query cache' do
+    ActiveRecord::Base.expects(:uncached).once
+    Tag.with_advisory_lock('a-lock', disable_query_cache: true) { Tag.first }
+  end
 end

data/test/lock_test.rb

@@ -1,47 +1,80 @@
-require 'minitest_helper'
+# frozen_string_literal: true
 
-describe 'class methods' do
-  let(:lock_name) { 'test lock' }
+require 'test_helper'
 
-  describe '.current_advisory_lock' do
-    it 'returns nil outside an advisory lock request' do
-      Tag.current_advisory_lock.must_be_nil
+class LockTest < GemTestCase
+  setup do
+    @lock_name = 'test lock'
+    @return_val = 1900
+  end
+
+  test 'returns nil outside an advisory lock request' do
+    assert_nil(Tag.current_advisory_lock)
+  end
+
+  test 'returns the name of the last lock acquired' do
+    Tag.with_advisory_lock(@lock_name) do
+      assert_match(/#{@lock_name}/, Tag.current_advisory_lock)
     end
+  end
 
-    it 'returns the name of the last lock acquired' do
-      Tag.with_advisory_lock(lock_name) do
-        # The lock name may have a prefix if WITH_ADVISORY_LOCK_PREFIX env is set
-        Tag.current_advisory_lock.must_match(/#{lock_name}/)
-      end
+  test 'can obtain a lock with a name that attempts to disrupt a SQL comment' do
+    dangerous_lock_name = 'test */ lock /*'
+    Tag.with_advisory_lock(dangerous_lock_name) do
+      assert_match(/#{Regexp.escape(dangerous_lock_name)}/, Tag.current_advisory_lock)
     end
+  end
 
-    it 'can obtain a lock with a name that attempts to disrupt a SQL comment' do
-      dangerous_lock_name = 'test */ lock /*'
-      Tag.with_advisory_lock(dangerous_lock_name) do
-        Tag.current_advisory_lock.must_match(/#{Regexp.escape(dangerous_lock_name)}/)
-      end
+  test 'returns false for an unacquired lock' do
+    refute(Tag.advisory_lock_exists?(@lock_name))
+  end
 
+  test 'returns true for an acquired lock' do
+    Tag.with_advisory_lock(@lock_name) do
+      assert(Tag.advisory_lock_exists?(@lock_name))
     end
   end
 
-  describe '.advisory_lock_exists?' do
-    it 'returns false for an unacquired lock' do
-      Tag.advisory_lock_exists?(lock_name).must_be_false
+  test 'returns block return value if lock successful' do
+    assert_equal(@return_val, Tag.with_advisory_lock!(@lock_name) { @return_val })
+  end
+
+  test 'returns false on lock acquisition failure' do
+    thread_with_lock = Thread.new do
+      Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) do
+        @locked_elsewhere = true
+        loop { sleep 0.01 }
+      end
     end
 
-    it 'returns the name of the last lock acquired' do
-      Tag.with_advisory_lock(lock_name) do
-        Tag.advisory_lock_exists?(lock_name).must_be_true
+    sleep 0.01 until @locked_elsewhere
+    assert_not(Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) { @return_val })
+
+    thread_with_lock.kill
+  end
+
+  test 'raises an error on lock acquisition failure' do
+    thread_with_lock = Thread.new do
+      Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) do
+        @locked_elsewhere = true
+        loop { sleep 0.01 }
       end
     end
+
+    sleep 0.01 until @locked_elsewhere
+    assert_raises(WithAdvisoryLock::FailedToAcquireLock) do
+      Tag.with_advisory_lock!(@lock_name, timeout_seconds: 0) { @return_val }
+    end
+
+    thread_with_lock.kill
   end
 
-  describe 'zero timeout_seconds' do
-    it 'attempts the lock exactly once with no timeout' do
-      expected = SecureRandom.base64
-      Tag.with_advisory_lock(lock_name, 0) do
-        expected
-      end.must_equal expected
+  test 'attempts the lock exactly once with no timeout' do
+    expected = SecureRandom.base64
+    actual = Tag.with_advisory_lock(@lock_name, 0) do
+      expected
     end
+
+    assert_equal(expected, actual)
   end
 end

data/test/nesting_test.rb

@@ -1,60 +1,28 @@
-require 'minitest_helper'
+# frozen_string_literal: true
 
-describe "lock nesting" do
-  # This simplifies what we expect from the lock name:
-  before :each do
+require 'test_helper'
+
+class LockNestingTest < GemTestCase
+  setup do
     @prior_prefix = ENV['WITH_ADVISORY_LOCK_PREFIX']
     ENV['WITH_ADVISORY_LOCK_PREFIX'] = nil
   end
 
-  after :each do
+  teardown do
     ENV['WITH_ADVISORY_LOCK_PREFIX'] = @prior_prefix
   end
 
-  it "doesn't request the same lock twice" do
+  test "doesn't request the same lock twice" do
     impl = WithAdvisoryLock::Base.new(nil, nil, nil)
-    impl.lock_stack.must_be_empty
-    Tag.with_advisory_lock("first") do
-      impl.lock_stack.map(&:name).must_equal %w(first)
+    assert_empty(impl.lock_stack)
+    Tag.with_advisory_lock('first') do
+      assert_equal(%w[first], impl.lock_stack.map(&:name))
       # Even MySQL should be OK with this:
-      Tag.with_advisory_lock("first") do
-        impl.lock_stack.map(&:name).must_equal %w(first)
-      end
-      impl.lock_stack.map(&:name).must_equal %w(first)
-    end
-    impl.lock_stack.must_be_empty
-  end
-
-  it "raises errors with MySQL when acquiring nested lock" do
-    skip unless env_db == :mysql
-    exc = proc {
-      Tag.with_advisory_lock("first") do
-        Tag.with_advisory_lock("second") do
-        end
-      end
-    }.must_raise WithAdvisoryLock::NestedAdvisoryLockError
-    exc.lock_stack.map(&:name).must_equal %w(first)
-  end
-
-  it "supports nested advisory locks with !MySQL" do
-    skip if env_db == :mysql
-    impl = WithAdvisoryLock::Base.new(nil, nil, nil)
-    impl.lock_stack.must_be_empty
-    Tag.with_advisory_lock("first") do
-      impl.lock_stack.map(&:name).must_equal %w(first)
-      Tag.with_advisory_lock("second") do
-        impl.lock_stack.map(&:name).must_equal %w(first second)
-        Tag.with_advisory_lock("first") do
-          # Shouldn't ask for another lock:
-          impl.lock_stack.map(&:name).must_equal %w(first second)
-          Tag.with_advisory_lock("second") do
-            # Shouldn't ask for another lock:
-            impl.lock_stack.map(&:name).must_equal %w(first second)
-          end
-        end
+      Tag.with_advisory_lock('first') do
+        assert_equal(%w[first], impl.lock_stack.map(&:name))
       end
-      impl.lock_stack.map(&:name).must_equal %w(first)
+      assert_equal(%w[first], impl.lock_stack.map(&:name))
     end
-    impl.lock_stack.must_be_empty
+    assert_empty(impl.lock_stack)
   end
 end

data/test/options_test.rb

@@ -1,64 +1,66 @@
-require 'minitest_helper'
+# frozen_string_literal: true
 
-describe 'options parsing' do
+require 'test_helper'
+
+class OptionsParsingTest < GemTestCase
   def parse_options(options)
     WithAdvisoryLock::Base.new(mock, mock, options)
   end
 
-  specify 'defaults (empty hash)' do
+  test 'defaults (empty hash)' do
     impl = parse_options({})
-    impl.timeout_seconds.must_be_nil
-    impl.shared.must_equal false
-    impl.transaction.must_equal false
+    assert_nil(impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert_not(impl.transaction)
   end
 
-  specify 'nil sets timeout to nil' do
+  test 'nil sets timeout to nil' do
     impl = parse_options(nil)
-    impl.timeout_seconds.must_be_nil
-    impl.shared.must_equal false
-    impl.transaction.must_equal false
+    assert_nil(impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert_not(impl.transaction)
   end
 
-  specify 'integer sets timeout to value' do
+  test 'integer sets timeout to value' do
     impl = parse_options(42)
-    impl.timeout_seconds.must_equal 42
-    impl.shared.must_equal false
-    impl.transaction.must_equal false
+    assert_equal(42, impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert_not(impl.transaction)
   end
 
-  specify 'hash with invalid key errors' do
-    proc {
+  test 'hash with invalid key errors' do
+    assert_raises(ArgumentError) do
       parse_options(foo: 42)
-    }.must_raise ArgumentError
+    end
   end
 
-  specify 'hash with timeout_seconds sets timeout to value' do
+  test 'hash with timeout_seconds sets timeout to value' do
     impl = parse_options(timeout_seconds: 123)
-    impl.timeout_seconds.must_equal 123
-    impl.shared.must_equal false
-    impl.transaction.must_equal false
+    assert_equal(123, impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert_not(impl.transaction)
   end
 
-  specify 'hash with shared option sets shared to true' do
+  test 'hash with shared option sets shared to true' do
     impl = parse_options(shared: true)
-    impl.timeout_seconds.must_be_nil
-    impl.shared.must_equal true
-    impl.transaction.must_equal false
+    assert_nil(impl.timeout_seconds)
+    assert(impl.shared)
+    assert_not(impl.transaction)
   end
 
-  specify 'hash with transaction option set transaction to true' do
+  test 'hash with transaction option set transaction to true' do
     impl = parse_options(transaction: true)
-    impl.timeout_seconds.must_be_nil
-    impl.shared.must_equal false
-    impl.transaction.must_equal true
+    assert_nil(impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert(impl.transaction)
   end
 
-  specify 'hash with multiple keys sets options' do
+  test 'hash with multiple keys sets options' do
     foo = mock
     bar = mock
     impl = parse_options(timeout_seconds: foo, shared: bar)
-    impl.timeout_seconds.must_equal foo
-    impl.shared.must_equal bar
-    impl.transaction.must_equal false
+    assert_equal(foo, impl.timeout_seconds)
+    assert_equal(bar, impl.shared)
+    assert_not(impl.transaction)
   end
 end