ngmoco-cache-money 0.2.23 → 0.2.24.2

data/lib/cash/adapter/redis.rb

@@ -0,0 +1,152 @@
+# Maps Redis methods and semantics to those of memcache-client
+module Cash
+  module Adapter
+    class Redis
+      def initialize(repository, options = {})
+        @repository = repository
+        @logger = options[:logger]
+        @default_ttl = options[:default_ttl] || raise(":default_ttl is a required option")
+      end
+      
+      def add(key, value, ttl=nil, raw = false)
+        wrap(key, not_stored) do
+          logger.debug("Redis add: #{key.inspect}") if debug_logger?
+          value = dump(value) unless raw
+          # TODO: make transactional
+          result = @repository.setnx(key, value)
+          @repository.expires(key, ttl || @default_ttl) if 1 == result
+          logger.debug("Redis hit: #{key.inspect}") if debug_logger?
+          1 == result ? stored : not_stored
+        end
+      end
+      
+      def get(key, raw = false)
+        wrap(key) do
+          logger.debug("Redis get: #{key.inspect}") if debug_logger?
+          value = wrap(key) { @repository.get(key) }
+          if value
+            logger.debug("Redis hit: #{key.inspect}") if debug_logger?
+            value = load(value) unless raw
+          else
+            logger.debug("Redis miss: #{key.inspect}") if debug_logger?
+          end
+          value
+        end
+      end
+      
+      def get_multi(*keys)
+        wrap(keys, {}) do
+          keys.flatten!
+          logger.debug("Redis get_multi: #{keys.inspect}") if debug_logger?
+          
+          # Values are returned as an array. Convert them to a hash of matches, dropping anything
+          # that doesn't have a match.
+          values = @repository.mget(*keys)
+          result = {}
+          keys.each_with_index{ |key, i| result[key] = load(values[i]) if values[i] }
+          
+          if result.any?
+            logger.debug("Redis hit: #{keys.inspect}") if debug_logger?
+          else
+            logger.debug("Redis miss: #{keys.inspect}") if debug_logger?
+          end
+          result
+        end
+      end
+      
+      def set(key, value, ttl=nil, raw = false)
+        wrap(key, not_stored) do
+          logger.debug("Redis set: #{key.inspect}") if debug_logger?
+          value = dump(value) unless raw
+          @repository.setex(key, ttl || @default_ttl, value)
+          logger.debug("Redis hit: #{key.inspect}") if debug_logger?
+          stored
+        end
+      end
+      
+      def delete(key)
+        wrap(key, not_found) do
+          logger.debug("Redis delete: #{key.inspect}") if debug_logger?
+          @repository.del(key)
+          logger.debug("Redis hit: #{key.inspect}") if debug_logger?
+          deleted
+        end
+      end
+            
+      def get_server_for_key(key)
+        wrap(key) do
+          # Redis::Distributed has a node_for method. 
+          client = @repository.respond_to?(:node_for) ? @repository.node_for(key) : @repository.client
+          client.id
+        end
+      end
+
+      def incr(key, value = 1)
+        # Redis always answeres positively to incr/decr but memcache does not and waits for the key
+        # to be added in a separate operation.
+        if wrap(nil) { @repository.exists(key) }
+          wrap(key) { @repository.incrby(key, value).to_i }
+        end
+      end
+      
+      def decr(key, value = 1)
+        if wrap(nil) { @repository.exists(key) }
+          wrap(key) { @repository.decrby(key, value).to_i }
+        end
+      end
+      
+      def flush_all
+        @repository.flushall
+      end
+      
+      def exception_classes
+        [Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL]
+      end
+      
+      private
+      
+        def logger
+          @logger
+        end
+        
+        def debug_logger?
+          logger && logger.respond_to?(:debug?) && logger.debug?
+        end
+        
+        def wrap(key, error_value = nil)
+          yield
+        rescue *exception_classes
+          log_error($!) if logger
+          error_value
+        end
+        
+        def dump(value)
+          Marshal.dump(value)
+        end
+        
+        def load(value)
+          Marshal.load(value)
+        end
+        
+        def stored
+          "STORED\r\n"
+        end
+
+        def deleted
+          "DELETED\r\n"
+        end
+
+        def not_stored
+          "NOT_STORED\r\n"
+        end
+
+        def not_found
+          "NOT_FOUND\r\n"
+        end
+
+        def log_error(err)
+          logger.error("Redis ERROR, #{err.class}: #{err}") if logger
+        end
+    end
+  end
+end

