pg_advisory_lock 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 466169c01607df8b0c40594fa296e1fed78308d06a5512bab01e12cbafe59c2d
-  data.tar.gz: 55fb38aafaaad466d4ef287dcb5ae9b2ad17bdd2e22cfc8ddeb6ca75e7d036e4
+  metadata.gz: 8a63a1943d6c02f12078939e1c72cad482972a9493ec408a0984308b329e269b
+  data.tar.gz: fcf0e101ff148fa73651759f0dbe4fe32cbaac1be1b5e9a13f26a7816c2d3a15
 SHA512:
-  metadata.gz: cb2a78d382278811c09863faee99aca67c7fffdfb9f579b9ea96f76c3a895888b598c1bbd16c2ea5e57cbd409f6d36d60dc8b185b00c7861a83c3ac98dfe1d75
-  data.tar.gz: 8fa4803b480af658d61c4c86441e7f0e0886f573a373ab182ed2c3b5bf41f195a9f1e4d81bdecadd1881655feb28eed39b1dd84f0bb8386dfcf2c15033f72fae
+  metadata.gz: 12b30ae854f94924bbced7bd831f4bbe89e682a50a0d01c299b7c3071c79e04e1d8cadadc5017574138d328104dc118f35f0fcee4e69889ea3ebb01bb0b8c8a8
+  data.tar.gz: 33ce47ca69b19de4985d8bf9d7517fecb5d9074bf3fe5ce53518b2b880ae6a7e1110f607a2160a6e8b8ee3928938603c75d53e957ee3f8e7dca1f5961b38682b

data/.github/workflows/tests.yml

@@ -0,0 +1,69 @@
+name: Tests
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+    name: Rubocop lint
+    env:
+      RAILS_VERSION: '~> 6.0'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7
+          bundler-cache: true
+      - name: Run rubocop
+        run: |
+          gem install bundler
+          bundle install
+          bundle exec rake rubocop
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [ '2.7', '3.0', '3.1' ]
+        rails: [ '~> 6.0', '~> 7.0' ]
+    name: Tests with Ruby ${{ matrix.ruby }} Activerecord ${{ matrix.rails }}
+    services:
+      # Label used to access the service container
+      postgres:
+        # Docker Hub image
+        image: postgres
+        # Provide the password for postgres
+        env:
+          POSTGRES_DB: postgres_db
+          POSTGRES_PORT: 5432
+          POSTGRES_USER: postgres_user
+          POSTGRES_PASSWORD: postgres_password
+        ports:
+          - 5432:5432
+        # Set health checks to wait until postgres has started
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    env:
+      RAILS_VERSION: ${{ matrix.rails }}
+      POSTGRES_HOST: localhost
+      POSTGRES_DB: postgres_db
+      POSTGRES_PORT: 5432
+      POSTGRES_USER: postgres_user
+      POSTGRES_PASSWORD: postgres_password
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run tests
+        run: |
+          gem install bundler
+          bundle install
+          cp -v spec/config/database.ci.yml spec/config/database.yml
+          bundle exec rake spec

data/.rubocop.yml

@@ -1,6 +1,6 @@
 AllCops:
   DisplayCopNames: true
-  TargetRubyVersion: 2.5
+  TargetRubyVersion: 2.7
   Exclude:
     - vendor/**/*
     - tmp/**/*

data/README.md

@@ -1,5 +1,9 @@
 # PgAdvisoryLock
 
+![tests](https://github.com/didww/pg_advisory_lock/actions/workflows/tests.yml/badge.svg)
+[![Gem Version](https://badge.fury.io/rb/pg_advisory_lock.svg)](https://badge.fury.io/rb/pg_advisory_lock)
+
+
 Postgresql Advisory Lock for ActiveRecord.
 Allows to use mutex in applications that uses same database.
 
@@ -24,8 +28,6 @@ Or install it yourself as:
 create subclass from `PgAdvisoryLock::Base` and define `model_class` for it
 
 ```ruby
-require 'pg_sql_caller'
-
 class MySqlCaller < PgAdvisoryLock::Base
   model_class 'ApplicationRecord'
 end
@@ -44,7 +46,7 @@ PgAdvisoryLock::Base.select_values 'SELECT id from users WHERE parent_name = ?',
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. 
-Create `spec/config/database.yml` (look at `spec/config/database.travis.yml` for example).
+Create `spec/config/database.yml` (look at `spec/config/database.example.yml` for example).
 You need to create test database, so run `psql -c 'CREATE DATABASE pg_advisory_lock_test;'`.
 Then, run `rake spec` to run the tests. 
 You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/pg_advisory_lock/base.rb

@@ -23,6 +23,8 @@ module PgAdvisoryLock
       # @param name [Symbol, String]
       # @param value [Integer, Array<(Integer, Integer)>]
       def register_lock(name, value)
+        raise ArgumentError, 'value must be integer or array of integers' unless int_or_array_of_ints?(value)
+
         _lock_names[name.to_sym] = value
       end
 
@@ -31,6 +33,8 @@ module PgAdvisoryLock
         self._sql_caller_class = klass
       end
 
+      # Locks specific advisory lock.
+      # If it's already locked just waits.
       # @param name [Symbol, String] - lock name (will be transformed to number).
       # @param transaction [Boolean] - if true lock will be released at the end of current transaction
       #   otherwise it will be released at the end of block.
@@ -41,7 +45,33 @@ module PgAdvisoryLock
       # @raise [ArgumentError] when lock name is invalid.
       # @return yield
       def with_lock(name, transaction: true, shared: false, id: nil, &block)
-        new(name, transaction: transaction, shared: shared, id: id).lock(&block)
+        new(name, transaction: transaction, shared: shared, id: id, wait: true).lock(&block)
+      end
+
+      # Tries to lock specific advisory lock.
+      # If it's already locked raises exception.
+      # @param name [Symbol, String] - lock name (will be transformed to number).
+      # @param transaction [Boolean] - if true lock will be released at the end of current transaction
+      #   otherwise it will be released at the end of block.
+      # @param shared [Boolean] - is lock shared or not.
+      # @param id [Integer] - number that will be used in pair with lock number to perform advisory lock.
+      # @yield - call block when lock is acquired
+      #   block must be passed if transaction argument is false.
+      # @raise [ArgumentError] when lock name is invalid.
+      # @raise [PgAdvisoryLock::LockNotObtained] when wait: false passed and lock already locked.
+      # @return yield
+      def try_lock(name, transaction: true, shared: false, id: nil, &block)
+        new(name, transaction: transaction, shared: shared, id: id, wait: false).lock(&block)
+      end
+
+      private
+
+      def int_or_array_of_ints?(value)
+        return true if value.is_a?(Integer)
+
+        return true if value.is_a?(Array) && value.all? { |i| i.is_a?(Integer) }
+
+        false
       end
     end
 
@@ -50,27 +80,30 @@ module PgAdvisoryLock
     #   otherwise it will be released at the end of block.
     # @param shared [Boolean] - is lock shared or not.
     # @param id [Integer] - number that will be used in pair with lock number to perform advisory lock.
-    def initialize(name, transaction: false, shared: false, id: nil)
+    # @param wait [Boolean] - when locked by someone else: true - wait for lock, raise PgAdvisoryLock::LockNotObtained.
+    def initialize(name, transaction:, shared:, id:, wait:)
       @name = name.to_sym
       @transaction = transaction
       @shared = shared
       @id = id
+      @wait = wait
     end
 
     # @yield - call block when lock is acquired
     #   block must be passed if transaction argument is false.
     # @raise [ArgumentError] when lock name is invalid.
+    # @raise [PgAdvisoryLock::LockNotObtained] when wait: false passed and lock already locked.
     # @return yield
     def lock(&block)
       with_logger do
-        lock_number = name_to_number
-        advisory_lock(lock_number, &block)
+        lock_args = build_lock_args
+        advisory_lock(lock_args, &block)
       end
     end
 
     private
 
-    attr_reader :transaction, :shared, :name, :id
+    attr_reader :transaction, :shared, :name, :id, :wait
 
     def with_logger
       return yield if logger.nil? || !logger.respond_to?(:tagged)
@@ -78,57 +111,68 @@ module PgAdvisoryLock
       logger.tagged(self.class.to_s, name.inspect) { yield }
     end
 
-    def advisory_lock(lock_number, &block)
+    def advisory_lock(lock_args, &block)
       if transaction
-        transaction_lock(lock_number, &block)
+        transaction_lock(lock_args, &block)
       else
-        non_transaction_lock(lock_number, &block)
+        non_transaction_lock(lock_args, &block)
       end
     end
 
-    def transaction_lock(lock_number)
+    def transaction_lock(lock_args)
       raise ArgumentError, 'block required when not within transaction' if !block_given? && !sql_caller_class.transaction_open?
 
-      return perform_lock(lock_number) unless block_given?
+      return perform_lock(lock_args) unless block_given?
 
       sql_caller_class.transaction do
-        perform_lock(lock_number)
+        perform_lock(lock_args)
         yield
       end
     end
 
-    def non_transaction_lock(lock_number)
+    def non_transaction_lock(lock_args)
       raise ArgumentError, 'block required on transaction: false' unless block_given?
 
       begin
-        perform_lock(lock_number)
+        perform_lock(lock_args)
         yield
       ensure
-        perform_unlock(lock_number)
+        perform_unlock(lock_args)
       end
     end
 
-    def perform_lock(lock_number)
-      function_name = "pg_advisory#{'_xact' if transaction}_lock#{'_shared' if shared}"
+    def perform_lock(lock_args)
+      function_name = "pg#{'_try' unless wait}_advisory#{'_xact' if transaction}_lock#{'_shared' if shared}"
 
-      sql_caller_class.execute("SELECT #{function_name}(#{lock_number})")
+      if wait
+        sql_caller_class.execute("SELECT #{function_name}(#{lock_args})")
+      else
+        result = sql_caller_class.select_value("SELECT #{function_name}(#{lock_args})")
+        raise LockNotObtained, "#{self.class} can't obtain lock (#{name}, #{id.inspect})" unless result
+      end
     end
 
-    def perform_unlock(lock_number)
-      sql_caller_class.select_value("SELECT pg_advisory_unlock#{'_shared' if shared}(#{lock_number})")
+    def perform_unlock(lock_args)
+      sql_caller_class.select_value("SELECT pg_advisory_unlock#{'_shared' if shared}(#{lock_args})")
     end
 
     # Converts lock name to number, because pg advisory lock functions accept only bigint numbers.
     # @return [String] lock number or two numbers delimited by comma.
-    def name_to_number
-      lock_number = _lock_names.fetch(name) do
+    def build_lock_args
+      lock_args = _lock_names.fetch(name) do
         raise ArgumentError, "lock name #{name.inspect} is invalid, see #{self.class}::NAMES"
       end
-      lock_number = Array.wrap(lock_number)
-      lock_number.push(id) if id.present?
-      raise ArgumentError, "can't use lock name #{name.inspect} with id" if lock_number.size > 2
+      lock_args = Array.wrap(lock_args)
+      if id.present?
+        if id.is_a?(Integer)
+          lock_args.push(id)
+        else
+          lock_args.push("hashtext(#{sql_caller_class.connection.quote(id.to_s)})")
+        end
+      end
+      raise ArgumentError, "can't use lock name #{name.inspect} with id" if lock_args.size > 2
 
-      lock_number.join(', ')
+      lock_args.join(', ')
     end
 
     def sql_caller_class

data/lib/pg_advisory_lock/lock_not_obtained.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PgAdvisoryLock
+  class LockNotObtained < StandardError
+  end
+end

data/lib/pg_advisory_lock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgAdvisoryLock
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

data/lib/pg_advisory_lock.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'pg_advisory_lock/version'
+require 'pg_advisory_lock/lock_not_obtained'
 require 'pg_advisory_lock/base'
 
 module PgAdvisoryLock

data/pg_advisory_lock.gemspec

@@ -29,5 +29,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'activerecord'
   spec.add_dependency 'activesupport'
-  spec.add_dependency 'pg_sql_caller'
+  spec.add_dependency 'pg_sql_caller', '>= 0.2.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_advisory_lock
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Denis Talakevich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-25 00:00:00.000000000 Z
+date: 2023-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.2
 description: Postgresql Advisory Lock for ActiveRecord.
 email:
 - senid231@gmail.com
@@ -59,10 +59,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/tests.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -72,6 +72,7 @@ files:
 - bin/setup
 - lib/pg_advisory_lock.rb
 - lib/pg_advisory_lock/base.rb
+- lib/pg_advisory_lock/lock_not_obtained.rb
 - lib/pg_advisory_lock/version.rb
 - pg_advisory_lock.gemspec
 homepage: https://github.com/didww/pg_advisory_lock
@@ -96,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Postgresql Advisory Lock for ActiveRecord

data/.travis.yml

@@ -1,6 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.5.5
-before_install: gem install bundler -v 2.1.4