sinatra-redis-cache 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06b3625b3a106890160c40df9820300bfff4f089
-  data.tar.gz: cbf94d36d64713d4aa0aa5cf2fb8ce02c0d51cd4
+  metadata.gz: b87cc8855b185fcd8ed06c830fa184a1d175941e
+  data.tar.gz: 6a335f63d0d2fa50caaafd8d3e3a3422f101d428
 SHA512:
-  metadata.gz: c0a67b592f9147989575655308251364de3d7131a29772241f78a65a757aba8f5ad8ec1ad0c8da1d61ab0309fce1deb837e7c205f7688451044de7360cde8f1c
-  data.tar.gz: 5b80698e8592d31960975df62142bbb58c614ab25f48b0f772922b6e89342d04335dc85807edd22869f593a6da68689dde8f7aa4dbb1198766fd57bb5a24c782
+  metadata.gz: ca83aa4e02139b50bb1d284ce0f1ee6a2f61bed119bba06a77eeeda0858ef1c352769d902b7c30671f00c679d2d7533b49453e77751cf4e3576284cb5e4a7924
+  data.tar.gz: a4326ed7771f25d79f5da08779eca7ecc542b1d40eabc07c329ac5c0135465d836a950ea4e243fd6eabdc5f89891d839bf5f5de2e2ca82635c964bc40c1813c3

data/README.md

@@ -40,6 +40,8 @@ Sinatra::RedisCache::Config.config do
   redis_conn      Redis.new
   namespace       'sinatra_cache'
   default_expires 3600
+  lock_timeout    5
   environments    [:production]
