with_advisory_lock 4.6.0 → 7.0.1

data/lib/with_advisory_lock/postgresql.rb

@@ -1,41 +0,0 @@
-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.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)
-    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
-    end
-  end
-end

data/test/concern_test.rb

@@ -1,20 +0,0 @@
-require 'minitest_helper'
-
-describe "with_advisory_lock.concern" do
-  it "adds with_advisory_lock to ActiveRecord classes" do
-    assert Tag.respond_to?(:with_advisory_lock)
-  end
-
-  it "adds with_advisory_lock to ActiveRecord instances" do
-    assert Label.new.respond_to?(:with_advisory_lock)
-  end
-
-  it "adds advisory_lock_exists? to ActiveRecord classes" do
-    assert Tag.respond_to?(:advisory_lock_exists?)
-  end
-
-  it "adds advisory_lock_exists? to ActiveRecord classes" do
-    assert Label.new.respond_to?(:advisory_lock_exists?)
-  end
-
-end

data/test/database.yml

@@ -1,17 +0,0 @@
-sqlite:
-  adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
-  database: test/sqlite.db
-  timeout: 500
-  pool: 50
-postgresql:
-  adapter: postgresql
-  username: postgres
-  database: with_advisory_lock_test
-  min_messages: ERROR
-  pool: 50
-mysql:
-  adapter: mysql2
-  host: localhost
-  username: root
-  database: with_advisory_lock_test
-  pool: 50

data/test/lock_test.rb

@@ -1,47 +0,0 @@
-require 'minitest_helper'
-
-describe 'class methods' do
-  let(:lock_name) { 'test lock' }
-
-  describe '.current_advisory_lock' do
-    it 'returns nil outside an advisory lock request' do
-      Tag.current_advisory_lock.must_be_nil
-    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
-    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
-
-    end
-  end
-
-  describe '.advisory_lock_exists?' do
-    it 'returns false for an unacquired lock' do
-      Tag.advisory_lock_exists?(lock_name).must_be_false
-    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
-      end
-    end
-  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
-    end
-  end
-end

data/test/minitest_helper.rb

@@ -1,40 +0,0 @@
-require 'erb'
-require 'active_record'
-require 'with_advisory_lock'
-require 'tmpdir'
-require 'securerandom'
-
-def env_db
-  (ENV['DB'] || :mysql).to_sym
-end
-
-db_config = File.expand_path('database.yml', File.dirname(__FILE__))
-ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(db_config)).result)
-
-ENV['WITH_ADVISORY_LOCK_PREFIX'] ||= SecureRandom.hex
-
-ActiveRecord::Base.establish_connection(env_db)
-ActiveRecord::Migration.verbose = false
-
-require 'test_models'
-begin
-  require 'minitest'
-rescue LoadError
-  puts 'Failed to load the minitest gem; built-in version will be used.'
-end
-require 'minitest/autorun'
-require 'minitest/great_expectations'
-require 'mocha/setup'
-
-class MiniTest::Spec
-  before do
-    ENV['FLOCK_DIR'] = Dir.mktmpdir
-    Tag.delete_all
-    TagAudit.delete_all
-    Label.delete_all
-  end
-  after do
-    FileUtils.remove_entry_secure ENV['FLOCK_DIR']
-  end
-end
-

data/test/nesting_test.rb

@@ -1,93 +0,0 @@
-require 'minitest_helper'
-
-describe "lock nesting" do
-  # This simplifies what we expect from the lock name:
-  before :each do
-    @prior_prefix = ENV['WITH_ADVISORY_LOCK_PREFIX']
-    ENV['WITH_ADVISORY_LOCK_PREFIX'] = nil
-  end
-
-  after :each do
-    ENV['WITH_ADVISORY_LOCK_PREFIX'] = @prior_prefix
-  end
-
-  it "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)
-      # 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 < 5.7.5 when acquiring nested lock" do
-    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
-    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 "does not raise errors with MySQL < 5.7.5 when acquiring nested error force enabled" do
-    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
-    impl = WithAdvisoryLock::Base.new(nil, nil, nil)
-    impl.lock_stack.must_be_empty
-    Tag.with_advisory_lock("first", force_nested_lock_support: true) do
-      impl.lock_stack.map(&:name).must_equal %w(first)
-      Tag.with_advisory_lock("second", force_nested_lock_support: true) do
-        impl.lock_stack.map(&:name).must_equal %w(first second)
-        Tag.with_advisory_lock("first", force_nested_lock_support: true) do
-          # Shouldn't ask for another lock:
-          impl.lock_stack.map(&:name).must_equal %w(first second)
-          Tag.with_advisory_lock("second", force_nested_lock_support: true) do
-            # Shouldn't ask for another lock:
-            impl.lock_stack.map(&:name).must_equal %w(first second)
-          end
-        end
-      end
-      impl.lock_stack.map(&:name).must_equal %w(first)
-    end
-    impl.lock_stack.must_be_empty
-  end
-
-  it "supports nested advisory locks with !MySQL 5.6" do
-    skip if env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
-    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
-      end
-      impl.lock_stack.map(&:name).must_equal %w(first)
-    end
-    impl.lock_stack.must_be_empty
-  end
-
-  it "raises with !MySQL 5.6 and nested error force disabled" do
-    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
-    exc = proc {
-      Tag.with_advisory_lock("first", force_nested_lock_support: false) do
-        Tag.with_advisory_lock("second", force_nested_lock_support: false) do
-        end
-      end
-    }.must_raise WithAdvisoryLock::NestedAdvisoryLockError
-    exc.lock_stack.map(&:name).must_equal %w(first)
-  end
-end