data/lib/cash/config.rb

@@ -16,7 +16,7 @@ module Cash
       def self.extended(a_class)
         class << a_class
           def cache_config
-            @cache_config ? @cache_config : superclass.cache_config
+            @cache_config
           end
           
           delegate :repository, :indices, :to => :cache_config
@@ -26,7 +26,7 @@ module Cash
 
       def inherited_with_cache_config(subclass)
         inherited_without_cache_config(subclass)
-        @cache_config.inherit(subclass)
+        @cache_config.inherit(subclass) if @cache_config
       end
 
       def index(attributes, options = {})
@@ -41,6 +41,10 @@ module Cash
       def cache_config=(config)
         @cache_config = config
       end
+      
+      def cacheable?(*args)
+        Cash.enabled && cache_config
+      end
     end
 
     class Config
@@ -55,8 +59,7 @@ module Cash
       end
 
       def ttl
-        repository_ttl = repository.respond_to?(:default_ttl) ? repository.default_ttl : nil
-        @ttl ||= @options[:ttl] || repository_ttl || 1.day
+        @ttl ||= (repository.respond_to?(:default_ttl) && repository.default_ttl) || @options[:ttl]
       end
 
       def version

data/lib/cash/finders.rb

@@ -21,17 +21,29 @@ module Cash
 
       # User.find(:first, ...), User.find_by_foo(...), User.find(:all, ...), User.find_all_by_foo(...)
       def find_every_with_cache(options)
-        Query::Select.perform(self, options, scope(:find))
+        if cacheable?
+          Query::Select.perform(self, options, scope(:find))
+        else
+          find_every_without_cache(options)
+        end
       end
 
       # User.find(1), User.find(1, 2, 3), User.find([1, 2, 3]), User.find([])
       def find_from_ids_with_cache(ids, options)
-        Query::PrimaryKey.perform(self, ids, options, scope(:find))
+        if cacheable?
+          Query::PrimaryKey.perform(self, ids, options, scope(:find))
+        else
+          find_from_ids_without_cache(ids, options)
+        end
       end
 
       # User.count(:all), User.count, User.sum(...)
       def calculate_with_cache(operation, column_name, options = {})
-        Query::Calculation.perform(self, operation, column_name, options, scope(:find))
+        if cacheable?
+          Query::Calculation.perform(self, operation, column_name, options, scope(:find))
+        else
+          calculate_without_cache(operation, column_name, options)
+        end
       end
     end
   end

data/lib/cash/index.rb

@@ -4,11 +4,8 @@ module Cash
     delegate :each, :hash, :to => :@attributes
     delegate :get, :set, :expire, :find_every_without_cache, :calculate_without_cache, :calculate_with_cache, :incr, :decr, :primary_key, :logger, :to => :@active_record
 
-    DEFAULT_OPTIONS = { :ttl => 1.day }
-
     def initialize(config, active_record, attributes, options = {})
-      DEFAULT_OPTIONS[:ttl] = config.ttl || DEFAULT_OPTIONS[:ttl]
-      @config, @active_record, @attributes, @options = config, active_record, Array(attributes).collect(&:to_s).sort, DEFAULT_OPTIONS.merge(options)
+      @config, @active_record, @attributes, @options = config, active_record, Array(attributes).collect(&:to_s).sort, options
     end
 
     def ==(other)
@@ -47,7 +44,7 @@ module Cash
 
     module Attributes
       def ttl
-        @ttl ||= options[:ttl] || config.ttl
+        @ttl ||= options[:ttl] || @config.ttl
       end
 
       def order
@@ -129,7 +126,7 @@ module Cash
           (a <=> b) * (order == :asc ? 1 : -1)
         end.uniq
         objects = truncate_if_necessary(objects)
-        set(key, objects, :ttl => ttl)
+        set(key, objects, :ttl => ttl)        
         incr("#{key}/count") { calculate_at_index(:count, attribute_value_pairs) }
       end
     end

data/lib/cash/local.rb

@@ -15,7 +15,7 @@ module Cash
     
     def autoload_missing_constants
       yield if block_given?
-    rescue ArgumentError, MemCache::MemCacheError => error
+    rescue ArgumentError, *@remote_cache.exception_classes => error
       lazy_load ||= Hash.new { |hash, hash_key| hash[hash_key] = true; false }
       if error.to_s[/undefined class|referred/] && !lazy_load[error.to_s.split.last.constantize]
         retry

data/lib/cash/lock.rb

@@ -33,7 +33,7 @@ module Cash
         exponential_sleep(count, initial_wait) unless count == retries - 1
       end
       debug_lock(key)
-      raise Error, "Couldn't acquire memcache lock on #{@cache.get_server_for_key("lock/#{key}")}"
+      raise Error, "Couldn't acquire memcache lock on 'lock/#{key}'"
     end
 
     def release_lock(key)
@@ -41,7 +41,7 @@ module Cash
     end
 
     def exponential_sleep(count, initial_wait)
-      sleep((2**count) / initial_wait)
+      sleep((2**count) * initial_wait)
     end
 
     private

data/lib/cash/mock.rb

@@ -20,7 +20,7 @@ module Cash
           @value = Marshal.dump(value)
         end
         
-        if ttl.zero?
+        if ttl.nil? || ttl.zero?
           @ttl = self.class.default_ttl
         else
           @ttl = ttl
@@ -68,18 +68,22 @@ module Cash
     end
 
     def get(key, raw = false)
-      log "< get #{key}"
-      unless self.has_unexpired_key?(key)
-        log('> END')
-        return nil
-      end
-      
-      log("> sending key #{key}")
-      log('> END')
-      if raw
-        self[key].value
+      if key.is_a?(Array)
+        get_multi(*key)
       else
-        self[key].unmarshal
+        log "< get #{key}"
+        unless self.has_unexpired_key?(key)
+          log('> END')
+          return nil
+        end
+        
+        log("> sending key #{key}")
+        log('> END')
+        if raw
+          self[key].value
+        else
+          self[key].unmarshal
+        end
       end
     end
     

data/lib/cash/query/abstract.rb

@@ -61,8 +61,22 @@ module Cash
 
       private
       def cacheable?(*optionss)
-        return false if @active_record.respond_to?(:cacheable?) && ! @active_record.cacheable?(*optionss)
-        optionss.each { |options| return unless safe_options_for_cache?(options) }
+        if @active_record.respond_to?(:cacheable?) && ! @active_record.cacheable?(*optionss)
+          if logger
+            if @active_record.respond_to?(:cacheable?)
+              logger.debug("  \e[1;4;31mUNCACHEABLE CLASS\e[0m #{table_name}")
+            else
+              logger.debug("  \e[1;4;31mUNCACHEABLE INSTANCE\e[0m #{table_name} - #{optionss.inspect}")
+            end
+          end
+          return false
+        end
+        optionss.each do |options|
+          unless safe_options_for_cache?(options)
+            logger.debug("  \e[1;4;31mUNCACHEABLE UNSAFE\e[0m #{table_name} - #{options.inspect}") if logger
+            return false
+          end
+        end
         partial_indices = optionss.collect { |options| attribute_value_pairs_for_conditions(options[:conditions]) }
         return if partial_indices.include?(nil)
         attribute_value_pairs = partial_indices.sum.sort { |x, y| x[0] <=> y[0] }
@@ -74,7 +88,13 @@ module Cash
         if index = indexed_on?(attribute_value_pairs.collect { |pair| pair[0] })
           if index.matches?(self)
             [attribute_value_pairs, index]
+          else
+            logger.debug("  \e[1;4;31mUNCACHEABLE NO MATCHING INDEX\e[0m #{table_name} - #{index.order_column.inspect} #{index.order.inspect} #{index.limit.inspect}") if logger
+            false
           end
