lock_and_cache 3.0.1 → 4.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49f75de7ca663703123c5a93b4c03960ce20449e
-  data.tar.gz: e6f260e217549f32b4ce54b8e8fe03adbc27078e
+  metadata.gz: 4a3eaf745d9a9532d2062ea332fb63420fabbdd9
+  data.tar.gz: d1f4ec88da5e0f728da43d9b2f40d536c4224498
 SHA512:
-  metadata.gz: 6a027a15e0ec3c8918f9825d57a97f059a93a91bf43d2aefd32d7cd0cedf6eb223fddfd0df006e652824e927573a6cba408bd4f22bbd2c2ce7fb1345377ca985
-  data.tar.gz: 4ebe3e917a13f182e04a5e10fc19c58d109db200e2ac42bb1cb4078c1122eda2bd331836a3540ff794ba4987f326d33a8792b974fd26c0ac27ad9312a23ff9ca
+  metadata.gz: f34529d617b048841b0d33234619846f49a7367ff5627e653298098f0780401314f37df6aa9afe73d967ad358eeaffc3fd0d70ccbc043ecb6a8c1b360c2b61f7
+  data.tar.gz: d006e7f9e798425f6137d5611c3688b3e78fd906e15390ad0ff015f0834f3fd3e9a4d820c4ca546fa606f17f9ea481296d7f444dc0189cb48b4e368643251648

data/CHANGELOG

@@ -1,3 +1,33 @@
+4.0.4 / 2016-04-11
+
+* Bug fixes
+
+  * Don't default to debug logging
+
+4.0.3 / 2016-04-11
+
+* Bug fixes
+
+  * Allow true or false in keys
+
+4.0.2 / 2016-04-11
+
+* Bug fixes
+
+  * When generating key, recurse into #lock_and_cache_key
+
+4.0.1 / 2016-04-11
+
+* Bug fixes
+
+  * Avoid deadlocks related to logging
+
+4.0.0 / 2016-04-11
+
+* Breaking changes
+
+  * The cache key generation I've always wanted: recursively call #id or #lock_and_cache_key
+
 3.0.1 / 2016-04-04
 
 * Enhancements

data/README.md

@@ -212,10 +212,13 @@ You can expire nil values with a different timeout (`nil_expires`) than other va
 * [redis](https://github.com/redis/redis-rb)
 * [redlock](https://github.com/leandromoreira/redlock-rb)
 
+## Known issues
+
+* In cache keys, can't distinguish {a: 1} from [[:a, 1]]
+
 ## Wishlist
 
 * Convert most tests to use standalone mode, which is easier to understand
-* Make explicit Key unit tests
 * Check options
 * Lengthen heartbeat so it's not so sensitive
 * Clarify which options are seconds or milliseconds

data/lib/lock_and_cache.rb

@@ -1,3 +1,4 @@
+require 'logger'
 require 'timeout'
 require 'digest/sha1'
 require 'base64'
@@ -18,8 +19,6 @@ module LockAndCache
 
   DEFAULT_HEARTBEAT_EXPIRES = 32 # 32 seconds
 
-  LOG_MUTEX = Mutex.new
-
   class TimeoutWaitingForLock < StandardError; end
 
   # @param redis_connection [Redis] A redis connection to be used for lock and cached value storage
@@ -34,6 +33,16 @@ module LockAndCache
     @storage
   end
 
+  # @param logger [Logger] A logger.
+  def LockAndCache.logger=(logger)
+    @logger = logger
+  end
+
+  # @return [Logger] The logger.
+  def LockAndCache.logger
+    @logger
+  end
+
   # Flush LockAndCache's storage.
   #
   # @note If you are sharing a redis database, it will clear it...
@@ -139,3 +148,7 @@ module LockAndCache
     action.perform
   end
 end
+
+logger = Logger.new $stderr
+logger.level = (ENV['LOCK_AND_CACHE_DEBUG'] == 'true') ? Logger::DEBUG : Logger::INFO
+LockAndCache.logger = logger

data/lib/lock_and_cache/action.rb

@@ -35,42 +35,41 @@ module LockAndCache
     end
 
     def perform
-      debug = (ENV['LOCK_AND_CACHE_DEBUG'] == 'true')
       max_lock_wait = options.fetch 'max_lock_wait', LockAndCache.max_lock_wait
       heartbeat_expires = options.fetch('heartbeat_expires', LockAndCache.heartbeat_expires).to_f.ceil
       raise "heartbeat_expires must be >= 2 seconds" unless heartbeat_expires >= 2
       heartbeat_frequency = (heartbeat_expires / 2).ceil
-      LockAndCache::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] A1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if debug
+      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)
       end
