with_advisory_lock 4.6.0 → 5.3.0

data/lib/with_advisory_lock/concern.rb

@@ -1,19 +1,25 @@
-require 'active_support/concern'
+# frozen_string_literal: true
 
 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)
+        raise WithAdvisoryLock::FailedToAcquireLock, lock_name unless result.lock_was_acquired?
+
+        result.result
+      end
+
       def with_advisory_lock_result(lock_name, options = {}, &block)
-        class_options = options.extract!(:force_nested_lock_support) if options.respond_to?(:fetch)
-        impl = impl_class(class_options).new(connection, lock_name, options)
+        impl = impl_class.new(connection, lock_name, options)
         impl.with_advisory_lock_if_needed(&block)
       end
 
@@ -27,24 +33,18 @@ module WithAdvisoryLock
         lock_stack_key && lock_stack_key[0]
       end
 
+      def current_advisory_locks
+        WithAdvisoryLock::Base.lock_stack.map(&:name)
+      end
+
       private
 
-      def impl_class(options = nil)
+      def impl_class
         adapter = WithAdvisoryLock::DatabaseAdapterSupport.new(connection)
         if adapter.postgresql?
           WithAdvisoryLock::PostgreSQL
         elsif adapter.mysql?
-          nested_lock = if options.respond_to?(:fetch) && [true, false].include?(options.fetch(:force_nested_lock_support, nil))
-                          options.fetch(:force_nested_lock_support)
-                        else
-                          adapter.mysql_nested_lock_support?
-                        end
-
-          if nested_lock
-            WithAdvisoryLock::MySQL
-          else
-            WithAdvisoryLock::MySQLNoNesting
-          end
+          WithAdvisoryLock::MySQL
         else
           WithAdvisoryLock::Flock
         end

data/lib/with_advisory_lock/database_adapter_support.rb

@@ -1,63 +1,23 @@
+# 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
-
+    attr_reader :adapter_name
     def initialize(connection)
       @connection = connection
-      @sym_name   = connection.adapter_name.downcase.to_sym
+      @adapter_name   = connection.adapter_name.downcase.to_sym
     end
 
     def mysql?
-      %i[mysql mysql2].include? @sym_name
-    end
-
-    # Nested lock support for MySQL was introduced in 5.7.5
-    # Checking by version number is complicated by MySQL compatible DBs (like MariaDB) having their own versioning schemes
-    # Therefore, we check for nested lock support by simply trying a nested lock, then testing and caching the outcome
-    def mysql_nested_lock_support?
-      return false unless mysql?
-
-      # We select the MySQL version this way and cache on it, as MySQL will report versions like "5.7.5", and MariaDB will
-      # report versions like "10.3.8-MariaDB", which allow us to cache on features without introducing problems.
-      version = @connection.select_value("SELECT version()")
-
-      @@mysql_nl_cache_mutex.synchronize do
-        return @@mysql_nl_cache[version] if @@mysql_nl_cache.keys.include?(version)
-
-        lock_1 = "\"nested-test-1-#{SecureRandom.hex}\""
-        lock_2 = "\"nested-test-2-#{SecureRandom.hex}\""
-
-        get_1  = @connection.select_value("SELECT GET_LOCK(#{lock_1}, 0) AS t#{SecureRandom.hex}")
-        get_2  = @connection.select_value("SELECT GET_LOCK(#{lock_2}, 0) AS t#{SecureRandom.hex}")
-
-        # Both locks should succeed in old and new MySQL versions with "1"
-        raise RuntimeError, "Unexpected nested lock acquire result #{get_1}, #{get_2}" unless [get_1, get_2] == [1, 1]
-
-        release_1 = @connection.select_value("SELECT RELEASE_LOCK(#{lock_1}) AS t#{SecureRandom.hex}")
-        release_2 = @connection.select_value("SELECT RELEASE_LOCK(#{lock_2}) AS t#{SecureRandom.hex}")
-
-        # In MySQL <  5.7.5 release_1 will return  nil (not currently locked) and release_2 will return 1 (successfully unlocked)
-        # In MySQL >= 5.7.5 release_1 and release_2 will return 1 (both successfully unlocked)
-        # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock for more
-        @@mysql_nl_cache[version] = case [release_1, release_2]
-                                    when [1, 1]
-                                      true
-                                    when [nil, 1]
-                                      false
-                                    else
-                                      raise RuntimeError, "Unexpected nested lock release result #{release_1}, #{release_2}"
-                                    end
-      end
+      %i[mysql2 trilogy].include? adapter_name
     end
 
     def postgresql?
-      %i[postgresql empostgresql postgis].include? @sym_name
+      %i[postgresql empostgresql postgis].include? adapter_name
     end
 
     def sqlite?
-      :sqlite3 == @sym_name
+      [:sqlite3, :sqlite].include? adapter_name
     end
   end
 end

data/lib/with_advisory_lock/failed_to_acquire_lock.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+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,12 +1,13 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
-  # MySQL > 5.7.5 supports nested locks
   class MySQL < Base
-    # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock
+    # See https://dev.mysql.com/doc/refman/5.7/en/locking-functions.html
+    # See https://dev.mysql.com/doc/refman/8.0/en/locking-functions.html
     def try_lock
       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
 
@@ -15,8 +16,12 @@ module WithAdvisoryLock
     end
 
     def execute_successful?(mysql_function)
-      sql = "SELECT #{mysql_function} AS #{unique_column_name}"
-      connection.select_value(sql).to_i > 0
+      execute_query(mysql_function) == 1
+    end
+
+    def execute_query(mysql_function)
+      sql = "SELECT #{mysql_function}"
+      connection.query_value(sql)
     end
 
     # MySQL wants a string as the lock key.

data/lib/with_advisory_lock/postgresql.rb

@@ -1,41 +1,66 @@
+# frozen_string_literal: true
+
 module WithAdvisoryLock
   class PostgreSQL < Base
-    # See http://www.postgresql.org/docs/9.1/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS
+    # See https://www.postgresql.org/docs/16/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS
+
+    # MRI returns 't', jruby returns true. YAY!
+    LOCK_RESULT_VALUES = ['t', true].freeze
+    PG_ADVISORY_UNLOCK = 'pg_advisory_unlock'
+    PG_TRY_ADVISORY = 'pg_try_advisory'
+    ERROR_MESSAGE_REGEX = / ERROR: +current transaction is aborted,/
+
     def try_lock
-      pg_function = "pg_try_advisory#{transaction ? '_xact' : ''}_lock#{shared ? '_shared' : ''}"
-      execute_successful?(pg_function)
+      execute_successful?(advisory_try_lock_function(transaction))
     end
 
     def release_lock
       return if transaction
-      pg_function = "pg_advisory_unlock#{shared ? '_shared' : ''}"
-      execute_successful?(pg_function)
+
+      execute_successful?(advisory_unlock_function)
     rescue ActiveRecord::StatementInvalid => e
-      raise unless e.message =~ / ERROR: +current transaction is aborted,/
+      raise unless e.message =~ ERROR_MESSAGE_REGEX
+
       begin
         connection.rollback_db_transaction
-        execute_successful?(pg_function)
+        execute_successful?(advisory_unlock_function)
       ensure
         connection.begin_db_transaction
       end
     end
 
+    def advisory_try_lock_function(transaction_scope)
+      [
+        'pg_try_advisory',
+        transaction_scope ? '_xact' : nil,
+        '_lock',
+        shared ? '_shared' : nil
+      ].compact.join
+    end
+
+    def advisory_unlock_function
+      [
+        'pg_advisory_unlock',
+        shared ? '_shared' : nil
+      ].compact.join
+    end
+
     def execute_successful?(pg_function)
-      comment = lock_name.gsub(/(\/\*)|(\*\/)/, '--')
-      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)
+      result = connection.select_value(prepare_sql(pg_function))
+      LOCK_RESULT_VALUES.include?(result)
+    end
+
+    def prepare_sql(pg_function)
+      comment = lock_name.to_s.gsub(%r{(/\*)|(\*/)}, '--')
+      "SELECT #{pg_function}(#{lock_keys.join(',')}) AS #{unique_column_name} /* #{comment} */"
     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
