with_advisory_lock 0.0.4 → 0.0.5

data/README.md

@@ -46,12 +46,10 @@ You will want to wrap your block within a transaction to ensure consistency.
 
 ### MySQL doesn't support nesting
 
-With MySQL, if you ask for another advisory lock within a ```with_advisory_lock``` block,
-you will be releasing the parent lock (!!!).
-
-A warning message will be emitted to the Rails logger in this case, because you
-probably didn't mean to lose your first lock. *Raising an exception would be safer. I'm open to
-suggestions on how to handle this dangerous case!*
+With MySQL (at least <= v5.5), if you ask for a *different* advisory lock within a ```with_advisory_lock``` block,
+you will be releasing the parent lock (!!!). A ```NestedAdvisoryLockError```will be raised
+in this case. If you ask for the same lock name, ```with_advisory_lock``` won't ask for the
+lock again, and the block given will be yielded to.
 
 ## Installation
 
@@ -67,7 +65,6 @@ And then execute:
 
 ## Lock Types
 
-
 First off, know that there are **lots** of different kinds of locks available to you. **Pick the
 finest-grain lock that ensures correctness.** If you choose a lock that is too coarse, you are
 unnecessarily blocking other processes.
@@ -94,6 +91,11 @@ aren't going to be commonly applicable, and they can be a source of
 
 ## Changelog
 
+### 0.0.5
+
+* Asking for the currently acquired advisory lock doesn't re-ask for the lock now.
+* Introduced NestedAdvisoryLockError when asking for different, nested advisory locksMySQL
+
 ### 0.0.4
 
 * Moved require into on_load, which should speed loading when AR doesn't have to spin up

data/lib/with_advisory_lock/base.rb

@@ -12,13 +12,31 @@ module WithAdvisoryLock
       connection.quote(lock_name)
     end
 
-    def with_advisory_lock(&block)
+    def lock_stack
+      Thread.current[:with_advisory_lock_stack] ||= []
+    end
+
+    def already_locked?
+      lock_stack.include? @lock_name
+    end
+
+    def with_advisory_lock_if_needed
+      if already_locked?
+        yield
+      else
+        yield_with_lock { yield }
+      end
+    end
+
+    def yield_with_lock
       give_up_at = Time.now + @timeout_seconds if @timeout_seconds
       while @timeout_seconds.nil? || Time.now < give_up_at do
         if try_lock
           begin
+            lock_stack.push(lock_name)
             return yield
           ensure
+            lock_stack.pop
             release_lock
           end
         else
@@ -30,4 +48,4 @@ module WithAdvisoryLock
       false # failed to get lock in time.
     end
   end
-end
+end

data/lib/with_advisory_lock/concern.rb

@@ -20,32 +20,17 @@ module WithAdvisoryLock
     module ClassMethods
 
       def with_advisory_lock(lock_name, timeout_seconds=nil, &block)
-        lock_stack = Thread.current[:with_advisory_lock_stack] ||= []
-        impl = case (connection.adapter_name.downcase)
+        impl_class = case (connection.adapter_name.downcase)
           when "postgresql"
             WithAdvisoryLock::PostgreSQL
           when "mysql", "mysql2"
-            unless lock_stack.empty?
-              wal_log("with_advisory_lock: MySQL doesn't support nested advisory locks, and will now release lock '#{lock_stack.last}'")
-            end
             WithAdvisoryLock::MySQL
           else
             WithAdvisoryLock::Flock
         end
-        lock_stack.push(lock_name)
-        impl.new(connection, lock_name, timeout_seconds).with_advisory_lock(&block)
-      ensure
-        lock_stack.pop
+        impl = impl_class.new(connection, lock_name, timeout_seconds)
+        impl.with_advisory_lock_if_needed(&block)
       end
-
-      def wal_log(msg)
-        if respond_to?(:logger) && logger
-          logger.warn(msg)
-        else
-          $stderr.puts(msg)
-        end
-      end
-      private :wal_log
     end
   end
 end

data/lib/with_advisory_lock/mysql.rb

@@ -1,9 +1,15 @@
+require 'with_advisory_lock/nested_advisory_lock_error'
 module WithAdvisoryLock
   class MySQL < Base
 
     # See http://dev.mysql.com/doc/refman/5.0/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)
+      end
       # Returns 1 if the lock was obtained successfully,
       # 0 if the attempt timed out (for example, because another client has
       # previously locked the name), or NULL if an error occurred
