db_lock 0.8.3 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bf2cc97847ee6ffd808862521722c813feaddd2c901b3d7ae2f3048b5f110c6
-  data.tar.gz: a1d6c63848525ac3c5525859ae6ab8de36b4207f316235367bb048ea4d056a25
+  metadata.gz: 50db7061b198b0f203663eecb1c432320d5977a9887e9468a2742d718d16e399
+  data.tar.gz: 18368c4c79889d0eed565a5090f4b00b548d52b29b7cfbf93f65e7f05cbc05fc
 SHA512:
-  metadata.gz: 7d86fd46f20a9e2395d5c9c933cc72de655b9639f310ace64d73c1d840eaf3c0ac8e0586cf7eca419aeb093c50aee1856d81df2a08d56bebbc8be8274ae150b2
-  data.tar.gz: 50bbbba20692ca761eecbd696abd5bd942dd8b61db07f4c86687f0adc7a284c4d35753e4f2e07fe53eecf1fcda0db47486125bc3aebe85891a32beb9c8e50eb1
+  metadata.gz: f4d25535f5a4b4e32dd4c4ec8b3c9bd97a107df91c881ddef25ba2f3e47ff7e0cbfec398a8ca45a29e251daaf0a3a5aa8d17a776eba3b2d8bd6a8bef5ff44b26
+  data.tar.gz: cb7cc7240ba171a0e049d638043b3b220a987ee254255674de053dfae413adb65fa165292184f1ddeef9f1eb4ed93b52dbb64b18f711f3166ca9d09a5c84fc32

data/README.md

@@ -1,12 +1,13 @@
 # DBLock
 
 [![Gem Version](https://badge.fury.io/rb/db_lock.svg)](https://badge.fury.io/rb/db_lock)
-[![Tests](https://github.com/mkon/db_lock/actions/workflows/test.yml/badge.svg)](https://github.com/mkon/db_lock/actions/workflows/test.yml)
+[![Tests](https://github.com/mkon/db_lock/actions/workflows/main.yml/badge.svg)](https://github.com/mkon/db_lock/actions/workflows/main.yml)
 
 Gem to obtain and release manual db locks. This can be utilized for example to make sure that certain rake tasks do not run in parallel on the same database (for example when cron jobs run for too long or are accidentally started multiple times). Currently only supports:
 
 - MySQL
 - Microsoft SQL Server
+- Postgres
 
 ## Installation
 
@@ -19,16 +20,24 @@ then run `bundle`
 ## Usage
 
 ```ruby
-DBLock::Lock.get('name_of_lock', 5) do
+DBLock.with_lock('name_of_lock', 5) do
   # code here
 end
 ```
 
-Before the code block is executed, it will attempt to acquire a mysql db lock for X seconds (5 in this example). If this fails it will raise an `DBLock::AlreadyLocked` error. The lock is released after the block is executed, even if the block raised an error itself.
+Before the code block is executed, it will attempt to acquire a db lock for X seconds (5 in this example). If this fails it will raise an `DBLock::AlreadyLocked` error. The lock is released after the block is executed, even if the block raised an error itself.
 
-The current implementation uses a class variable to store lock state so it is not thread-safe when using multiple threads to acquire/release locks.
+The locking will already fail with an error if the current thread already holds a lock via this gem.
 
-## Smart lock name
+Locks are achieved on the database via:
+
+| Database  | Locking method     |
+|-----------|--------------------|
+| MySQL     | `GET_LOCK`         |
+| Postgres  | `pg_advisory_lock` |
+| SQLServer | `sp_getapplock`    |
+
+## Dynamic lock name
 
 If you prefix the lock with a `.` in a Rails application, `.` will be automatically replaced with `YourAppName.environment` (production/development/etc).
 If the lock name exceeds 64 characters, it will be replaced with a lock name of 64 characters, that consists of a pre- and suffix from the original lock name and a middle MD5 checksum.

data/lib/db_lock/adapter/base.rb

@@ -3,14 +3,41 @@ module DBLock
     class Base
       include Singleton
 
+      def execute(*args)
+        run_sanitized :execute, args
+      end
+
+      def select_one(*args)
+        run_sanitized :select_one, args
+      end
+
+      def select_value(*args)
+        run_sanitized :select_value, args
+      end
+
       private
 
       def connection
         DBLock.db_handler.connection
       end
 
+      def pool
+        DBLock.db_handler.connection_pool
+      end
+
+      def logger
+        DBLock.db_handler.logger
+      end
+
       def sanitize_sql_array(*args)
-        DBLock.db_handler.send(:sanitize_sql_array, args)
+        DBLock.db_handler.sanitize_sql_array args
+      end
+
+      def run_sanitized(command, args)
+        options = args.extract_options!
+        con = options[:connection] || connection
+        sql = sanitize_sql_array(*args)
+        con.public_send(command, sql)
       end
     end
   end

data/lib/db_lock/adapter/mysql.rb

@@ -2,15 +2,13 @@ module DBLock
   module Adapter
     class MYSQL < Base
       def lock(name, timeout = 0)
-        sql = sanitize_sql_array 'SELECT GET_LOCK(?, ?)', name, timeout
-        res = connection.select_one sql
-        (res && res.values.first == 1)
+        res = select_value 'SELECT GET_LOCK(?, ?)', name, timeout
+        res == 1
       end
 
       def release(name)
-        sql = sanitize_sql_array 'SELECT RELEASE_LOCK(?)', name
-        res = connection.select_one sql
-        (res && res.values.first == 1)
+        res = select_value 'SELECT RELEASE_LOCK(?)', name
+        res == 1
       end
     end
   end

data/lib/db_lock/adapter/postgres.rb

@@ -0,0 +1,66 @@
+require 'timeout'
+
+module DBLock
+  module Adapter
+    LockTimeout = Class.new(Timeout::Error)
+
+    class Postgres < Base
+      def lock(name, timeout = 0)
+        pid = connection_pid(connection)
+        Timeout.timeout(timeout, LockTimeout) do
+          execute lock_query(name)
+          # Sadly this returns void in postgres
+          true
+        end
+      rescue LockTimeout
+        logger&.info 'DBLock: Recovering from expired lock query'
+        recover_from_timeout pid, name
+      end
+
+      def release(name)
+        res = select_value 'SELECT pg_advisory_unlock(hashtext(?))', name
+        res == true
+      end
+
+      private
+
+      def lock_query(name)
+        sanitize_sql_array 'SELECT pg_advisory_lock(hashtext(?))', name
+      end
+
+      def connection_pid(con)
+        select_value 'SELECT pg_backend_pid()', connection: con
+      end
+
+      # We have to manually kill the lock query.
+      # Connection pool keeps it alive blocking one connection.
+      # Also it would eventually acquire the lock.
+      # returns true if lock was acquired
+      def recover_from_timeout(pid, name)
+        with_dedicated_connection do |con|
+          lock = select_one(<<~SQL, pid, name, connection: con)
+            SELECT locktype, objid, pid, granted FROM pg_locks \
+            WHERE pid = ? AND locktype = 'advisory' AND objid = hashtext(?)
+          SQL
+          return false unless lock
+
+          if lock['granted']
+            logger&.info 'DBLock: Lock was acquired after all'
+            true
+          else
+            res = select_value 'SELECT pg_cancel_backend(?)', pid, connection: con
+            logger&.warn 'DBLock: Failed to cancel ungranted lock query' unless res == true
+            false
+          end
+        end
+      end
+
+      def with_dedicated_connection
+        con = pool.checkout
+        yield con
+      ensure
+        pool.checkin con
+      end
+    end
+  end
+end

data/lib/db_lock/adapter.rb

@@ -4,6 +4,7 @@ module DBLock
 
     autoload :Base, 'db_lock/adapter/base'
     autoload :MYSQL, 'db_lock/adapter/mysql'
+    autoload :Postgres, 'db_lock/adapter/postgres'
     autoload :Sqlserver, 'db_lock/adapter/sqlserver'
 
     delegate :lock, :release, to: :implementation
@@ -12,6 +13,8 @@ module DBLock
       case DBLock.db_handler.connection.adapter_name.downcase
       when 'mysql2'
         MYSQL.instance
+      when 'postgresql'
+        Postgres.instance
       when 'sqlserver'
         Sqlserver.instance
       else

data/lib/db_lock/lock.rb

@@ -4,48 +4,12 @@ module DBLock
   module Lock
     extend self
 
-    # rubocop:disable Metrics/AbcSize
-    def get(name, timeout = 0)
-      timeout = timeout.to_f # catches nil
-      timeout = 0 if timeout.negative?
-
-      raise "Invalid lock name: #{name.inspect}" if name.empty?
-      raise AlreadyLocked, 'Already lock in progress' if locked?
-
-      name = generate_lock_name(name)
-
-      if Adapter.lock(name, timeout)
-        @locked = true
-        yield
-      else
-        raise AlreadyLocked, "Unable to obtain lock '#{name}' within #{timeout} seconds" unless locked?
-      end
-    ensure
-      Adapter.release(name) if locked?
-      @locked = false
+    def get(name, timeout = 0, &block)
+      DBLock.with_lock(name, timeout, &block)
     end
-    # rubocop:enable Metrics/AbcSize
 
     def locked?
-      @locked ||= false
-    end
-
-    private
-
-    def generate_lock_name(name)
-      name = "#{rails_app_name}.#{Rails.env}#{name}" if name[0] == '.' && defined? Rails
-      # reduce lock names of > 64 chars in size
-      # MySQL 5.7 only supports 64 chars max, there might be similar limitations elsewhere
-      name = "#{name.chars.first(15).join}-#{Digest::MD5.hexdigest(name)}-#{name.chars.last(15).join}" if name.length > 64
-      name
-    end
-
-    def rails_app_name
-      if Gem::Version.new(Rails.version) >= Gem::Version.new('6.0.0')
-        Rails.application.class.module_parent_name
-      else
-        Rails.application.class.parent_name
-      end
+      DBLock.send(:locked?)
     end
   end
 end

data/lib/db_lock/locking.rb

@@ -0,0 +1,47 @@
+require 'digest/md5'
+
+module DBLock
+  module Locking
+    def with_lock(name, timeout = 0)
+      timeout = timeout.to_f # catches nil
+      timeout = 0 if timeout.negative?
+
+      raise ArgumentError, "Invalid lock name: #{name.inspect}" if name.empty?
+      raise AlreadyLocked, 'Already lock in progress' if locked?
+
+      name = generate_lock_name(name)
+
+      if Adapter.lock(name, timeout)
+        @locked = true
+        yield
+      else
+        raise AlreadyLocked, "Unable to obtain lock '#{name}' within #{timeout} seconds" unless locked?
+      end
+    ensure
+      Adapter.release(name) if locked?
+      @locked = false
+    end
+
+    private
+
+    def locked?
+      @locked ||= false
+    end
+
+    def generate_lock_name(name)
+      name = "#{rails_app_name}.#{Rails.env}#{name}" if name[0] == '.' && defined? Rails
+      # reduce lock names of > 64 chars in size
+      # MySQL 5.7 only supports 64 chars max, there might be similar limitations elsewhere
+      name = "#{name.chars.first(15).join}-#{Digest::MD5.hexdigest(name)}-#{name.chars.last(15).join}" if name.length > 64
+      name
+    end
+
+    def rails_app_name
+      if Gem::Version.new(Rails.version) >= Gem::Version.new('6.0.0')
+        Rails.application.class.module_parent_name
+      else
+        Rails.application.class.parent_name
+      end
+    end
+  end
+end

data/lib/db_lock.rb

@@ -1,17 +1,25 @@
+require 'active_support'
 require 'digest/md5'
 
 module DBLock
-  extend self
-
   autoload :Adapter, 'db_lock/adapter'
   autoload :Lock, 'db_lock/lock'
+  autoload :Locking, 'db_lock/locking'
+
+  extend Locking
 
   class AlreadyLocked < StandardError; end
 
-  attr_accessor :db_handler
+  attr_writer :db_handler
 
-  def db_handler
+  def self.db_handler
     # this must be an active record base object or subclass
     @db_handler || ActiveRecord::Base
   end
+
+  custom_deprecator = ActiveSupport::Deprecation.new('1.0.0', 'DBLock')
+  ActiveSupport::Deprecation.deprecate_methods(DBLock::Lock, get: 'use DBLock.with_lock instead',
+                                                             deprecator: custom_deprecator)
+  ActiveSupport::Deprecation.deprecate_methods(DBLock::Lock, locked?: 'will be removed without replacement',
+                                                             deprecator: custom_deprecator)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_lock
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.9.1
 platform: ruby
 authors:
 - mkon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-26 00:00:00.000000000 Z
+date: 2022-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -50,28 +50,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.29.1
+        version: 1.37.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.29.1
+        version: 1.37.1
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.11.1
+        version: 2.14.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.11.1
+        version: 2.14.2
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -86,8 +86,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Obtain manual db locks to guard blocks of code from parallel execution.Currently
-  only supports mysql and ms-sql-server.
+description: Obtain manual db locks to guard blocks of code from parallel execution.Supports
+  mysql, postgres and ms-sql-server.
 email:
 - konstantin@munteanu.de
 executables: []
@@ -100,8 +100,10 @@ files:
 - lib/db_lock/adapter.rb
 - lib/db_lock/adapter/base.rb
 - lib/db_lock/adapter/mysql.rb
+- lib/db_lock/adapter/postgres.rb
 - lib/db_lock/adapter/sqlserver.rb
 - lib/db_lock/lock.rb
+- lib/db_lock/locking.rb
 homepage: https://github.com/mkon/db_lock
 licenses:
 - MIT