with_advisory_lock 5.3.0 → 7.0.1

data/lib/with_advisory_lock/database_adapter_support.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module WithAdvisoryLock
-  class DatabaseAdapterSupport
-    attr_reader :adapter_name
-    def initialize(connection)
-      @connection = connection
-      @adapter_name   = connection.adapter_name.downcase.to_sym
-    end
-
-    def mysql?
-      %i[mysql2 trilogy].include? adapter_name
-    end
-
-    def postgresql?
-      %i[postgresql empostgresql postgis].include? adapter_name
-    end
-
-    def sqlite?
-      [:sqlite3, :sqlite].include? adapter_name
-    end
-  end
-end

data/lib/with_advisory_lock/flock.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-
-module WithAdvisoryLock
-  class Flock < Base
-    def filename
-      @filename ||= begin
-        safe = lock_str.to_s.gsub(/[^a-z0-9]/i, '')
-        fn = ".lock-#{safe}-#{stable_hashcode(lock_str)}"
-        # Let the user specify a directory besides CWD.
-        ENV['FLOCK_DIR'] ? File.expand_path(fn, ENV['FLOCK_DIR']) : fn
-      end
-    end
-
-    def file_io
-      @file_io ||= begin
-        FileUtils.touch(filename)
-        File.open(filename, 'r+')
-      end
-    end
-
-    def try_lock
-      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
-
-    def release_lock
-      0 == file_io.flock(File::LOCK_UN)
-    end
-  end
-end

data/lib/with_advisory_lock/mysql.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module WithAdvisoryLock
-  class MySQL < Base
-    # 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
-      raise ArgumentError, 'transaction level locks are not supported on MySQL' if transaction
-
-      execute_successful?("GET_LOCK(#{quoted_lock_str}, 0)")
-    end
-
-    def release_lock
-      execute_successful?("RELEASE_LOCK(#{quoted_lock_str})")
-    end
-
-    def execute_successful?(mysql_function)
-      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.
-    def quoted_lock_str
-      connection.quote(lock_str)
-    end
-  end
-end

data/lib/with_advisory_lock/postgresql.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module WithAdvisoryLock
-  class PostgreSQL < Base
-    # 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
-      execute_successful?(advisory_try_lock_function(transaction))
-    end
-
-    def release_lock
-      return if transaction
-
-      execute_successful?(advisory_unlock_function)
-    rescue ActiveRecord::StatementInvalid => e
-      raise unless e.message =~ ERROR_MESSAGE_REGEX
-
-      begin
-        connection.rollback_db_transaction
-        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)
-      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 ||= [
-        stable_hashcode(lock_name),
-        ENV[LOCK_PREFIX_ENV]
-      ].map { |ea| ea.to_i & 0x7fffffff }
-    end
-  end
-end

data/test/with_advisory_lock/base_test.rb

@@ -1,9 +0,0 @@
-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/nesting_test.rb

@@ -1,28 +0,0 @@
-# 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

data/test/with_advisory_lock/options_test.rb

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