@@ -18,5 +24,9 @@ module WithAdvisoryLock
       # NULL if the named lock did not exist.
       1 == connection.select_value("SELECT RELEASE_LOCK(#{quoted_lock_name})")
     end
+
+    def already_locked?
+      lock_stack.last == @lock_name
+    end
   end
 end

data/lib/with_advisory_lock/nested_advisory_lock_error.rb

@@ -0,0 +1,14 @@
+module WithAdvisoryLock
+  class NestedAdvisoryLockError < StandardError
+    attr_accessor :lock_stack
+
+    def initialize(msg = nil, lock_stack = nil)
+      super(msg)
+      @lock_stack = lock_stack
+    end
+
+    def to_s
+      super + (lock_stack ? ": lock stack = #{lock_stack}" : "")
+    end
+  end
+end

data/lib/with_advisory_lock/version.rb

@@ -1,3 +1,3 @@
 module WithAdvisoryLock
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/test/concern_test.rb

@@ -6,6 +6,6 @@ describe "with_advisory_lock.concern" do
   end
 
   it "adds with_advisory_lock to ActiveRecord instances" do
-    assert Tag.new.respond_to?(:with_advisory_lock)
+    assert Label.new.respond_to?(:with_advisory_lock)
   end
 end

data/test/minitest_helper.rb

@@ -8,7 +8,7 @@ db_config = File.expand_path("database.yml", File.dirname(__FILE__))
 ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(db_config)).result)
 
 def env_db
-  ENV["DB"] || "sqlite3"
+  ENV["DB"] || "sqlite"
 end
 
 ActiveRecord::Base.establish_connection(env_db)

data/test/nesting_test.rb

@@ -0,0 +1,49 @@
+require 'minitest_helper'
+
+describe "lock nesting" do
+  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.must_equal %w(first)
+      # Even MySQL should be OK with this:
+      Tag.with_advisory_lock("first") do
+        impl.lock_stack.must_equal %w(first)
+      end
+      impl.lock_stack.must_equal %w(first)
+    end
+    impl.lock_stack.must_be_empty
+  end
+
+  it "raises errors with MySQL when acquiring nested lock" do
+    skip if env_db != 'mysql'
+    proc {
+      Tag.with_advisory_lock("first") do
+        Tag.with_advisory_lock("second") do
+        end
+      end
+    }.must_raise WithAdvisoryLock::NestedAdvisoryLockError
+  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.must_equal %w(first)
+      Tag.with_advisory_lock("second") do
+        impl.lock_stack.must_equal %w(first second)
+        Tag.with_advisory_lock("first") do
+          # Shouldn't ask for another lock:
+          impl.lock_stack.must_equal %w(first second)
+          Tag.with_advisory_lock("second") do
+            # Shouldn't ask for another lock:
+            impl.lock_stack.must_equal %w(first second)
+          end
+        end
+      end
+      impl.lock_stack.must_equal %w(first)
+    end
+    impl.lock_stack.must_be_empty
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: with_advisory_lock
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-28 00:00:00.000000000 Z
+date: 2013-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -189,12 +189,13 @@ files:
 - lib/with_advisory_lock/concern.rb
 - lib/with_advisory_lock/flock.rb
 - lib/with_advisory_lock/mysql.rb
+- lib/with_advisory_lock/nested_advisory_lock_error.rb
 - lib/with_advisory_lock/postgresql.rb
 - lib/with_advisory_lock/version.rb
 - test/concern_test.rb
 - test/database.yml
 - test/minitest_helper.rb
-- test/mysql_nesting_test.rb
+- test/nesting_test.rb
 - test/parallelism_test.rb
 - test/simplest_test.rb
 - test/test_models.rb
@@ -214,7 +215,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2231625769835238034
+      hash: -1188809411944032990
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -223,7 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2231625769835238034
+      hash: -1188809411944032990
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -234,7 +235,7 @@ test_files:
 - test/concern_test.rb
 - test/database.yml
 - test/minitest_helper.rb
-- test/mysql_nesting_test.rb
+- test/nesting_test.rb
 - test/parallelism_test.rb
 - test/simplest_test.rb
 - test/test_models.rb

data/test/mysql_nesting_test.rb

@@ -1,13 +0,0 @@
-require 'minitest_helper'
-
-describe "lock nesting" do
-  it "warns about MySQL releasing advisory locks" do
-    skip if env_db != 'mysql'
-
-    Tag.expects(:wal_log)
-    Tag.with_advisory_lock("first") do
-      Tag.with_advisory_lock("second") do
-      end
-    end
-  end
-end