-      end
+      @lock_keys ||= [
+        stable_hashcode(lock_name),
+        ENV[LOCK_PREFIX_ENV]
+      ].map { |ea| 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.6.0')
+  VERSION = Gem::Version.new('5.3.0')
 end

data/lib/with_advisory_lock.rb

@@ -1,17 +1,16 @@
 require 'with_advisory_lock/version'
 require 'active_support'
+require 'zeitwerk'
 
-module WithAdvisoryLock
-  extend ActiveSupport::Autoload
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  'mysql' => 'MySQL',
+  'postgresql' => 'PostgreSQL',
+  )
+loader.setup
 
-  autoload :Concern
-  autoload :Base
-  autoload :DatabaseAdapterSupport
-  autoload :Flock
-  autoload :MySQL, 'with_advisory_lock/mysql'
-  autoload :MySQLNoNesting, 'with_advisory_lock/mysql_no_nesting'
-  autoload :NestedAdvisoryLockError
-  autoload :PostgreSQL, 'with_advisory_lock/postgresql'
+module WithAdvisoryLock
+  LOCK_PREFIX_ENV = 'WITH_ADVISORY_LOCK_PREFIX'.freeze
 end
 
 ActiveSupport.on_load :active_record do

data/release-please-config.json

@@ -0,0 +1,9 @@
+{
+  "release-type": "ruby",
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "package-name": "with_advisory_lock"
+    }
+  }
+}

data/test/test_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'active_record'
+require 'with_advisory_lock'
+require 'tmpdir'
+require 'securerandom'
+begin
+  require 'activerecord-trilogy-adapter'
+  ActiveSupport.on_load(:active_record) do
+    require "trilogy_adapter/connection"
+    ActiveRecord::Base.public_send :extend, TrilogyAdapter::Connection
+  end
+rescue LoadError
+  # do nothing
+end
+
+ActiveRecord::Base.configurations = {
+  default_env: {
+    url: ENV.fetch('DATABASE_URL', "sqlite3://#{Dir.tmpdir}/with_advisory_lock_test#{RUBY_VERSION}-#{ActiveRecord.gem_version}.sqlite3"),
+    pool: 20,
+    properties: { allowPublicKeyRetrieval: true } # for JRuby madness
+  }
+}
+
+ENV['WITH_ADVISORY_LOCK_PREFIX'] ||= SecureRandom.hex
+
+ActiveRecord::Base.establish_connection
+
+def env_db
+  @env_db ||= ActiveRecord::Base.connection_db_config.adapter.to_sym
+end
+
+ActiveRecord::Migration.verbose = false
+
+require 'test_models'
+require 'minitest'
+require 'maxitest/autorun'
+require 'mocha/minitest'
+
+class GemTestCase < ActiveSupport::TestCase
+
+  parallelize(workers: 1)
+  def adapter_support
+    @adapter_support ||= WithAdvisoryLock::DatabaseAdapterSupport.new(ActiveRecord::Base.connection)
+  end
+  def is_sqlite3_adapter?; adapter_support.sqlite?; end
+  def is_mysql_adapter?; adapter_support.mysql?; end
+  def is_postgresql_adapter?; adapter_support.postgresql?; end
+
+  setup do
+    ENV['FLOCK_DIR'] = Dir.mktmpdir if is_sqlite3_adapter?
+    ApplicationRecord.connection.truncate_tables(
+      Tag.table_name,
+      TagAudit.table_name,
+      Label.table_name
+    )
+  end
+
+  teardown do
+    FileUtils.remove_entry_secure(ENV['FLOCK_DIR'], true) if is_sqlite3_adapter?
+  end
+end
+
+puts "Testing with #{env_db} database, ActiveRecord #{ActiveRecord.gem_version} and #{RUBY_ENGINE} #{RUBY_ENGINE_VERSION} as #{RUBY_VERSION}"
+puts "Connection Pool size: #{ActiveRecord::Base.connection_pool.size}"

data/test/test_models.rb

@@ -1,24 +1,30 @@
-ActiveRecord::Schema.define(:version => 0) do
-  create_table "tags", :force => true do |t|
-    t.string "name"
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table 'tags', force: true do |t|
+    t.string 'name'
   end
