lock_and_cache 4.0.6 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 486140a35280062778f6f70680406c74798a8a68
-  data.tar.gz: 262bc8de8f1990818ed04b4e964fe46c4366256a
+  metadata.gz: 186a1eea8f6cc7f0d72ed2ccd5cc1c8f19f3c605
+  data.tar.gz: 80d956322883072ea8e23f58df3710bc0bc6571c
 SHA512:
-  metadata.gz: caf0ac825c8b69ce6d15f4af75aa1f6a7a8e0902184c80dafb04a0de1b9dcebf05ec6018b75c27d4b845cc7d7f5e00f3ca48c7daee1c6a5edb90078561638058
-  data.tar.gz: 77ed0de21b2fafbc9c36b50ce5b390e1d8090c4c1956c079f83ef6fd6a26d3d1db7c71ead492c06328d9c68808706807f377de1ec92651cea8d3fe08e3a521b0
+  metadata.gz: ff3c3bde1ab6eddc04217ee3c64d1877d75f19c24155a110cae23d5019468cae2bf7fc58e695ab5627277c1087c49aaf18f2cf952b109c375eeeaf122738fabf
+  data.tar.gz: af5b4021a8d5e5e8ab6fbc7fe80464f9f6d0e2e1ddeeb5f7a97371406414000d464b574a0a01813f9a0b3d11bdb105c0730aa1fe8ffd9861bd9af6297f879378

data/CHANGELOG

@@ -1,3 +1,10 @@
+5.0.0
+
+* Enhancements / breaking changes
+
+  * Propagate errors to all waiters up to 1 second after the error
+  * Stop using redlock, just use plain single-node Redis locking
+
 4.0.6
 
 * ?

data/README.md

@@ -27,9 +27,9 @@ end
 
 ## Sponsor
 
-<p><a href="http://faraday.io"><img src="http://cdn2.hubspot.net/hubfs/515497/img/logo.svg" alt="Faraday logo"/></a></p>
+<p><a href="https://www.faraday.io"><img src="https://s3.amazonaws.com/faraday-assets/files/img/logo.svg" alt="Faraday logo"/></a></p>
 
-We use [`lock_and_cache`](https://github.com/seamusabshere/lock_and_cache) for [data-driven marketing at Faraday](http://faraday.io).
+We use [`lock_and_cache`](https://github.com/seamusabshere/lock_and_cache) for [B2C customer intelligence at Faraday](https://www.faraday.io).
 
 ## TOC
 
@@ -70,6 +70,8 @@ We use [`lock_and_cache`](https://github.com/seamusabshere/lock_and_cache) for [
 
 As you can see, most caching libraries only take care of (1) and (4) (well, and (5) of course).
 
+If an error is raised during calculation, that error is propagated to all waiters for 1 second.
+
 ## Practice
 
 ### Setup
@@ -82,9 +84,9 @@ It will use this redis for both locking and storing cached values.
 
 ### Locking
 
-Based on [antirez's Redlock algorithm](http://redis.io/topics/distlock).
+Just uses Redis naive locking with NX.
 
-Above and beyond Redlock, a 32-second heartbeat is used that will clear the lock if a process is killed. This is implemented using lock extensions.
+A 32-second heartbeat is used that will clear the lock if a process is killed.
 
 ### Caching
 
@@ -189,7 +191,7 @@ Most caching libraries don't do locking, meaning that >1 process can be calculat
 
 ### Heartbeat
 
-If the process holding the lock dies, we automatically remove the lock so somebody else can do it (using heartbeats and redlock extends).
+If the process holding the lock dies, we automatically remove the lock so somebody else can do it (using heartbeats).
 
 ### Context mode
 
@@ -210,7 +212,6 @@ You can expire nil values with a different timeout (`nil_expires`) than other va
 
 * [activesupport](https://rubygems.org/gems/activesupport) (come on, it's the bomb)
 * [redis](https://github.com/redis/redis-rb)
-* [redlock](https://github.com/leandromoreira/redlock-rb)
 
 ## Known issues
 

data/lib/lock_and_cache.rb

@@ -3,7 +3,6 @@ require 'timeout'
 require 'digest/sha1'
 require 'base64'
 require 'redis'
-require 'redlock'
 require 'active_support'
 require 'active_support/core_ext'
 
@@ -25,7 +24,6 @@ module LockAndCache
   def LockAndCache.storage=(redis_connection)
     raise "only redis for now" unless redis_connection.class.to_s == 'Redis'
     @storage = redis_connection
-    @lock_manager = Redlock::Client.new [redis_connection], retry_count: 1
   end
 
   # @return [Redis] The redis connection used for lock and cached value storage
@@ -117,11 +115,6 @@ module LockAndCache
     @heartbeat_expires || DEFAULT_HEARTBEAT_EXPIRES
   end
 
-  # @private
-  def LockAndCache.lock_manager
-    @lock_manager
-  end
-
   # Check if a method is locked on an object.
   #
   # @note Subject mode - this is expected to be called on an object whose class has LockAndCache mixed in. See also standalone mode.

data/lib/lock_and_cache/action.rb

@@ -1,6 +1,8 @@
 module LockAndCache
   # @private
   class Action
+    ERROR_MAGIC_KEY = :lock_and_cache_error
+
     attr_reader :key
     attr_reader :options
     attr_reader :blk
@@ -34,6 +36,15 @@ module LockAndCache
       @storage ||= LockAndCache.storage or raise("must set LockAndCache.storage=[Redis]")
     end
 
+    def load_existing(existing)
+      v = ::Marshal.load(existing)
+      if v.is_a?(::Hash) and (founderr = v[ERROR_MAGIC_KEY])
+        raise "Another LockAndCache process raised #{founderr}"
+      else
+        v
+      end
+    end
+
     def perform
       max_lock_wait = options.fetch 'max_lock_wait', LockAndCache.max_lock_wait
       heartbeat_expires = options.fetch('heartbeat_expires', LockAndCache.heartbeat_expires).to_f.ceil
@@ -41,23 +52,24 @@ module LockAndCache
       heartbeat_frequency = (heartbeat_expires / 2).ceil
       LockAndCache.logger.debug { "[lock_and_cache] A1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
       if storage.exists(digest) and (existing = storage.get(digest)).is_a?(String)
-        return ::Marshal.load(existing)
+        return load_existing(existing)
       end
       LockAndCache.logger.debug { "[lock_and_cache] B1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
       retval = nil
-      lock_manager = LockAndCache.lock_manager
-      lock_info = nil
+      lock_secret = SecureRandom.hex 16
+      acquired = false
       begin
         Timeout.timeout(max_lock_wait, TimeoutWaitingForLock) do
-          until lock_info = lock_manager.lock(lock_digest, heartbeat_expires*1000)
+          until storage.set(lock_digest, lock_secret, nx: true, ex: heartbeat_expires)
             LockAndCache.logger.debug { "[lock_and_cache] C1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
             sleep rand
           end
+          acquired = true
         end
         LockAndCache.logger.debug { "[lock_and_cache] D1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
         if storage.exists(digest) and (existing = storage.get(digest)).is_a?(String)
           LockAndCache.logger.debug { "[lock_and_cache] E1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
-          retval = ::Marshal.load existing
+          retval = load_existing existing
         end
         unless retval
           LockAndCache.logger.debug { "[lock_and_cache] F1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
@@ -70,28 +82,39 @@ module LockAndCache
                 sleep heartbeat_frequency
                 break if done
                 LockAndCache.logger.debug { "[lock_and_cache] heartbeat2 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
-                lock_manager.lock lock_digest, heartbeat_expires*1000, extend: lock_info
+                # FIXME use lua to check the value
+                raise "unexpectedly lost lock for #{key.debug}" unless storage.get(lock_digest) == lock_secret
+                storage.set lock_digest, lock_secret, xx: true, ex: heartbeat_expires
               end
             end
-            retval = blk.call
-            retval.nil? ? set_nil : set_non_nil(retval)
+            begin
+              retval = blk.call
+              retval.nil? ? set_nil : set_non_nil(retval)
+            rescue
+              set_error $!
+              raise
+            end
           ensure
             done = true
             lock_extender.join if lock_extender.status.nil?
           end
         end
       ensure
-        lock_manager.unlock lock_info if lock_info
+        storage.del lock_digest if acquired
       end
       retval
     end
 
+    def set_error(exception)
+      storage.set digest, ::Marshal.dump(ERROR_MAGIC_KEY => exception.message), ex: 1
+    end
+
     NIL = Marshal.dump nil
     def set_nil
       if nil_expires
-        storage.setex digest, nil_expires, NIL
+        storage.set digest, NIL, ex: nil_expires
       elsif expires
-        storage.setex digest, expires, NIL
+        storage.set digest, NIL, ex: expires
       else
         storage.set digest, NIL
       end
@@ -100,7 +123,7 @@ module LockAndCache
     def set_non_nil(retval)
       raise "expected not null #{retval.inspect}" if retval.nil?
       if expires
-        storage.setex digest, expires, ::Marshal.dump(retval)
+        storage.set digest, ::Marshal.dump(retval), ex: expires
       else
         storage.set digest, ::Marshal.dump(retval)
       end

data/lib/lock_and_cache/version.rb

@@ -1,3 +1,3 @@
 module LockAndCache
-  VERSION = '4.0.6'
+  VERSION = '5.0.0'
 end

data/lock_and_cache.gemspec

@@ -20,8 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'activesupport'
   spec.add_runtime_dependency 'redis'
-  # temporary until https://github.com/leandromoreira/redlock-rb/pull/20 is merged
-  spec.add_runtime_dependency 'redlock', '>=0.1.3'
 
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'bundler', '~> 1.6'

data/spec/lock_and_cache_spec.rb

@@ -337,6 +337,28 @@ describe LockAndCache do
       expect(count).to eq(1)
     end
 
+    it 'really caches' do
+      expect(LockAndCache.lock_and_cache('hello') { :red }).to eq(:red)
+      expect(LockAndCache.lock_and_cache('hello') { raise(Exception.new("stop")) }).to eq(:red)
+    end
+
+    it 'caches errors (briefly)' do
+      count = 0
+      expect {
+        LockAndCache.lock_and_cache('hello') { count += 1; raise("stop") }
+      }.to raise_error(/stop/)
+      expect(count).to eq(1)
+      expect {
+        LockAndCache.lock_and_cache('hello') { count += 1; raise("no no not me") }
+      }.to raise_error(/LockAndCache.*stop/)
+      expect(count).to eq(1)
+      sleep 1
+      expect {
+        LockAndCache.lock_and_cache('hello') { count += 1; raise("retrying") }
+      }.to raise_error(/retrying/)
+      expect(count).to eq(2)
+    end
+
     it "can be queried for cached?" do
       expect(LockAndCache.cached?('hello')).to be_falsy
       LockAndCache.lock_and_cache('hello') { nil }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lock_and_cache
 version: !ruby/object:Gem::Version
-  version: 4.0.6
+  version: 5.0.0
 platform: ruby
 authors:
 - Seamus Abshere
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-26 00:00:00.000000000 Z
+date: 2018-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: redlock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -196,7 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Lock and cache methods.