redcache 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 793fd19a398f38a5bcdc992bc217569fd2b9a198
-  data.tar.gz: 68e67159b66834a941ae9d98b4f924237f29c74c
+  metadata.gz: b9134505b631ba6721ae691c4a9031dd3e62a551
+  data.tar.gz: f4a352cc66f24de9d52b8907f62b96d4aa413e91
 SHA512:
-  metadata.gz: d0311ccbaf060b02bc5690426b7157779d3956aa0dd1ab9d2dca0ed58631011f9f6391300b8bee4767fc7c15482b2800db4e4afd572ddb68db253931d2f1a74c
-  data.tar.gz: 11b2359e537853933c9dfd3502e5365e3d80801581f72572d2e00b611acdba9c510018e023bf2c67d8218769a184d916e5e502135f435667daa06890ec277213
+  metadata.gz: 04bb02ff0a7e38f07ccd7741edd113c0eb7e7b4c3c6cd10d2405a1ea03261caad59e6d7bacfa48b7b8a2a7c5cf242ef59673faee1d004657bbf08d8dfb6ac9dc
+  data.tar.gz: c1ff6af3a7bc067f2844440e4a33876d2a88f9d6c472caad29a78b3dfe3c01770e272c4038f0b4e740713eee162d442fe34d72d151d7c7a1f37ea94e018e85a8

data/lib/redcache/configuration.rb

@@ -6,6 +6,7 @@ module Redcache
     attr_accessor :stale_time
     attr_accessor :encrypt
     attr_accessor :skip_cache
+    attr_accessor :silent
     attr_accessor :logger
     attr_accessor :log_prefix
 
@@ -15,6 +16,7 @@ module Redcache
       @encrypt = false
       @secret = nil
       @skip_cache = false
+      @silent = false
       @logger = nil
       @log_prefix = "redcache"
     end

data/lib/redcache/version.rb

@@ -1,3 +1,3 @@
 module Redcache
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/redcache.rb

@@ -1,6 +1,11 @@
 require "redcache/version"
+require "fernet"
 require "redcache/configuration"
 
+Fernet::Configuration.run do |config|
+  config.enforce_ttl = false
+end
+
 module Redcache
   class << self
     attr_writer :configuration
@@ -10,15 +15,67 @@ module Redcache
     end
 
     def cache(redis_key, &block)
-      return block.call if skip_cache?
-      if redis_up?
-        value = read_from_cache(redis_key, block) || write_into_cache(redis_key, block)
-        return value unless value.nil?
-      else
-        block.call
+      # return immediately if we shouldn't or can't cache
+      return block.call if skip_cache? || !redis_up?
+      with_redis do
+        # attempt to read from cache, running and caching the block if cold
+        value = read_from_cache(redis_key, block)
+        if value.nil?
+          value = block.call if value.nil?
+          write_into_cache(redis_key, value)
+        end
+        return value
+      end
+    end
+
+    def read_from_cache(redis_key, block)
+      value = get_value(redis_key)
+      value.nil? ? log("cache.miss", redis_key) : log("cache.hit", redis_key)
+      refresh_cache(redis_key, block) if key_stale?(redis_key) && !value.nil?
+      return value
+    end
+
+    def refresh_cache(redis_key, block)
+      log("cache.stale_refresh", redis_key)
+      Thread.new do
+        write_into_cache(redis_key, block.call)
       end
     end
 
+    def write_into_cache(redis_key, value)
+      with_redis do
+        log("cache.write", redis_key)
+        set_value(redis_key, value)
+      end
+      value
+    end
+
+    def get_value(key)
+      decrypt redis.get(key)
+    end
+
+    def set_value(key, value)
+      redis.setex key, configuration.cache_time, encrypt(value)
+    end
+
+    def key_stale?(redis_key)
+      ttl = redis.ttl(redis_key)
+      return  ttl < (configuration.cache_time - configuration.stale_time)
+    end
+
+    def encrypt(value)
+      return prep_value(value) unless encrypt?
+      fernet.generate(secret, prep_value(value))
+    end
+
+    def decrypt(value)
+      return nil if value.nil?
+      return value unless encrypt?
+      verifier = fernet.verifier(secret, value)
+      return MultiJson.load(verifier.message) if verifier.valid?
+      return nil
+    end
+
     def configuration
       @configuration ||= Configuration.new
     end
@@ -53,73 +110,32 @@ module Redcache
       configuration.skip_cache
     end
 
-    def read_from_cache(redis_key, block)
-      value = get_value(redis_key)
-      value.nil? ? log("cache.miss", redis_key) : log("cache.hit", redis_key)
-      refresh_cache(redis_key, block) if key_stale?(redis_key) && !value.nil?
-      return value
-    end
-
     def test?
       ENV["RACK_ENV"] == 'test'
     end
 
-    def refresh_cache(redis_key, block)
-      log("cache.stale_refresh", redis_key)
-      Thread.new do
-        write_into_cache(redis_key, block)
-      end
-    end
-
-    def write_into_cache(redis_key, block)
-      json = block.call
-      with_redis do
-        log("cache.write", redis_key)
-        set_value(redis_key, json)
-      end
-      json
-    end
-
-    def key_stale?(redis_key)
-      ttl = redis.ttl(redis_key)
-      return  ttl < (configuration.cache_time - configuration.stale_time)
-    end
-
-    def get_value(key)
-      decrypt redis.get(key)
-    end
-
-    def set_value(key, value)
-      redis.setex key, configuration.cache_time, encrypt(value)
-    end
-
-    def encrypt(value)
-      return value unless encrypt?
-      Fernet.generate(secret, MultiJson.encode(value))
+    def prep_value(value)
+      MultiJson.encode(value)
     end
 
     def encrypt?
       configuration.encrypt
     end
 
