with_advisory_lock 5.1.0 → 7.0.0

data/lib/with_advisory_lock/base.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'zlib'
-
-module WithAdvisoryLock
-  class Result
-    attr_reader :result
-
-    def initialize(lock_was_acquired, result = false)
-      @lock_was_acquired = lock_was_acquired
-      @result = result
-    end
-
-    def lock_was_acquired?
-      @lock_was_acquired
-    end
-  end
-
-  FAILED_TO_LOCK = Result.new(false)
-
-  LockStackItem = Struct.new(:name, :shared)
-
-  class Base
-    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, :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
-      @lock_str ||= "#{ENV['WITH_ADVISORY_LOCK_PREFIX']}#{lock_name}"
-    end
-
-    def lock_stack_item
-      @lock_stack_item ||= LockStackItem.new(lock_str, shared)
-    end
-
-    def self.lock_stack
-      # access doesn't need to be synchronized as it is only accessed by the current thread.
-      Thread.current[:with_advisory_lock_stack] ||= []
-    end
-    delegate :lock_stack, to: 'self.class'
-
-    def already_locked?
-      lock_stack.include? lock_stack_item
-    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
-        yield_with_lock(&block)
-      else
-        yield_with_lock_and_timeout(&block)
-      end
-    end
-
-    def stable_hashcode(input)
-      if input.is_a? Numeric
-        input.to_i
-      else
-        # Ruby MRI's String#hash is randomly seeded as of Ruby 1.9 so
-        # make sure we use a deterministic hash.
-        Zlib.crc32(input.to_s, 0)
-      end
-    end
-
-    def yield_with_lock_and_timeout(&block)
-      give_up_at = Time.now + @timeout_seconds if @timeout_seconds
-      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
-      FAILED_TO_LOCK
-    end
-
-    def yield_with_lock
-      if try_lock
-        begin
-          lock_stack.push(lock_stack_item)
-          result = block_given? ? yield : nil
-          Result.new(true, result)
-        ensure
-          lock_stack.pop
-          release_lock
-        end
-      else
-        FAILED_TO_LOCK
-      end
-    end
-
-    # Prevent AR from caching results improperly
-    def unique_column_name
-      "t#{SecureRandom.hex}"
-    end
-  end
-end

data/lib/with_advisory_lock/database_adapter_support.rb

@@ -1,26 +0,0 @@
-# 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)
-      @connection = connection
-      @sym_name   = connection.adapter_name.downcase.to_sym
-    end
-
-    def mysql?
-      %i[mysql2 trilogy].include? @sym_name
-    end
-
-    def postgresql?
-      %i[postgresql empostgresql postgis].include? @sym_name
-    end
-
-    def sqlite?
-      @sym_name == :sqlite3
-    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,27 +0,0 @@
-# frozen_string_literal: true
-
-module WithAdvisoryLock
-  class MySQL < Base
-    # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock
-    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)
-      sql = "SELECT #{mysql_function} AS #{unique_column_name}"
-      connection.select_value(sql).to_i.positive?
-    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,43 +0,0 @@
-# frozen_string_literal: true
-
-module WithAdvisoryLock
-  class PostgreSQL < Base
-    # See http://www.postgresql.org/docs/9.1/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS
-    def try_lock
-      pg_function = "pg_try_advisory#{transaction ? '_xact' : ''}_lock#{shared ? '_shared' : ''}"
-      execute_successful?(pg_function)
-    end
-
-    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)
-      ensure
-        connection.begin_db_transaction
-      end
-    end
-
-    def execute_successful?(pg_function)
-      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!
-      ['t', true].include?(result)
-    end
-
-    # PostgreSQL wants 2 32bit integers as the lock key.
-    def lock_keys
-      @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
-end

data/test/concern_test.rb

@@ -1,33 +0,0 @@
-# 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
-    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,80 +0,0 @@
-# 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
-end

data/test/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/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

data/test/parallelism_test.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'forwardable'
-
-class FindOrCreateWorker
-  extend Forwardable
-  def_delegators :@thread, :join, :wakeup, :status, :to_s
-
-  def initialize(name, use_advisory_lock)
-    @name = name
-    @use_advisory_lock = use_advisory_lock
-    @thread = Thread.new { work_later }
-  end
-
-  def work_later
-    sleep
-    ActiveRecord::Base.connection_pool.with_connection do
-      if @use_advisory_lock
-        Tag.with_advisory_lock(@name) { work }
-      else
-        work
-      end
-    end
-  end
-
-  def work
-    Tag.transaction do
-      Tag.where(name: @name).first_or_create
-    end
-  end
-end
-
-class ParallelismTest < GemTestCase
-  def run_workers
-    @names = @iterations.times.map { |iter| "iteration ##{iter}" }
-    @names.each do |name|
-      workers = @workers.times.map do
-        FindOrCreateWorker.new(name, @use_advisory_lock)
-      end
-      # Wait for all the threads to get ready:
-      sleep(0.1) until workers.all? { |ea| ea.status == 'sleep' }
-      # OK, GO!
-      workers.each(&:wakeup)
-      # Then wait for them to finish:
-      workers.each(&:join)
-    end
-    # Ensure we're still connected:
-    ActiveRecord::Base.connection_pool.connection
-  end
-
-  setup do
-    ActiveRecord::Base.connection.reconnect!
-    @workers = 10
-  end
-
-  test 'creates multiple duplicate rows without advisory locks' do
-    skip if %i[sqlite3 jdbcsqlite3].include?(env_db)
-    @use_advisory_lock = false
-    @iterations = 1
-    run_workers
-    assert_operator(Tag.all.size,      :>, @iterations) # <- any duplicated rows will make me happy.
-    assert_operator(TagAudit.all.size, :>, @iterations) # <- any duplicated rows will make me happy.
-    assert_operator(Label.all.size,    :>, @iterations) # <- any duplicated rows will make me happy.
-  end
-
-  test "doesn't create multiple duplicate rows with advisory locks" do
-    @use_advisory_lock = true
-    @iterations = 10
-    run_workers
-    assert_equal(@iterations, Tag.all.size)       # <- any duplicated rows will NOT make me happy.
-    assert_equal(@iterations, TagAudit.all.size)  # <- any duplicated rows will NOT make me happy.
-    assert_equal(@iterations, Label.all.size)     # <- any duplicated rows will NOT make me happy.
-  end
-end

data/test/shared_test.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-class SharedTestWorker
-  def initialize(shared)
-    @shared = shared
-
-    @locked = nil
-    @cleanup = false
-    @thread = Thread.new { work }
-  end
-
-  def locked?
-    sleep 0.01 while @locked.nil? && @thread.alive?
-    @locked
-  end
-
-  def cleanup!
-    @cleanup = true
-    @thread.join
-    raise if @thread.status.nil?
-  end
-
-  private
-
-  def work
-    ActiveRecord::Base.connection_pool.with_connection do
-      Tag.with_advisory_lock('test', timeout_seconds: 0, shared: @shared) do
-        @locked = true
-        sleep 0.01 until @cleanup
-      end
-      @locked = false
-      sleep 0.01 until @cleanup
-    end
-  end
-end
-
-class SharedLocksTest < GemTestCase
-  def supported?
-    %i[trilogy mysql2 jdbcmysql].exclude?(env_db)
-  end
-
-  test 'does not allow two exclusive locks' do
-    one = SharedTestWorker.new(false)
-    assert_predicate(one, :locked?)
-
-    two = SharedTestWorker.new(false)
-    refute(two.locked?)
-
-    one.cleanup!
-    two.cleanup!
-  end
-end
-
-class NotSupportedEnvironmentTest < SharedLocksTest
-  setup do
-    skip if supported?
-  end
-
-  test 'raises an error when attempting to use a shared lock' do
-    one = SharedTestWorker.new(true)
-    assert_nil(one.locked?)
-
-    exception = assert_raises(ArgumentError) do
-      one.cleanup!
-    end
-
-    assert_match(/#{Regexp.escape('not supported')}/, exception.message)
-  end
-end
-
-class SupportedEnvironmentTest < SharedLocksTest
-  setup do
-    skip unless supported?
-  end
-
-  test 'does allow two shared locks' do
-    one = SharedTestWorker.new(true)
-    assert_predicate(one, :locked?)
-
-    two = SharedTestWorker.new(true)
-    assert_predicate(two, :locked?)
-
-    one.cleanup!
-    two.cleanup!
-  end
-
-  test 'does not allow exclusive lock with shared lock' do
-    one = SharedTestWorker.new(true)
-    assert_predicate(one, :locked?)
-
-    two = SharedTestWorker.new(false)
-    refute(two.locked?)
-
-    three = SharedTestWorker.new(true)
-    assert_predicate(three, :locked?)
-
-    one.cleanup!
-    two.cleanup!
-    three.cleanup!
-  end
-
-  test 'does not allow shared lock with exclusive lock' do
-    one = SharedTestWorker.new(false)
-    assert_predicate(one, :locked?)
-
-    two = SharedTestWorker.new(true)
-    refute(two.locked?)
-
-    one.cleanup!
-    two.cleanup!
-  end
-
-  class PostgreSQLTest < SupportedEnvironmentTest
-    setup do
-      skip unless env_db == :postgresql
-    end
-
-    def pg_lock_modes
-      ActiveRecord::Base.connection.select_values("SELECT mode FROM pg_locks WHERE locktype = 'advisory';")
-    end
-
-    test 'allows shared lock to be upgraded to an exclusive lock' do
-      assert_empty(pg_lock_modes)
-      Tag.with_advisory_lock 'test', shared: true do
-        assert_equal(%w[ShareLock], pg_lock_modes)
-        Tag.with_advisory_lock 'test', shared: false do
-          assert_equal(%w[ShareLock ExclusiveLock], pg_lock_modes)
-        end
-      end
-      assert_empty(pg_lock_modes)
-    end
-  end
-end