+        else
+          logger.debug("  \e[1;4;31mUNCACHEABLE NOT INDEXED\e[0m #{table_name} - #{attribute_value_pairs.collect { |pair| pair[0] }.inspect}") if logger
+          false
         end
       end
 
@@ -191,7 +211,13 @@ module Cash
         order_sql = @options1[:order] || @options2[:order]
         options[:order] = order_sql if order_sql
         results = find_from_ids_without_cache(missing_ids, options)
-        results.each {|o| @active_record.add_to_caches(o) } if results && results.is_a?(Array)
+        if results
+          if results.is_a?(Array)
+            results.each {|o| @active_record.add_to_caches(o) } 
+          else
+            @active_record.add_to_caches(results)
+          end
+        end
         results
       end
     end

data/lib/cash/version.rb

@@ -0,0 +1,3 @@
+module Cash
+  VERSION = '0.2.24.2'
+end

data/lib/cash/write_through.rb

@@ -1,6 +1,6 @@
 module Cash
   module WriteThrough
-    DEFAULT_TTL = 12.hours
+    DEFAULT_TTL = 12.hours.to_i
 
     def self.included(active_record_class)
       active_record_class.class_eval do
@@ -50,19 +50,23 @@ module Cash
 
     module ClassMethods
       def add_to_caches(object)
-        indices.each { |index| index.add(object) } if cache_config
+        indices.each { |index| index.add(object) } if cacheable?
+        true
       end
 
       def update_caches(object)
-        indices.each { |index| index.update(object) } if cache_config
+        indices.each { |index| index.update(object) } if cacheable?
+        true
       end
 
       def remove_from_caches(object)
-        indices.each { |index| index.remove(object) } if cache_config
+        indices.each { |index| index.remove(object) } if cacheable?
+        true
       end
 
       def expire_caches(object)
-        indices.each { |index| index.delete(object) } if cache_config
+        indices.each { |index| index.delete(object) } if cacheable?
+        true
       end
     end
   end

data/lib/mem_cached_support_store.rb

@@ -126,7 +126,7 @@ require 'memcached'
 
       private
         def expires_in(options)
-          (options && options[:expires_in]) || 0
+          (options && options[:expires_in] && options[:expires_in].to_i) || 0
         end
 
         def marshal?(options)

data/rails/init.rb

@@ -1,40 +1 @@
-yml = YAML.load(IO.read(File.join(RAILS_ROOT, "config", "memcached.yml")))
-memcache_config = yml[RAILS_ENV]
-memcache_config.symbolize_keys! if memcache_config.respond_to?(:symbolize_keys!)
-
-if defined?(DISABLE_CACHE_MONEY) || ENV['DISABLE_CACHE_MONEY'] == 'true' || memcache_config.nil? || memcache_config[:cache_money] != true
-  Rails.logger.info 'cache-money disabled'
-  class ActiveRecord::Base
-    def self.index(*args)
-    end
-  end
-else
-  Rails.logger.info 'cache-money enabled'
-  require 'cache_money'
-
-  memcache_config[:logger] = Rails.logger
-  memcache_servers = 
-    case memcache_config[:servers].class.to_s
-      when "String"; memcache_config[:servers].gsub(' ', '').split(',')
-      when "Array"; memcache_config[:servers]
-    end
-  $memcache = MemcachedWrapper.new(memcache_servers, memcache_config)
-
-  #ActionController::Base.cache_store = :cache_money_mem_cache_store
-  ActionController::Base.session_options[:cache] = $memcache if memcache_config[:sessions]
-  #silence_warnings {
-  #  Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(:cache_money_mem_cache_store)
-  #}
-
-  $local = Cash::Local.new($memcache)
-  $lock  = Cash::Lock.new($memcache)
-  $cache = Cash::Transactional.new($local, $lock)
-
-  # allow setting up caching on a per-model basis
-  unless memcache_config[:automatic_caching].to_s == 'false'
-    Rails.logger.info "cache-money: global model caching enabled"
-    class ActiveRecord::Base
-      is_cached(:repository => $cache)
-    end
-  end
-end
+require 'cache_money'