-      LockAndCache::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] B1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if debug
+      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
       begin
         Timeout.timeout(max_lock_wait, TimeoutWaitingForLock) do
           until lock_info = lock_manager.lock(lock_digest, heartbeat_expires*1000)
-            LockAndCache::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] C1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if debug
+            LockAndCache.logger.debug { "[lock_and_cache] C1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
             sleep rand
           end
         end
-        LockAndCache::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] D1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if debug
+        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::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] E1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if debug
+          LockAndCache.logger.debug { "[lock_and_cache] E1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
           retval = ::Marshal.load existing
         end
         unless retval
-          LockAndCache::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] F1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if debug
+          LockAndCache.logger.debug { "[lock_and_cache] F1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
           done = false
           begin
             lock_extender = Thread.new do
               loop do
-                LockAndCache::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] heartbeat1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if debug
+                LockAndCache.logger.debug { "[lock_and_cache] heartbeat1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
                 break if done
                 sleep heartbeat_frequency
                 break if done
-                LockAndCache::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] heartbeat2 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if debug
+                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
               end
             end

data/lib/lock_and_cache/key.rb

@@ -20,20 +20,30 @@ module LockAndCache
 
       # @private
       #
-      # Extract id from context. Calls #lock_and_cache_key if available, otherwise #id
-      def extract_context_id(context)
-        if context.class == ::Class
-          nil
-        elsif context.respond_to?(:lock_and_cache_key)
-          context.lock_and_cache_key
-        elsif context.respond_to?(:id)
-          context.id
+      # Recursively extract id from obj. Calls #lock_and_cache_key if available, otherwise #id
+      def extract_obj_id(obj)
+        if ALLOWED_IN_KEYS.any? { |k| obj.is_a?(k) }
+          obj
+        elsif obj.respond_to?(:lock_and_cache_key)
+          extract_obj_id obj.lock_and_cache_key
+        elsif obj.respond_to?(:id)
+          extract_obj_id obj.id
+        elsif obj.respond_to?(:map)
+          obj.map { |objj| extract_obj_id objj }
         else
-          raise "#{context} must respond to #lock_and_cache_key or #id"
+          raise "#{obj.inspect} must respond to #lock_and_cache_key or #id"
         end
       end
     end
 