-  create_table "tag_audits", :id => false, :force => true do |t|
-    t.string "tag_name"
+  create_table 'tag_audits', id: false, force: true do |t|
+    t.string 'tag_name'
   end
-  create_table "labels", :id => false, :force => true do |t|
-    t.string "name"
+  create_table 'labels', id: false, force: true do |t|
+    t.string 'name'
   end
 end
 
-class Tag < ActiveRecord::Base
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end
+
+class Tag < ApplicationRecord
   after_save do
     TagAudit.create(tag_name: name)
     Label.create(name: name)
   end
 end
 
-class TagAudit < ActiveRecord::Base
+class TagAudit < ApplicationRecord
 end
 
-class Label < ActiveRecord::Base
+class Label < ApplicationRecord
 end

data/test/with_advisory_lock/base_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class WithAdvisoryLockBaseTest < GemTestCase
+  test 'should support advisory_locks_enabled' do
+    skip if is_sqlite3_adapter?
+
+    assert Tag.connection.advisory_locks_enabled?
+  end
+end

data/test/with_advisory_lock/concern_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class WithAdvisoryLockConcernTest < GemTestCase
+  test 'adds with_advisory_lock to ActiveRecord classes' do
+    assert_respond_to(Tag, :with_advisory_lock)
+  end
+
+  test 'adds with_advisory_lock to ActiveRecord instances' do
+    assert_respond_to(Label.new, :with_advisory_lock)
+  end
+
+  test 'adds advisory_lock_exists? to ActiveRecord classes' do
+    assert_respond_to(Tag, :advisory_lock_exists?)
+  end
+
+  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
+    Tag.connection.expects(:uncached).never
+    Tag.with_advisory_lock('lock') { Tag.first }
+  end
+
+  test 'can disable ActiveRecord query cache' do
+    Tag.connection.expects(:uncached).once
+    Tag.with_advisory_lock('a-lock', disable_query_cache: true) { Tag.first }
+  end
+end

data/test/with_advisory_lock/lock_test.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+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
+
+  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
+
+  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
+
+  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
+
+    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
+
+  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
+
+  test 'current_advisory_locks returns empty array outside an advisory lock request' do
+    assert_equal([], Tag.current_advisory_locks)
+  end
+
+  test 'current_advisory_locks returns an array with names of the acquired locks' do
+    Tag.with_advisory_lock(@lock_name) do
+      locks = Tag.current_advisory_locks
+      assert_equal(1, locks.size)
+      assert_match(/#{@lock_name}/, locks.first)
+    end
+  end
+
+  test 'current_advisory_locks returns array of all nested lock names' do
+    first_lock = 'outer lock'
+    second_lock = 'inner lock'
+
+    Tag.with_advisory_lock(first_lock) do
+      Tag.with_advisory_lock(second_lock) do
+        locks = Tag.current_advisory_locks
+        assert_equal(2, locks.size)
+        assert_match(/#{first_lock}/, locks.first)
+        assert_match(/#{second_lock}/, locks.last)
+      end
+
+      locks = Tag.current_advisory_locks
+      assert_equal(1, locks.size)
+      assert_match(/#{first_lock}/, locks.first)
+    end
+    assert_equal([], Tag.current_advisory_locks)
+  end
+end

data/test/with_advisory_lock/nesting_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class LockNestingTest < GemTestCase
+  setup do
+    @prior_prefix = ENV['WITH_ADVISORY_LOCK_PREFIX']
+    ENV['WITH_ADVISORY_LOCK_PREFIX'] = nil
+  end
+
+  teardown do
+    ENV['WITH_ADVISORY_LOCK_PREFIX'] = @prior_prefix
+  end
+
+  test "doesn't request the same lock twice" do
+    impl = WithAdvisoryLock::Base.new(nil, nil, nil)
+    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
+        assert_equal(%w[first], impl.lock_stack.map(&:name))
+      end
+      assert_equal(%w[first], impl.lock_stack.map(&:name))
+    end
+    assert_empty(impl.lock_stack)
+  end
+end