data/test/options_test.rb

@@ -1,64 +0,0 @@
-require 'minitest_helper'
-
-describe 'options parsing' do
-  def parse_options(options)
-    WithAdvisoryLock::Base.new(mock, mock, options)
-  end
-
-  specify 'defaults (empty hash)' do
-    impl = parse_options({})
-    impl.timeout_seconds.must_be_nil
-    impl.shared.must_equal false
-    impl.transaction.must_equal false
-  end
-
-  specify '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
-  end
-
-  specify '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
-  end
-
-  specify 'hash with invalid key errors' do
-    proc {
-      parse_options(foo: 42)
-    }.must_raise ArgumentError
-  end
-
-  specify '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
-  end
-
-  specify '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
-  end
-
-  specify '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
-  end
-
-  specify '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
-  end
-end

data/test/parallelism_test.rb

@@ -1,77 +0,0 @@
-require 'minitest_helper'
-require 'forwardable'
-
-describe 'parallelism' do
-  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
-
-  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:
-      until workers.all? { |ea| ea.status == 'sleep' }
-        sleep(0.1)
-      end
-      # 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
-
-  before :each do
-    ActiveRecord::Base.connection.reconnect!
-    @workers = 10
-  end
-
-  # < SQLite, understandably, throws "The database file is locked (database is locked)"
-
-  it 'creates multiple duplicate rows without advisory locks' do
-    skip if env_db == :sqlite
-    @use_advisory_lock = false
-    @iterations = 1
-    run_workers
-    Tag.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
-    TagAudit.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
-    Label.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
-  end
-
-  it "doesn't create multiple duplicate rows with advisory locks" do
-    @use_advisory_lock = true
-    @iterations = 10
-    run_workers
-    Tag.all.size.must_equal @iterations # <- any duplicated rows will NOT make me happy.
-    TagAudit.all.size.must_equal @iterations # <- any duplicated rows will NOT make me happy.
-    Label.all.size.must_equal @iterations # <- any duplicated rows will NOT make me happy.
-  end
-end

data/test/shared_test.rb

@@ -1,131 +0,0 @@
-require 'minitest_helper'
-
-describe 'shared locks' do
-  def supported?
-    env_db != :mysql
-  end
-
-  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
-
-  it 'does not allow two exclusive locks' do
-    one = SharedTestWorker.new(false)
-    one.locked?.must_equal true
-
-    two = SharedTestWorker.new(false)
-    two.locked?.must_equal false
-
-    one.cleanup!
-    two.cleanup!
-  end
-
-  describe 'not supported' do
-    before do
-      skip if supported?
-    end
-
-    it 'raises an error when attempting to use a shared lock' do
-      one = SharedTestWorker.new(true)
-      one.locked?.must_be_nil
-      exception = proc {
-        one.cleanup!
-      }.must_raise ArgumentError
-      exception.message.must_include 'not supported'
-    end
-  end
-
-  describe 'supported' do
-    before do
-      skip unless supported?
-    end
-
-    it 'does allow two shared locks' do
-      one = SharedTestWorker.new(true)
-      one.locked?.must_equal true
-
-      two = SharedTestWorker.new(true)
-      two.locked?.must_equal true
-
-      one.cleanup!
-      two.cleanup!
-    end
-
-    it 'does not allow exclusive lock with shared lock' do
-      one = SharedTestWorker.new(true)
-      one.locked?.must_equal true
-
-      two = SharedTestWorker.new(false)
-      two.locked?.must_equal false
-
-      three = SharedTestWorker.new(true)
-      three.locked?.must_equal true
-
-      one.cleanup!
-      two.cleanup!
-      three.cleanup!
-    end
-
-    it 'does not allow shared lock with exclusive lock' do
-      one = SharedTestWorker.new(false)
-      one.locked?.must_equal true
-
-      two = SharedTestWorker.new(true)
-      two.locked?.must_equal false
-
-      one.cleanup!
-      two.cleanup!
-    end
-
-    describe 'PostgreSQL' do
-      before 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
-
-      it 'allows shared lock to be upgraded to an exclusive lock' do
-        pg_lock_modes.must_equal %w[]
-        Tag.with_advisory_lock 'test', shared: true do
-          pg_lock_modes.must_equal %w[ShareLock]
-          Tag.with_advisory_lock 'test', shared: false do
-            pg_lock_modes.must_equal %w[ShareLock ExclusiveLock]
-          end
-        end
-        pg_lock_modes.must_equal %w[]
-      end
-    end
-  end
-end

data/test/test_models.rb

@@ -1,24 +0,0 @@
-ActiveRecord::Schema.define(:version => 0) 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"
-  end
-  create_table "labels", :id => false, :force => true do |t|
-    t.string "name"
-  end
-end
-
-class Tag < ActiveRecord::Base
-  after_save do
-    TagAudit.create(tag_name: name)
-    Label.create(name: name)
-  end
-end
-
-class TagAudit < ActiveRecord::Base
-end
-
-class Label < ActiveRecord::Base
-end

data/test/thread_test.rb

@@ -1,60 +0,0 @@
-require 'minitest_helper'
-
-describe 'separate thread tests' do
-  let(:lock_name) { 'testing 1,2,3' } # OMG COMMAS
-
-  before do
-    @mutex = Mutex.new
-    @t1_acquired_lock = false
-    @t1_return_value = nil
-
-    @t1 = Thread.new do
-      ActiveRecord::Base.connection_pool.with_connection do
-        @t1_return_value = Label.with_advisory_lock(lock_name) do
-          @mutex.synchronize { @t1_acquired_lock = true }
-          sleep
-          't1 finished'
-        end
-      end
-    end
-
-    # Wait for the thread to acquire the lock:
-    until @mutex.synchronize { @t1_acquired_lock } do
-      sleep(0.1)
-    end
-    ActiveRecord::Base.connection.reconnect!
-  end
-
-  after do
-    @t1.wakeup if @t1.status == 'sleep'
-    @t1.join
-  end
-
-  it '#with_advisory_lock with a 0 timeout returns false immediately' do
-    response = Label.with_advisory_lock(lock_name, 0) do
-      fail 'should not be yielded to'
-    end
-    response.must_be_false
-  end
-
-  it '#with_advisory_lock yields to the provided block' do
-    @t1_acquired_lock.must_be_true
-  end
-
-  it '#advisory_lock_exists? returns true when another thread has the lock' do
-    Tag.advisory_lock_exists?(lock_name).must_be_true
-  end
-
-  it 'can re-establish the lock after the other thread releases it' do
-    @t1.wakeup
-    @t1.join
-    @t1_return_value.must_equal 't1 finished'
-
-    # We should now be able to acquire the lock immediately:
-    reacquired = false
-    Label.with_advisory_lock(lock_name, 0) do
-      reacquired = true
-    end.must_be_true
-    reacquired.must_be_true
-  end
-end

data/test/transaction_test.rb

@@ -1,70 +0,0 @@
-require 'minitest_helper'
-
-describe 'transaction scoping' do
-  def supported?
-    env_db == :postgresql
-  end
-
-  describe 'not supported' do
-    before do
-      skip if supported?
-    end
-
-    it 'raises an error when attempting to use transaction level locks' do
-      Tag.transaction do
-        exception = proc {
-          Tag.with_advisory_lock 'test', transaction: true do
-            raise 'should not get here'
-          end
-        }.must_raise ArgumentError
-        exception.message.must_include 'not supported'
-      end
-    end
-  end
-
-  describe 'supported' do
-    before do
-      skip unless env_db == :postgresql
-    end
-
-    def pg_lock_count
-      ActiveRecord::Base.connection.select_value("SELECT COUNT(*) FROM pg_locks WHERE locktype = 'advisory';").to_i
-    end
-
-    specify 'session locks release after the block executes' do
-      Tag.transaction do
-        pg_lock_count.must_equal 0
-        Tag.with_advisory_lock 'test' do
-          pg_lock_count.must_equal 1
-        end
-        pg_lock_count.must_equal 0
-      end
-    end
-
-    specify 'session locks release when transaction fails inside block' do
-      Tag.transaction do
-        pg_lock_count.must_equal 0
-
-        exception = proc {
-          Tag.with_advisory_lock 'test' do
-            Tag.connection.execute 'SELECT 1/0;'
-          end
-        }.must_raise ActiveRecord::StatementInvalid
-        exception.message.must_include 'division by zero'
-
-        pg_lock_count.must_equal 0
-      end
-    end
-
-    specify 'transaction level locks hold until the transaction completes' do
-      Tag.transaction do
-        pg_lock_count.must_equal 0
-        Tag.with_advisory_lock 'test', transaction: true do
-          pg_lock_count.must_equal 1
-        end
-        pg_lock_count.must_equal 1
-      end
-      pg_lock_count.must_equal 0
-    end
-  end
-end