+    ALLOWED_IN_KEYS = [
+      ::String,
+      ::Symbol,
+      ::Numeric,
+      ::TrueClass,
+      ::FalseClass,
+      ::NilClass,
+    ]
     METHOD_NAME_IN_CALLER = /in `([^']+)'/
 
     attr_reader :context
@@ -75,7 +85,7 @@ module LockAndCache
     end
 
     def clear
-      LockAndCache::LOG_MUTEX.synchronize { $stderr.puts "[lock_and_cache] clear #{debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" } if ENV['LOCK_AND_CACHE_DEBUG'] == 'true'
+      LockAndCache.logger.debug { "[lock_and_cache] clear #{debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
       storage = LockAndCache.storage
       storage.del digest
       storage.del lock_digest
@@ -84,7 +94,12 @@ module LockAndCache
     alias debug key
 
     def context_id
-      @context_id ||= Key.extract_context_id context
+      return @context_id if defined?(@context_id)
+      @context_id = if context.class == ::Class
+        nil
+      else
+        Key.extract_obj_id context
+      end
     end
 
     def class_name
@@ -93,14 +108,7 @@ module LockAndCache
 
     # An array of the parts we use for the key
     def parts
-      @parts ||= @_parts.map do |v|
-        case v
-        when ::String, ::Symbol, ::Hash, ::Array
-          v
-        else
-          v.respond_to?(:lock_and_cache_key) ? v.lock_and_cache_key : v.id
-        end
-      end
+      @parts ||= Key.extract_obj_id @_parts
     end
   end
 end

data/lib/lock_and_cache/version.rb

@@ -1,3 +1,3 @@
 module LockAndCache
-  VERSION = '3.0.1'
+  VERSION = '4.0.4'
 end

data/spec/lock_and_cache/key_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+class KeyTestId
+  def id
+    'id'
+  end
+end
+class KeyTestLockAndCacheKey
+  def lock_and_cache_key
+    'lock_and_cache_key'
+  end
+end
+class KeyTest1
+  def lock_and_cache_key
+    KeyTestLockAndCacheKey.new
+  end
+end
+describe LockAndCache::Key do
+  describe 'parts' do
+    it "has a known issue differentiating between {a: 1} and [[:a, 1]]" do
+      expect(described_class.new(a: 1).send(:parts)).to eq(described_class.new([[:a, 1]]).send(:parts))
+    end
+    
+    {
+      [1]                                                => [1],
+      ["you"]                                            => ['you'],
+      [["you"]]                                          => [['you']],
+      [["you"], "person"]                                => [["you"], "person"],
+      [["you"], {:silly=>:person}]                       => [["you"], [[:silly, :person]] ],
+      { hi: 'you' }                                      => [[:hi, "you"]],
+      [KeyTestId.new]                                    => ['id'],
+      [[KeyTestId.new]]                                  => [['id']],
+      { a: KeyTestId.new }                               => [[:a, "id"]],
+      [{ a: KeyTestId.new }]                             => [[[:a, "id"]]],
+      [[{ a: KeyTestId.new }]]                           => [[ [[:a, "id"]] ]],
+      [[{ a: [ KeyTestId.new ] }]]                       => [[[[:a, ["id"]]]]],
+      [[{ a: { b: KeyTestId.new } }]]                    => [[ [[ :a, [[:b, "id"]] ]] ]],
+      [[{ a: { b: [ KeyTestId.new ] } }]]                => [[ [[ :a, [[:b, ["id"]]] ]] ]],
+      [KeyTestLockAndCacheKey.new]                       => ['lock_and_cache_key'],
+      [[KeyTestLockAndCacheKey.new]]                     => [['lock_and_cache_key']],
+      { a: KeyTestLockAndCacheKey.new }                  => [[:a, "lock_and_cache_key"]],
+      [{ a: KeyTestLockAndCacheKey.new }]                => [[[:a, "lock_and_cache_key"]]],
+      [[{ a: KeyTestLockAndCacheKey.new }]]              => [[ [[:a, "lock_and_cache_key"]] ]],
+      [[{ a: [ KeyTestLockAndCacheKey.new ] }]]          => [[[[:a, ["lock_and_cache_key"]]]]],
+      [[{ a: { b: KeyTestLockAndCacheKey.new } }]]       => [[ [[ :a, [[:b, "lock_and_cache_key"]] ]] ]],
+      [[{ a: { b: [ KeyTestLockAndCacheKey.new ] } }]]   => [[ [[ :a, [[:b, ["lock_and_cache_key"]]] ]] ]],
+
+      [[{ a: { b: [ KeyTest1.new ] } }]]   => [[ [[ :a, [[:b, ["lock_and_cache_key"]]] ]] ]],
+    }.each do |i, o|
+      it "turns #{i} into #{o}" do
+        expect(described_class.new(i).send(:parts)).to eq(o)
+      end
+    end
+  end
+end

data/spec/lock_and_cache_spec.rb

@@ -88,10 +88,11 @@ class Bar
   def initialize(id)
     @id = id
     @count = 0
+    @mutex = Mutex.new
   end
 
   def unsafe_click
-    LockAndCache::LOG_MUTEX.synchronize do
+    @mutex.synchronize do
       # puts "clicking bar #{@id} - #{$clicking.to_a} - #{$clicking.include?(@id)} - #{@id == $clicking.to_a[0]}"
       raise "somebody already clicking Bar #{@id}" if $clicking.include?(@id)
       $clicking << @id

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lock_and_cache
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 4.0.4
 platform: ruby
 authors:
 - Seamus Abshere
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-04 00:00:00.000000000 Z
+date: 2016-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -172,6 +172,7 @@ files:
 - lib/lock_and_cache/key.rb
 - lib/lock_and_cache/version.rb
 - lock_and_cache.gemspec
+- spec/lock_and_cache/key_spec.rb
 - spec/lock_and_cache_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/seamusabshere/lock_and_cache
@@ -199,6 +200,7 @@ signing_key:
 specification_version: 4
 summary: Lock and cache methods.
 test_files:
+- spec/lock_and_cache/key_spec.rb
 - spec/lock_and_cache_spec.rb
 - spec/spec_helper.rb
 has_rdoc: