active_record_mutex 3.1.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 337ab2cfb637dc992dda05b67bc12098b0d8d7266591dc741d4918dbb3238aee
-  data.tar.gz: e812c787de8cb82696027803eafa426793af334d4c1d847c9956473a7d1faf20
+  metadata.gz: 36b8a40a6140ecdfcd0e3892d2e008d502acdce96826ef3aecc797cadb65fa89
+  data.tar.gz: 38bf80d5ed330479f5a8399633048c606f7d03b71aaccacf512509c9cdcbb58e
 SHA512:
-  metadata.gz: f8cb37ec99b0a52267f964b032b8f061801bef3000a11d355af5cddef3d5f075c471bd51e3fa79310136cbc53b3cd0376c293a501363b4f48f979fc774f03efc
-  data.tar.gz: 1418b58e067e151bb33e92cdd7beb215cb3fdce4ea9f7439e34ae6315b452c80d9e0cafa5f368f399ec2abb7d48c0479a1a233b1fc01f4ff364043042647faa1
+  metadata.gz: a580eda2be88864af2b8aec078b09b5757992063f9078e64afb195c167bfc6b858f1d0674f2c348e66659c9f759e2cb47bb147a9b6118e9817510cdf6b77cb05
+  data.tar.gz: 51e00870718236b49c3271a0164d68fe6708e5b2451daad87b9f211090b3d7979a06546665d25082dadaca028fbb773c544ac33f7932c3a8d04150c2e31ff369

data/CHANGES.md

@@ -1,5 +1,19 @@
 # Changes
 
+## 2024-10-16 v3.2.1
+
+* Refactor DatabaseMutex implementation:
+  * Change `@name` and `mutex.name` to downcase and freeze values
+  * Update tests to reflect new behavior
+
+## 2024-10-16 v3.2.0
+
+* DatabaseMutex improvements:
+  * Improved lock name generation in `lock_name` method.
+  * Modified SQL queries to use `lock_name` instead of `internal_name`.
+  * Added `lock_exists?` and `test_all_mutexes` methods for testing mutex
+    creation and querying.
+
 ## 2024-10-16 v3.1.0
 
 * Changes for **3.1.0**:

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.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "active_record_mutex".freeze
-  s.version = "3.1.0".freeze
+  s.version = "3.2.1".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,8 +20,10 @@ 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"
-        internal_name # create/check internal_name
+        @name = opts[:name].to_s.downcase
+        @name.size != 0 or raise ArgumentError, "mutex requires a nonempty :name argument"
+        @name.freeze
+        lock_name # create/check internal_name and lock_name
       end
 
       # Returns the name of this mutex as given via the constructor argument.
@@ -34,7 +36,8 @@ module ActiveRecord
       def internal_name
         @internal_name and return @internal_name
         encoded_name = ?$ + Digest::MD5.base64digest([ self.class.name, name ] * ?#).
-          delete('^A-Za-z0-9+/').gsub(/[+\/]/, ?+ => ?_, ?/ => ?.)
+          delete('^A-Za-z0-9+/').gsub(/[+\/]/, ?+ => ?_, ?/ => ?.).
+          downcase.freeze
         if encoded_name.size <= 64
           @internal_name = encoded_name
         else
@@ -43,38 +46,51 @@ 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
+        @lock_name and return @lock_name
+        prefix_name = name.gsub(/[^[:print:]]/, '')[0, 32]
+        @lock_name = prefix_name + ?= + internal_name
+        @lock_name.downcase!
+        @lock_name.freeze
+      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 +163,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 +197,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 +210,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 +241,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 +308,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.1'
   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

@@ -25,7 +25,7 @@ class DatabaseMutexTest < Test::Unit::TestCase
     old, ENV['RAILS_ENV'] = ENV['RAILS_ENV'], nil
     mutex = Foo.mutex
     assert_kind_of ActiveRecord::DatabaseMutex::Implementation, mutex
-    assert_equal Foo.name, mutex.name
+    assert_equal Foo.name.downcase, mutex.name
   ensure
     ENV['RAILS_ENV'] = old
   end
@@ -34,7 +34,7 @@ class DatabaseMutexTest < Test::Unit::TestCase
     old, ENV['RAILS_ENV'] = ENV['RAILS_ENV'], 'test'
     mutex = Foo.mutex
     assert_kind_of ActiveRecord::DatabaseMutex::Implementation, mutex
-    assert_equal "#{Foo.name}@test", mutex.name
+    assert_equal "#{Foo.name}@test".downcase, mutex.name
   ensure
     ENV['RAILS_ENV'] = old
   end
@@ -47,7 +47,7 @@ class DatabaseMutexTest < Test::Unit::TestCase
     assert_equal true, instance.save
     mutex = instance.mutex
     assert_kind_of ActiveRecord::DatabaseMutex::Implementation, mutex
-    assert_equal "#{instance.id}@#{Foo.name}", mutex.name
+    assert_equal "#{instance.id}@#{Foo.name}".downcase, mutex.name
   end
 
   def test_factory_method_for
@@ -55,9 +55,26 @@ class DatabaseMutexTest < Test::Unit::TestCase
     assert_kind_of ActiveRecord::DatabaseMutex::Implementation, mutex
   end
 
+  private def lock_exists?(string)
+    string = string.downcase
+    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
+    assert_equal 'create', mutex.name
   end
 
   def test_lock
@@ -268,11 +285,11 @@ class DatabaseMutexTest < Test::Unit::TestCase
 
   def test_internal_name
     mutex = Implementation.new(:name => (250..255).map(&:chr) * '')
-    assert_equal '$3i3xQvUrNPGyH6kaIOkiPw', mutex.send(:internal_name)
+    assert_equal '$3i3xqvurnpgyh6kaiokipw', mutex.send(:internal_name)
   end
 
   def test_counter_name
     mutex = Implementation.new(:name => (250..255).map(&:chr) * '')
-    assert_equal '@$3i3xQvUrNPGyH6kaIOkiPw', mutex.send(:counter)
+    assert_equal '@$3i3xqvurnpgyh6kaiokipw', mutex.send(:counter)
   end
 end

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.1
 platform: ruby
 authors:
 - Florian Frank