+  logger          Logger.new(STDERR)
 end
 ```

data/Rakefile

@@ -7,7 +7,12 @@ namespace :sinatra_cache do
 
   desc 'Print configured namespace'
   task :namespace do
+    puts Sinatra::RedisCache::Config.namespace
+  end
+
+  desc 'Show all cache keys'
+  task :list_keys do
     include Sinatra::RedisCache
-    Sinatra::RedisCache::Config.config.namespace
+    puts cache_list_keys.map{|k| "#{k} [age: #{cache_key_age(k).to_i}, ttl: #{cache_key_ttl(k)}]"}
   end
 end

data/lib/sinatra/redis-cache.rb

@@ -28,17 +28,36 @@ module Sinatra
       end
     end
 
-    class RedisCache
-      def do(key, expires, params={}, block)
-        key = key_with_namespace(key)
+    class Cache
+      def do(key, expires=config.default_expires, block)
+        debug_log "do #{key_without_namespace(key)}"
         if Sinatra::RedisCache::Config.environments.include? Sinatra::Base.settings.environment
-          object = get(key)
-          if object
-            object
-          else
-            object = block.call
-            store(key, object, expires)
-            object
+          try = 0
+          begin
+            redis.watch(key = key_with_namespace(key)) do |watched|
+              object = get(key)
+              unless object.empty?
+                if object['locked']
+                  raise SinatraRedisCacheKeyLocked
+                end
+                object['object']
+              else
+                lock_key(key, watched, config.lock_timeout)
+                new_object = block.call
+                store(key, new_object, expires)
+                new_object
+              end
+            end
+          rescue SinatraRedisCacheKeyLocked
+            sleeptime = (((try += 1)*50 + rand(100).to_f)/1000)
+            debug_log "key is locked, waiting #{sleeptime}s for retry ##{try}."
+            sleep sleeptime
+            retry
+          rescue SinatraRedisCacheKeyAlreadyLocked
+            sleeptime = (((try += 1)*50 + rand(100).to_f)/1000)
+            debug_log "failed to obtain lock, waiting #{sleeptime}s for retry ##{try}."
+            sleep sleeptime
+            retry
           end
         else
           # Just run the block without cache if we're not in an allowed environment
@@ -46,25 +65,51 @@ module Sinatra
         end
       end
 
-      def get(key, params={})
-        key = key_with_namespace(key)
-        string = redis.get(key)
-        unless string.nil?
-          deserialize(string)
+      def get(key)
+        debug_log "get #{key_without_namespace(key)}"
+        unless (hash = redis.hgetall(key_with_namespace(key))).nil?
+          hash.each{|k,v| hash[k]=deserialize(v)}
         else
           false
         end
       end
 
-      def store(key, object, expires, params={})
-        key = key_with_namespace(key)
-        expires = expires || config.default_expires
-        redis.set(key, serialize(object))
-        redis.expire(key, expires)
+      def store(key, object, expires=config.default_expires)
+        debug_log "store #{key_without_namespace(key)}"
+        properties = { created_at: Time.now.utc.to_i }
+        redis.watch(key = key_with_namespace(key)) do |watched|
+          watched.multi do |multi|
+            multi.hset(key, 'object',     serialize(object))
+            multi.hset(key, 'properties', serialize(properties))
+            multi.hdel(key, 'locked')
+            multi.expire(key, expires)
+          end
+        end
+      end
+
+      def properties(key)
+        unless (string = redis.hget(key_with_namespace(key), 'properties')).nil?
+          deserialize(string)
+        end
+      end
+
+      def ttl(key)
+        redis.ttl(key_with_namespace(key))
+      end
+
+      def all_keys(params={with_namespace: true})
+        redis.keys("#{namespace}:*").map{|k| params[:with_namespace] ? k : key_without_namespace(k) }
+      end
+
+      def del(keys)
+        debug_log "del #{keys.map{|k| key_without_namespace(k)}}"
+        redis.del(keys)
       end
 
       def flush
-        redis.del(all_keys)
+        unless (keys = all_keys).empty?
+          del(keys)
+        end
       end
 
       private
@@ -73,6 +118,12 @@ module Sinatra
         Sinatra::RedisCache::Config
       end
 
+      def debug_log(message)
+        if config.logger
+          config.logger.debug("sinatra-redis-cache/#{Process.pid}/#{Thread.current.__id__}") { message }
+        end
+      end
+
       def redis
         config.redis_conn
       end
@@ -97,10 +148,6 @@ module Sinatra
         end
       end
 
-      def all_keys
-        redis.keys(namespace + '*')
-      end
-
       def serialize(object)
         Marshal.dump(object)
       end
@@ -108,25 +155,61 @@ module Sinatra
       def deserialize(string)
         Marshal.load(string)
       end
+
+      def lock_key(key, redis, timeout=config.lock_timeout)
+        debug_log "locking #{key_without_namespace(key)} for #{timeout}s"
+        unless redis.multi do |multi|
+          multi.hsetnx(key, 'locked', serialize(true))
+          multi.expire(key, timeout)
+        end.eql? [true,true]
+          raise SinatraRedisCacheKeyAlreadyLocked
+        end
+
+      end
     end
 
-    def cache_do(key, expires=nil, params={}, &block)
-      cache = RedisCache.new
-      cache.do(key, expires, params, block)
+    def cache_do(key, expires=nil, &block)
+      cache = Cache.new
+      cache.do(key, expires, block)
     end
 
-    def cache_get(key, params={})
-      cache = RedisCache.new
-      cache.get(key, params)
+    def cache_get(key)
+      cache = Cache.new
+      cache.get(key)
     end
 
-    def cache_store(key, value, expires, params={})
-      cache = RedisCache.new
-      cache.store(key, value, expires, params)
+    def cache_key_properties(key)
+      cache = Cache.new
+      cache.properties(key)
+    end
+
+    def cache_key_age(key)
+      cache = Cache.new
+      Time.now.utc.to_i - cache.properties(key)[:created_at]
+    end
+
+    def cache_key_ttl(key)
+      cache = Cache.new
+      cache.ttl(key)
+    end
+
+    def cache_store(key, value, expires=nil)
+      cache = Cache.new
+      cache.store(key, value, expires)
+    end
+
+    def cache_list_keys
+      cache = Cache.new
+      cache.all_keys(with_namespace: false)
+    end
+
+    def cache_del(keys)
+      cache = Cache.new
+      cache.del(keys)
     end
 
     def cache_flush
-      cache = RedisCache.new
+      cache = Cache.new
       cache.flush
     end
 
@@ -135,12 +218,20 @@ module Sinatra
   helpers RedisCache
 end
 
+class SinatraRedisCacheKeyLocked < Exception
+end
+
+class SinatraRedisCacheKeyAlreadyLocked < Exception
+end
+
 Sinatra::RedisCache::Config.config do
   # Set up configurable values
   parameter :redis_conn
   parameter :namespace
   parameter :default_expires
+  parameter :lock_timeout
   parameter :environments
+  parameter :logger
 end
 
 Sinatra::RedisCache::Config.config do
@@ -148,7 +239,9 @@ Sinatra::RedisCache::Config.config do
   redis_conn      Redis.new
   namespace       'sinatra_cache'
   default_expires 3600
+  lock_timeout    5
   environments    [:production]
+  logger          Logger.new(STDERR)
 end
 
 unless defined?(Rake).nil?

data/lib/sinatra/redis-cache.rb.bak

@@ -0,0 +1,251 @@
+require 'sinatra/base'
+require 'redis'
+require 'socket'
+
+module Sinatra
+
+  module RedisCache
+
+    module Config
+      extend self
+
+      def parameter(*names)
+        names.each do |name|
+          attr_accessor name
+
+          define_method name do |*values|
+            value = values.first
+            if value
+              self.send("#{name}=", value)
+            else
+              instance_variable_get("@#{name}")
+            end
+          end
+        end
+      end
+
+      def config(&block)
+        instance_eval &block
+      end
+    end
+
+    class Cache
+      def do(key, expires, lock, block)
+        log "def do #{key}"
+        if Sinatra::RedisCache::Config.environments.include? Sinatra::Base.settings.environment
+          begin
+            redis.watch(key = key_with_namespace(key)) do
+              log "  in watch"
+              object = redis.hgetall(key)
+              unless object.empty?
+                log "    object is not empty"
+                if lock && object['locked']
+                  log "      object is locked"
+                  raise SinatraRedisCacheKeyLocked
+                end
+                log "    returning object"
+                deserialize(object['object'])
+              else
+                log " apparently object is empty"
+                if lock
+                  log " locking"
+                  lock_key(key, lock.class == Integer ? lock : 2)
+                end
+                new_object = block.call
+                store(key, new_object, expires)
+                new_object
+              end
+            end
+          rescue SinatraRedisCacheKeyLocked
+            log "  raise SinatraRedisCacheKeyLocked"
+            sleep ((50 + rand(100).to_f)/1000)
+            retry
+          rescue SinatraRedisCacheKeyAlreadyLocked
+            log "  raise SinatraRedisCacheKeyAlreadyLocked"
+            sleep ((50 + rand(100).to_f)/1000)
+            retry
+          end
+        else
+          # Just run the block without cache if we're not in an allowed environment
+          block.call
+        end
+      end
+
+      def get(key)
+        log "def get #{key}"
+        unless (string = redis.hget(key_with_namespace(key),'object')).nil?
+          deserialize(string)
+        else
+          false
+        end
+      end
+
+      def store(key, object, expires=config.default_expires)
+        log "def store #{key}"
+        redis.watch(key = key_with_namespace(key)) do
+          redis.multi do |multi|
+            multi.hset(key, 'object',     serialize(object))
+            multi.expire(key, expires)
+            multi.hdel(key, 'locked')
+          end
+        end
+      end
+
+      def properties(key)
+        log "def properties #{key}"
+        unless (string = redis.hget(key_with_namespace(key), 'properties')).nil?
+          deserialize(string)
+        end
+      end
+
+      def ttl(key)
+        redis.ttl(key_with_namespace(key))
+      end
+
+      def all_keys(params={with_namespace: true})
+        redis.keys("#{namespace}:*").map{|k| params[:with_namespace] ? k : key_without_namespace(k) }
+      end
+
+      def del(keys)
+        redis.del(keys)
+      end
+
+      def flush
+        unless (keys = all_keys).empty?
+          del(keys)
+        end
+      end
+
+      private
+
+      def config
+        Sinatra::RedisCache::Config
+      end
+
+      def log(message)
+        if config.logger
+          config.logger.debug('sinatra-redis-cache') { message }
+        end
+      end
+
+      def redis
+        config.redis_conn
+      end
+
+      def namespace
+        config.namespace
+      end
+
+      def key_with_namespace(key)
+        if key.start_with? namespace
+          key
+        else
+          "#{namespace}:#{key}"
+        end
+      end
+
+      def key_without_namespace(key)
+        if key.start_with? namespace
+          key.gsub(/^#{namespace}:/,'')
+        else
+          key
+        end
+      end
+
+      def serialize(object)
+        Marshal.dump(object)
+      end
+
+      def deserialize(string)
+        Marshal.load(string)
+      end
+
+      def lock_key(key, timeout=2)
+        log "  def lock"
+        unless redis.multi do |multi|
+          multi.hsetnx(key, 'locked', true)
+          multi.hsetnx(key, 'created_by', "#{Socket.gethostname}/#{Process.pid.to_s}/#{Thread.current.to_s}")
+          multi.expire(key, timeout)
+        end[0]
+          raise SinatraRedisCacheKeyAlreadyLocked
+        end
+      end
+    end
+
+    def cache_do(key, expires=nil, lock=false, &block)
+      cache = Cache.new
+      cache.do(key, expires, lock, block)
+    end
+
+    def cache_get(key)
+      cache = Cache.new
+      cache.get(key)
+    end
+
+    def cache_key_properties(key)
+      cache = Cache.new
+      cache.properties(key)
+    end
+
+    def cache_key_age(key)
+      cache = Cache.new
+      Time.now.utc.to_i - cache.properties(key)[:created_at]
+    end
+
+    def cache_key_ttl(key)
+      cache = Cache.new
+      cache.ttl(key)
+    end
+
+    def cache_store(key, value, expires=nil)
+      cache = Cache.new
+      cache.store(key, value, expires)
+    end
+
+    def cache_list_keys
+      cache = Cache.new
+      cache.all_keys(with_namespace: false)
+    end
+
+    def cache_del(keys)
+      cache = Cache.new
+      cache.del(keys)
+    end
+
+    def cache_flush
+      cache = Cache.new
+      cache.flush
+    end
+
+  end
+
+  helpers RedisCache
+end
+
+class SinatraRedisCacheKeyLocked < Exception
+end
+
+class SinatraRedisCacheKeyAlreadyLocked < Exception
+end
+
+Sinatra::RedisCache::Config.config do
+  # Set up configurable values
+  parameter :redis_conn
+  parameter :namespace
+  parameter :default_expires
+  parameter :environments
+  parameter :logger
+end
+
+Sinatra::RedisCache::Config.config do
+  # Default values
+  redis_conn      Redis.new
+  namespace       'sinatra_cache'
+  default_expires 3600
+  environments    [:production]
+  logger          Logger.new(STDOUT)
+end
+
+unless defined?(Rake).nil?
+    Rake.load_rakefile("#{File.dirname(__FILE__)}/../../Rakefile")
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-redis-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Warren Guy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-10 00:00:00.000000000 Z
+date: 2014-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -62,6 +62,7 @@ files:
 - README.md
 - Rakefile
 - lib/sinatra/redis-cache.rb
+- lib/sinatra/redis-cache.rb.bak
 homepage: https://github.com/warrenguy/sinatra-redis-cache
 licenses:
 - MIT