-    def decrypt(value)
-      return nil if value.nil?
-      return value unless encrypt?
-      verifier = Fernet.verifier(secret, value)
-      return MultiJson.load(verifier.message) if verifier.valid?
-      return nil
-    end
-
     def secret
       configuration.secret
     end
 
     def log(str, key)
-      configuration.logger.log(log_prefix(str) => 1, :key => key)
+      configuration.logger.log(log_prefix(str) => 1, :key => key) unless configuration.silent
     end
 
     def log_prefix(str)
       [configuration.log_prefix, str].join(".")
     end
+
+    def fernet
+      ::Fernet
+    end
   end
 end

data/spec/redcache_spec.rb

@@ -1,8 +1,10 @@
 require 'spec_helper'
+require 'fernet'
 
 Redcache.configure do |c|
   c.redis = Redis.new
   c.logger = Pliny
+  c.silent = true
 end
 
 class Dummy
@@ -18,46 +20,116 @@ class Dummy
 end
 
 describe Redcache do
+  let(:rc) { Redcache }
+  let(:config) { Redcache.configuration }
+
+  before do
+    allow(rc.fernet).to receive(:generate){ "abd" }
+  end
 
   context 'when skipping caching' do
     before do
-      allow(Redcache.configuration).to receive(:skip_cache){true}
+      config.skip_cache = true
     end
+
     it 'does not use the cache' do
-      expect(Redcache).to_not receive(:read_from_cache)
+      expect(rc).to_not receive(:read_from_cache)
       Dummy.run
     end
   end
 
   context 'when caching' do
     before do
-      allow(Redcache.configuration).to receive(:skip_cache){false}
+      config.skip_cache = false
     end
 
     it 'uses the cached' do
-      expect(Redcache).to receive(:read_from_cache){ {} }
+      expect(rc).to receive(:read_from_cache){ {} }
       Dummy.run
     end
 
     it 'triggers a cache write if the cache is cold' do
-      allow(Redcache).to receive(:read_from_cache){ nil }
-      expect(Redcache).to receive(:write_into_cache) { "" }
+      allow(rc).to receive(:read_from_cache){ nil }
+      expect(rc).to receive(:write_into_cache) { "" }
       Dummy.run
     end
 
     it 'skips cache when redis is down' do
-      allow(Redcache).to receive(:redis_up?){ false }
-      expect(Redcache).to_not receive(:read_from_cache)
+      allow(rc).to receive(:redis_up?){ false }
+      expect(rc).to_not receive(:read_from_cache)
       expect(Dummy).to receive(:get_value)
       Dummy.run
     end
 
     it 'triggers a cache refresh with a stale warm cache' do
-      allow(Redcache).to receive(:key_stale?){ true }
-      allow(Redcache).to receive(:get_value){ "" }
-      expect(Redcache).to receive(:refresh_cache).once
+      allow(rc).to receive(:key_stale?){ true }
+      allow(rc).to receive(:get_value){ "" }
+      expect(rc).to receive(:refresh_cache).once
       Dummy.run
     end
   end
 
+  describe 'configuration' do
+    it 'respects cache_time' do
+      config.cache_time = 100
+      expect(rc.cache_time).to eq(100)
+    end
+
+    it 'respects stale_time' do
+      config.stale_time = 100
+      expect(rc.stale_time).to eq(100)
+    end
+
+    it 'respects skip_cache' do
+      config.skip_cache = true
+      expect(rc.skip_cache?).to eq(true)
+    end
+
+    it 'knows the secret' do
+      config.secret = "bar"
+      expect(rc.secret).to eq("bar")
+    end
+  end
+
+  it 'knows when a key is stale' do
+    config.cache_time = 100
+    config.stale_time = 10
+    allow(rc.redis).to receive(:ttl){ 80 }
+    expect(rc.key_stale?("foo")).to eq(true)
+
+    allow(rc.redis).to receive(:ttl){ 91 }
+    expect(rc.key_stale?("foo")).to eq(false)
+  end
+
+  it 'can refresh the cache' do
+    p = Proc.new {}
+    expect(Thread).to receive(:new)
+    rc.refresh_cache("foo", p)
+  end
+
+  it 'can write into the cache' do
+    p = Proc.new { "" }
+    expect(rc).to receive(:set_value).with("foo", "")
+    rc.write_into_cache("foo", p.call)
+  end
+
+  it 'can get a value' do
+    expect(rc.redis).to receive(:get).with("foo"){ "bar" }
+    expect(rc).to receive(:decrypt).with("bar")
+    rc.get_value("foo")
+  end
+
+  it 'can set a value' do
+    config.cache_time = 100
+    config.encrypt = false
+    expect(rc.redis).to receive(:setex).with("foo", 100, '"bar"')
+    rc.set_value("foo", "bar")
+  end
+
+  it 'encrypts' do
+    config.encrypt = true
+    config.secret = "foo"
+    expect(rc.fernet).to receive(:generate).with("foo", '"bar"'){ "abc" }
+    rc.encrypt("bar")
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redcache
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Neil Middleton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-05 00:00:00.000000000 Z
+date: 2014-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler