sequel-advisory-locking 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b0557baa78d17f9720b23a06e2816fc1e3b004d
-  data.tar.gz: 461541ba776f14f621082f2b21b4b76046da4522
+  metadata.gz: 57fd6955d93c47e0e7c2be787616466d8e87e351
+  data.tar.gz: d35d690106eb1d21f4dea2624abad06600c4b9d8
 SHA512:
-  metadata.gz: c6752ad6945be5933dd6c5e4168253217049abacc37ca10268e32cdc8066515665fbaf75c8dac1a54a72220bfafd30bf66fe1353c227c7870271588618475c29
-  data.tar.gz: 17ecaec857690d795ca1a611b9d7995923dbe8bf847086fd1421d357f831ac481ed3b623b59610e319dd6dd62204cd577b84c7aa96b1733e8bbdaac747af1795
+  metadata.gz: cce1a093220e70c2758d78d59920c60627de1d040742c2a4e69641f78d6a115ce40385768da9e7e9773c0fd62e335e4dd4d0f865d1286930dd5e09105936b94e
+  data.tar.gz: 1321d4964ebca516d48f8ab06999a13b8db69bba80d3f82119110d402bd01fb5cc6b4e00a31eb24c54fc4210f76e17c8600c914d1c016034ac9027297240548d

data/lib/sequel/extensions/advisory_locking.rb

@@ -8,45 +8,77 @@ module Sequel
   module AdvisoryLocking
     class Error < StandardError; end
 
-    HEX_STRING_SLICE_RANGE         = 0..15
+    HEX_STRING_SLICE_RANGE         = (0..15).freeze
     POSTGRES_SIGNED_BIGINT_BOUND   = 2**63
-    POSTGRES_UNSIGNED_BIGINT_RANGE = 2**64
-
-    LOCK_SQL     = "SELECT pg_advisory_lock(?) -- ?".freeze
-    TRY_LOCK_SQL = "SELECT pg_try_advisory_lock(?) -- ?".freeze
-    UNLOCK_SQL   = "SELECT pg_advisory_unlock(?) -- ?".freeze
-
-    def advisory_lock(key, try: false)
-      int = case key
-            when Integer then key
-            when String, Symbol
-              # For an arbitrary string, pseudorandomly return an integer in
-              # the PG bigint range.
-              hex = Digest::MD5.hexdigest(key.to_s)[HEX_STRING_SLICE_RANGE].hex
-              # Mimic PG's bigint rollover behavior.
-              hex -= POSTGRES_UNSIGNED_BIGINT_RANGE if hex >= POSTGRES_SIGNED_BIGINT_BOUND
-              hex
-            else
-              raise Error, "passed an invalid key type (#{key.class})"
-            end
+    POSTGRES_UNSIGNED_BIGINT_BOUND = 2**64
+
+    POSTGRES_SIGNED_BIGINT_MAXIMUM = POSTGRES_SIGNED_BIGINT_BOUND - 1
+    POSTGRES_SIGNED_BIGINT_MINIMUM = -POSTGRES_SIGNED_BIGINT_BOUND
+    POSTGRES_SIGNED_BIGINT_RANGE = (POSTGRES_SIGNED_BIGINT_MINIMUM..POSTGRES_SIGNED_BIGINT_MAXIMUM).freeze
+
+    def advisory_lock(key, try: false, shared: false, &block)
+      int = advisory_lock_key(key)
 
       synchronize do
         begin
           # Add key to the end so that logs read easier.
-          sql = try ? TRY_LOCK_SQL : LOCK_SQL
+          sql = "SELECT pg#{'_try' if try}_advisory_lock#{'_shared' if shared}(?) -- ?"
           locked = !!self[sql, int, key].get
 
-          if locked && block_given?
-            yield
+          if locked && block
+            if in_transaction?
+              # If we're in a transaction and an error occurs at the DB level,
+              # the advisory lock won't be released for us and we won't be
+              # able to run the unlock function below. So, wrap the block in a
+              # savepoint that will hopefully be transparent to the caller.
+              transaction(savepoint: true, rollback: :reraise, &block)
+            else
+              # If we're not in a transaction, of course, we don't have that
+              # worry, and we don't want to force the caller to enter a
+              # transaction that they maybe don't want to incur the overhead
+              # of, so just yield.
+              yield
+            end
           else
             locked
           end
         ensure
-          self[UNLOCK_SQL, int, key].get if locked
+          sql = "SELECT pg_advisory_unlock#{'_shared' if shared}(?) -- ?"
+          self[sql, int, key].get if locked
         end
       end
     end
+
+    def advisory_lock_key(key)
+      case key
+      when Integer
+        advisory_lock_key_range_check(key)
+      when String, Symbol
+        # For an arbitrary string, pseudorandomly return an integer in
+        # the PG bigint range.
+        hex = Digest::MD5.hexdigest(key.to_s)[HEX_STRING_SLICE_RANGE].hex
+
+        # Mimic PG's bigint rollover behavior.
+        hex -= POSTGRES_UNSIGNED_BIGINT_BOUND if hex >= POSTGRES_SIGNED_BIGINT_BOUND
+
+        # The keys we derive from strings shouldn't ever fall outside the
+        # bigint range, but assert that just to be safe.
+        advisory_lock_key_range_check(hex)
+      else
+        raise Error, "passed an invalid key type (#{key.class})"
+      end
+    end
+
+    private
+
+    def advisory_lock_key_range_check(integer)
+      if POSTGRES_SIGNED_BIGINT_RANGE.cover?(integer)
+        integer
+      else
+        raise Error, "given advisory lock integer (#{integer}) falls outside Postgres' bigint range"
+      end
+    end
   end
 
-  Database.register_extension(:advisory_locking){|db| db.extend(Sequel::AdvisoryLocking)}
+  Database.register_extension(:advisory_locking) { |db| db.extend(Sequel::AdvisoryLocking) }
 end

data/lib/sequel/extensions/advisory_locking/version.rb

@@ -2,6 +2,6 @@
 
 module Sequel
   module AdvisoryLocking
-    VERSION = '0.0.1'
+    VERSION = '0.1.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-advisory-locking
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-29 00:00:00.000000000 Z
+date: 2016-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler