record-cache 0.1.4 → 0.1.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzM5MTA3YWI2MTRjMDIwMGFmN2FhYzQxZmNlMWU2ZTNiNTkzODkyMQ==
+    MDI2NWVjM2RkZjhjMmFkMmU2M2VhMTFlN2VmZTgwZDM5YmJhYWRjMA==
   data.tar.gz: !binary |-
-    MGYzNGU3NzVlZTI4YTMwZTM5NDhkZDVjZGVjY2UyODJlMWU1YzIzMQ==
+    ZmI3NDhhNzE0ZTcwZmZjNzZiNDhhMzg1Mjk2MDlkMjc1Njc0Zjg1NA==
 SHA512:
   metadata.gz: !binary |-
-    MzQxNDM1ZWQxMmUzYmQyNzZhZjZmNDA2MmQzZWViMWYwZDhlMzI0YTczYjY4
-    ZmE4ZDZkNjBkMjc3YjUxNGM1YjJhMDlkNzkwZDRlNGM0MTBlMTUzMTBmZThm
-    MDg1NWNjMzZhOGE3OWIxMjc0ODg5YzZmYjY1MmY5MWRkNWFhMDc=
+    OTdiNmIzNWMwMTk5ODQ3ZDUyNWJiYTc5NGM2NDI0OWI0YzdkYTZkM2UzYmNk
+    ZjIxYTBkNzBlYWI1M2EwYTU2YTlkYTA0ZTNjZTEwMmY3YmQ0YmFkMWU4MjMz
+    MDUyYjE1OWYxNDM3YzQ3ZGRlZjZhMjBkODUzZjNmNzUyNzRmNjA=
   data.tar.gz: !binary |-
-    ZDA2OTRjOTZkODFhMTdiNGU3M2IzZDZiYTljNTViZTdjZGQ2ZjRjODNmY2Ew
-    MzA4OTgwYmMyNTE2YzRlZDI4Yjg1MjhiMGFlNTdmYzFmNWZlYWZiYmJlZDc0
-    YzMzODM2Y2UyNDIzYjQyNzAwMWY0NWIxZWI0ZjBkNDJlNDVkMTQ=
+    MGRkZjIwZGVhNTgzNjU0NmFlMWQyOGRiMzZkZTY5MmU4MDlhM2VlZWYwNTQ3
+    NmY3NzliYjM1ZWE1NjI1Yzg1YTc2ZjVkNzY5OGE2MjFlZmNiODMxNDBiNWVk
+    YjYxYTU2YWFlZDQ3MjhlMGFjZTdlYjM5NjBkY2YyNjEzMjY1ZGE=

data/lib/record_cache/datastore/active_record_40.rb

@@ -399,6 +399,7 @@ module RecordCache
 
       module InstanceMethods
         def delete_records_with_record_cache(records, method)
+          records = load_target if records == :all
           # invalidate :id cache for all records
           records.each{ |record| record.class.record_cache.invalidate(record.id) if record.class.record_cache? unless record.new_record? }
           # invalidate the referenced class for the attribute/value pair on the index cache

data/lib/record_cache/strategy/full_table_cache.rb

@@ -36,7 +36,7 @@ module RecordCache
         # no records found?
         unless records
           # renew the version in case the version was not known
-          current_version ||= version_store.renew(key, version_opts)
+          current_version ||= version_store.renew_for_read(key, version_opts)
           # retrieve all records from the DB
           records = from_db(key, current_version)
         end

data/lib/record_cache/strategy/index_cache.rb

@@ -54,7 +54,7 @@ module RecordCache
         # retrieve the current version of the ids list
         current_version = version_store.current(key)
         # create the versioned key, renew the version in case it was missing in the version store
-        versioned_key = versioned_key(key, current_version || version_store.renew(key, version_opts))
+        versioned_key = versioned_key(key, current_version || version_store.renew_for_read(key, version_opts))
         # retrieve the ids from the local cache based on the current version from the version store
         ids = current_version ? fetch_ids_from_cache(versioned_key) : nil
         # logging (only in debug mode!) and statistics

data/lib/record_cache/strategy/unique_index_cache.rb

@@ -104,7 +104,7 @@ module RecordCache
                 unless versioned_key
                   # renew the key in the version store in case it was missing
                   key = id_to_key_map[record.send(@attribute)]
-                  versioned_key = versioned_key(key, version_store.renew(key, version_opts))
+                  versioned_key = versioned_key(key, version_store.renew_for_read(key, version_opts))
                 end
                 # store the record based on the versioned key
                 record_store.write(versioned_key, Util.serialize(record))

data/lib/record_cache/strategy/util.rb

@@ -17,7 +17,7 @@ module RecordCache
         # deserialize a cached record
         def deserialize(serialized)
           record = serialized[CLASS_KEY].constantize.allocate
-          attributes = serialized[ATTRIBUTES_KEY]
+          attributes = serialized[ATTRIBUTES_KEY].clone
           record.class.serialized_attributes.keys.each do |attribute|
             if attributes[attribute].respond_to?(:unserialize)
               if attributes[attribute].method(:unserialize).arity > 0

data/lib/record_cache/test/resettable_version_store.rb

@@ -20,9 +20,9 @@ module RecordCache
 
       module InstanceMethods
 
-        def renew_with_reset(key, opts = {})
+        def renew_with_reset(key, write = true, opts = {})
           updated_version_keys << key
-          renew_without_reset(key, opts)
+          renew_without_reset(key, write, opts)
         end
 
         def reset!

data/lib/record_cache/version.rb

@@ -1,5 +1,5 @@
 module RecordCache # :nodoc:
   module Version # :nodoc:
-    STRING = '0.1.4'
+    STRING = '0.1.5'
   end
 end

data/lib/record_cache/version_store.rb

@@ -9,6 +9,10 @@ module RecordCache
       @store = store
     end
 
+    def on_write_failure(&blk)
+      @on_write_failure = blk
+    end
+
     # Retrieve the current versions for the given key
     # @return nil in case the key is not known in the version store
     def current(key)
@@ -24,11 +28,16 @@ module RecordCache
       Hash[id_key_map.map{ |id, key| [id, current_versions[key]] }]
     end
 
+    def renew_for_read(key, options = {})
+      renew(key, false, options)
+    end
+
     # Call this method to reset the key to a new (unique) version
-    def renew(key, options = {})
+    def renew(key, write = true, options = {})
       new_version = (Time.current.to_f * 10000).to_i
       seconds = options[:ttl] ? options[:ttl] + (rand(options[:ttl] / 2) * [1, -1].sample) : nil
-      @store.write(key, new_version, {:expires_in => seconds})
+      written = @store.write(key, new_version, {:expires_in => seconds})
+      @on_write_failure.call(key) if !written && write && @on_write_failure
       RecordCache::Base.logger.debug{ "Version Store: renew #{key}: nil => #{new_version}" }
       new_version
     end
@@ -47,12 +56,13 @@ module RecordCache
     # @deprecated: use renew instead
     def increment(key)
       RecordCache::Base.logger.debug{ "increment is deprecated, use renew instead. Called from: #{caller[0]}" }
-      renew(key)
+      renew(key, true)
     end
 
     # Delete key from the version store (records cached in the Record Store belonging to this key will become unreachable)
     def delete(key)
       deleted = @store.delete(key)
+      @on_write_failure.call(key) if !deleted && @on_write_failure
       RecordCache::Base.logger.debug{ "Version Store: deleted #{key}" }
       deleted
     end

data/spec/lib/version_store_spec.rb

@@ -49,7 +49,30 @@ RSpec.describe RecordCache::VersionStore do
       @version_store.renew("unknown_key")
       expect(@version_store.current("unknown_key")).to_not be_nil
     end
-    
+
+    it "should call on_write_failure hook when renew fails" do
+      allow(@version_store.store).to receive(:write) { false }
+      failed = nil
+      @version_store.on_write_failure{ |key| failed = key }
+      @version_store.renew("key1")
+      expect(failed).to eq("key1")
+    end
+
+    it "should not call on_write_failure hook when renew_for_read fails" do
+      allow(@version_store.store).to receive(:write) { false }
+      failed = "nothing failed"
+      @version_store.on_write_failure{ |key| failed = key }
+      @version_store.renew_for_read("key1")
+      expect(failed).to eq("nothing failed")
+    end
+
+    it "should not call on_write_failure hook when renew succeeds" do
+      failed = "nothing failed"
+      @version_store.on_write_failure{ |key| failed = key }
+      @version_store.renew("key1")
+      expect(failed).to eq("nothing failed")
+    end
+
     it "should write to the debug log" do
       expect{ @version_store.renew("key1") }.to log(:debug, /Version Store: renew key1: nil => \d+/)
     end
@@ -77,6 +100,21 @@ RSpec.describe RecordCache::VersionStore do
       expect(@version_store.current("unknown_key")).to be_nil
     end
 
+    it "should call on_write_failure hook when delete fails" do
+      allow(@version_store.store).to receive(:delete) { false }
+      failed = nil
+      @version_store.on_write_failure{ |key| failed = key }
+      @version_store.delete("key1")
+      expect(failed).to eq("key1")
+    end
+
+    it "should not call on_write_failure hook when delete succeeds" do
+      failed = "nothing failed"
+      @version_store.on_write_failure{ |key| failed = key }
+      @version_store.delete("key1")
+      expect(failed).to eq("nothing failed")
+    end
+
     it "should write to the debug log" do
       expect{ @version_store.delete("key1") }.to log(:debug, %(Version Store: deleted key1))
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: record-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Orslumen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-12 00:00:00.000000000 Z
+date: 2015-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -260,7 +260,7 @@ rubyforge_project:
 rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
-summary: Record Cache v0.1.4 transparantly stores Records in a Cache Store and retrieve
+summary: Record Cache v0.1.5 transparantly stores Records in a Cache Store and retrieve
   those Records from the store when queried using Active Model.
 test_files:
 - spec/db/create-record-cache-db_and_user.sql