active_record_mutex 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 337ab2cfb637dc992dda05b67bc12098b0d8d7266591dc741d4918dbb3238aee
-  data.tar.gz: e812c787de8cb82696027803eafa426793af334d4c1d847c9956473a7d1faf20
+  metadata.gz: 34e4fb422fbe0336eee934df7fdeb49843c4b0335fe4222db9d8df1728b7d477
+  data.tar.gz: c3dc8c6fe86409160ded37ed5941cef3033d03b82e60c630c950ade50fc1d901
 SHA512:
-  metadata.gz: f8cb37ec99b0a52267f964b032b8f061801bef3000a11d355af5cddef3d5f075c471bd51e3fa79310136cbc53b3cd0376c293a501363b4f48f979fc774f03efc
-  data.tar.gz: 1418b58e067e151bb33e92cdd7beb215cb3fdce4ea9f7439e34ae6315b452c80d9e0cafa5f368f399ec2abb7d48c0479a1a233b1fc01f4ff364043042647faa1
+  metadata.gz: bd1437072b603f1dd5641d70970fe3bd2a24e77862a88d035222b4b1c0c360eb99ce14a573be87fc2e331e85955283262380be09c709e3bad936944a36b6615a
+  data.tar.gz: 2f4528e9a7d63ce3e2f9584f0b0099c783b07bf518174fd50c107237e0ad994fed77519f408ef27daa3aa752d3df1452fdc7a0139a312c21fe6d708d77cc5f0c

data/active_record_mutex.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: active_record_mutex 3.1.0 ruby lib
+# stub: active_record_mutex 3.2.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "active_record_mutex".freeze
-  s.version = "3.1.0".freeze
+  s.version = "3.2.0".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

data/lib/active_record/database_mutex/implementation.rb

@@ -20,7 +20,8 @@ module ActiveRecord
       #
       # @raise [ ArgumentError ] if no **name** option is provided in the options hash.
       def initialize(opts = {})
-        @name = opts[:name] or raise ArgumentError, "mutex requires a :name argument"
+        @name = opts[:name].to_s
+        @name.size != 0 or raise ArgumentError, "mutex requires a nonempty :name argument"
         internal_name # create/check internal_name
       end
 
@@ -43,38 +44,48 @@ module ActiveRecord
         end
       end
 
-			# The synchronize method attempts to acquire a mutex lock for the given name
-			# and executes the block passed to it. If the lock is already held by another
-			# database connection, this method will return nil instead of raising an
-			# exception and not execute the block. #
-			#
-			# This method provides a convenient way to ensure that critical sections of code
-			# are executed while holding the mutex lock. It attempts to acquire the lock using
-			# the underlying locking mechanisms (such as {lock} and {unlock}) and executes
-			# the block passed to it.
-			#
-			# The **block** and **timeout** options are passed to the {lock} method
-			# and configure the way the lock is acquired.
-			#
-			# The **force** option is passed to the {unlock} method, which will force the
-			# lock to open if true.
-			#
-			# @example
-			#   foo.mutex.synchronize { do_something_with foo } # wait forever and never give up
-			#
-			# @example
-			#   foo.mutex.synchronize(timeout: 5) { do_something_with foo } # wait 5s and give up
-			#
-			# @example
-			#   unless foo.mutex.synchronize(block: false) { do_something_with foo }
-			#     # try again later
-			#   end
-			#
-			# @param opts [ Hash ] Options hash containing the **block**, **timeout**, or **force** keys
-			#
-			# @yield [ Result ] The block to be executed while holding the mutex lock
-			#
-			# @return [ Nil or result of yielded block ] depending on whether the lock was acquired
+      # The lock_name method generates the name for the mutex's internal lock
+      # variable based on its class and {name} attributes, prefixing it with a
+      # truncated version of the name that only includes printable characters.
+      #
+      # @return [ String ] the generated lock name
+      def lock_name
+        prefix_name = name.gsub(/[^[:print:]]/, '')[0, 32]
+        prefix_name + ?= + internal_name
+      end
+
+      # The synchronize method attempts to acquire a mutex lock for the given name
+      # and executes the block passed to it. If the lock is already held by another
+      # database connection, this method will return nil instead of raising an
+      # exception and not execute the block. #
+      #
+      # This method provides a convenient way to ensure that critical sections of code
+      # are executed while holding the mutex lock. It attempts to acquire the lock using
+      # the underlying locking mechanisms (such as {lock} and {unlock}) and executes
+      # the block passed to it.
+      #
+      # The **block** and **timeout** options are passed to the {lock} method
+      # and configure the way the lock is acquired.
+      #
+      # The **force** option is passed to the {unlock} method, which will force the
+      # lock to open if true.
+      #
+      # @example
+      #   foo.mutex.synchronize { do_something_with foo } # wait forever and never give up
+      #
+      # @example
+      #   foo.mutex.synchronize(timeout: 5) { do_something_with foo } # wait 5s and give up
+      #
+      # @example
+      #   unless foo.mutex.synchronize(block: false) { do_something_with foo }
+      #     # try again later
+      #   end
+      #
+      # @param opts [ Hash ] Options hash containing the **block**, **timeout**, or **force** keys
+      #
+      # @yield [ Result ] The block to be executed while holding the mutex lock
+      #
+      # @return [ Nil or result of yielded block ] depending on whether the lock was acquired
       def synchronize(opts = {})
         locked = lock(opts.slice(:block, :timeout)) or return
         yield
@@ -147,7 +158,7 @@ module ActiveRecord
             decrement_counter
           end
           if counter_zero?
-            case query("SELECT RELEASE_LOCK(#{quote(internal_name)})")
+            case query("SELECT RELEASE_LOCK(#{quote(lock_name)})")
             when 1
               true
             when 0, nil
@@ -181,7 +192,7 @@ module ActiveRecord
       #
       # @return [ true, false ] true if the mutex is unlocked, false otherwise
       def unlocked?
-        query("SELECT IS_FREE_LOCK(#{quote(internal_name)})") == 1
+        query("SELECT IS_FREE_LOCK(#{quote(lock_name)})") == 1
       end
 
       # The locked? method returns true if this mutex is currently locked by
@@ -194,7 +205,7 @@ module ActiveRecord
 
       # Returns true if the mutex is was acquired on this database connection.
       def owned?
-        query("SELECT CONNECTION_ID() = IS_USED_LOCK(#{quote(internal_name)})") == 1
+        query("SELECT CONNECTION_ID() = IS_USED_LOCK(#{quote(lock_name)})") == 1
       end
 
       # Returns true if this mutex was not acquired on this database connection,
@@ -225,13 +236,15 @@ module ActiveRecord
         ActiveRecord::Base.connection.quote(value)
       end
 
+      alias counter_name internal_name
+
       # The counter method generates a unique name for the mutex's internal
       # counter variable. This name is used as part of the SQL query to set and
       # retrieve the counter value.
       #
       # @return [String] the unique name for the mutex's internal counter variable.
       def counter
-        "@#{internal_name}"
+        "@#{counter_name}"
       end
 
       # The increment_counter method increments the internal counter value for
@@ -290,7 +303,7 @@ module ActiveRecord
           increment_counter
           true
         else
-          case query("SELECT GET_LOCK(#{quote(internal_name)}, #{timeout})")
+          case query("SELECT GET_LOCK(#{quote(lock_name)}, #{timeout})")
           when 1
             increment_counter
             true

data/lib/active_record/database_mutex/version.rb

@@ -1,6 +1,6 @@
 module ActiveRecord::DatabaseMutex
   # ActiveRecord::DatabaseMutex version
-  VERSION         = '3.1.0'
+  VERSION         = '3.2.0'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/active_record/database_mutex.rb

@@ -76,7 +76,7 @@ module ActiveRecord
         connection.select_all(<<~EOT).map { MutexInfo.new(_1) }
           SELECT * FROM performance_schema.metadata_locks
           WHERE OBJECT_TYPE = 'USER LEVEL LOCK'
-          AND OBJECT_NAME LIKE "$%"
+          AND OBJECT_NAME LIKE "%=$%"
         EOT
       end
     end

data/test/database_mutex_test.rb

@@ -55,6 +55,22 @@ class DatabaseMutexTest < Test::Unit::TestCase
     assert_kind_of ActiveRecord::DatabaseMutex::Implementation, mutex
   end
 
+  private def lock_exists?(string)
+    ActiveRecord::Base.all_mutexes.map(&:OBJECT_NAME).any? {
+      _1.include?(string)
+    }
+  end
+
+  def test_all_mutexes
+    string = SecureRandom.hex(16)
+    mutex = ActiveRecord::DatabaseMutex.for(string)
+    assert_false lock_exists?(string)
+    mutex.lock
+    assert lock_exists?(string)
+  ensure
+    mutex.unlock force: true
+  end
+
   def test_create
     mutex = Implementation.new(:name => 'Create')
     assert_equal 'Create', mutex.name

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_mutex
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Florian Frank