viximo-cache-money 0.3.0

data/TODO

@@ -0,0 +1,17 @@
+TOP PRIORITY
+
+REFACTOR
+* Clarify terminology around cache/key/index, etc.
+
+INFRASTRUCTURE
+
+NEW FEATURES
+* transactional get multi isn't really multi
+
+BUGS
+* Handle append strategy (using add rather than set?) to avoid race condition
+
+MISSING TESTS:
+* missing tests for Klass.transaction do ... end
+* non "id" pks work but lack test coverage
+* expire_cache

data/UNSUPPORTED_FEATURES

@@ -0,0 +1,13 @@
+* does not work with :dependent => nullify because
+  def nullify_has_many_dependencies(record, reflection_name, association_class, primary_key_name, dependent_conditions)
+    association_class.update_all("#{primary_key_name} = NULL", dependent_conditions)
+  end
+  This does not trigger callbacks
+* update_all, delete, update_counter, increment_counter, decrement_counter, counter_caches in general - counter caches are replaced by this gem, bear that in mind.
+* attr_readonly - no technical obstacle, just not yet supported
+* attributes before typecast behave unpredictably - hard to support
+* Named bind variables :conditions => ["name = :name", { :name => "37signals!" }] - not hard to support
+* printf style binds: :conditions => ["name = '%s'", "37signals!"] - not too hard to support
+* objects as attributes that are serialized. story.title = {:foo => :bar}; customer.balance = Money.new(...) - these could be coerced using Column#type_cast?
+
+With a lot of these features the issue is not technical but performance. Every special case costs some overhead.

data/config/environment.rb

@@ -0,0 +1,8 @@
+require 'action_controller'
+require 'active_record'
+require 'active_record/session_store'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+)

data/config/memcached.yml

@@ -0,0 +1,4 @@
+test:
+  ttl: 604800
+  namespace: cache
+  servers: localhost:11211

data/db/schema.rb

@@ -0,0 +1,18 @@
+ActiveRecord::Schema.define(:version => 2) do
+  create_table "stories", :force => true do |t|
+    t.string "title", "subtitle"
+    t.string  "type"
+    t.boolean "published"
+  end
+
+  create_table "characters", :force => true do |t|
+    t.integer "story_id"
+    t.string "name"
+  end
+  
+  create_table :sessions, :force => true do |t|
+    t.string :session_id
+    t.text   :data
+    t.timestamps
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'rails/init'

data/lib/cache_money.rb

@@ -0,0 +1,105 @@
+require 'active_support'
+require 'active_record'
+
+require 'cash/version'
+require 'cash/lock'
+require 'cash/transactional'
+require 'cash/write_through'
+require 'cash/finders'
+require 'cash/buffered'
+require 'cash/index'
+require 'cash/config'
+require 'cash/accessor'
+
+require 'cash/request'
+require 'cash/fake'
+require 'cash/local'
+
+require 'cash/query/abstract'
+require 'cash/query/select'
+require 'cash/query/primary_key'
+require 'cash/query/calculation'
+
+require 'cash/util/array'
+require 'cash/util/marshal'
+
+module Cash
+  mattr_accessor :enabled
+  self.enabled = true
+  
+  mattr_accessor :repository
+  
+  def self.configure(options = {})
+    options.assert_valid_keys(:repository, :local, :transactional, :adapter, :default_ttl)
+    cache = options[:repository] || raise(":repository is a required option")
+    
+    adapter = options.fetch(:adapter, :memcached)
+    
+    if adapter
+      require "cash/adapter/#{adapter.to_s}"
+      klass = "Cash::Adapter::#{adapter.to_s.camelize}".constantize
+      cache = klass.new(cache, :logger => Rails.logger, :default_ttl => options.fetch(:default_ttl, 1.day.to_i))
+    end
+    
+    lock  = Cash::Lock.new(cache)
+    cache = Cash::Local.new(cache) if options.fetch(:local, true)
+    cache = Cash::Transactional.new(cache, lock) if options.fetch(:transactional, true)
+    
+    self.repository = cache
+  end
+  
+  def self.included(active_record_class)
+    active_record_class.class_eval do
+      include Config, Accessor, WriteThrough, Finders
+      extend ClassMethods
+    end
+  end
+
+  private
+
+    def self.repository
+      @@repository || raise("Cash.configure must be called when Cash.enabled is true")
+    end
+  
+  module ClassMethods
+    def self.extended(active_record_class)
+      class << active_record_class
+        alias_method_chain :transaction, :cache_transaction
+      end
+    end
+
+    def transaction_with_cache_transaction(*args, &block)
+      if Cash.enabled
+        # Wrap both the db and cache transaction in another cache transaction so that the cache 
+        # gets written only after the database commit but can still flush the inner cache
+        # transaction if an AR::Rollback is issued.
+        Cash.repository.transaction do
+          transaction_without_cache_transaction(*args) do
+            Cash.repository.transaction { block.call }
+          end
+        end
+      else
+        transaction_without_cache_transaction(*args, &block)
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include Cash
+  
+  def self.is_cached(options = {})
+    options.assert_valid_keys(:ttl, :repository, :version)
+    opts = options.dup
+    opts[:repository] = Cash.repository unless opts.has_key?(:repository)
+    Cash::Config.create(self, opts)
+  end
+
+  def <=>(other)
+    if self.id == other.id then 
+      0
+    else
+      self.id < other.id ? -1 : 1
+    end
+  end
+end

data/lib/cash/accessor.rb

@@ -0,0 +1,83 @@
+module Cash
+  module Accessor
+    def self.included(a_module)
+      a_module.module_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      def fetch(keys, options = {}, &block)
+        case keys
+        when Array
+          return {} if keys.empty?
+          
+          keys = keys.collect { |key| cache_key(key) }
+          hits = repository.get_multi(*keys)
+          if (missed_keys = keys - hits.keys).any?
+            missed_values = block.call(missed_keys)
+            hits.merge!(missed_keys.zip(Array(missed_values)).to_hash_without_nils)
+          end
+          hits
+        else
+          repository.get(cache_key(keys), options[:raw]) || (block ? block.call : nil)
+        end
+      end
+
+      def get(keys, options = {}, &block)
+        case keys
+        when Array
+          fetch(keys, options, &block)
+        else
+          fetch(keys, options) do
+            if block_given?
+              add(keys, result = yield(keys), options)
+              result
+            end
+          end
+        end
+      end
+
+      def add(key, value, options = {})
+        if repository.add(cache_key(key), value, options[:ttl] || cache_config.ttl, options[:raw]) == "NOT_STORED\r\n"
+          yield if block_given?
+        end
+      end
+
+      def set(key, value, options = {})
+        repository.set(cache_key(key), value, options[:ttl] || cache_config.ttl, options[:raw])
+      end
+
+      def incr(key, delta = 1, ttl = nil)
+        ttl ||= cache_config.ttl
+        repository.incr(cache_key = cache_key(key), delta) || begin
+          repository.add(cache_key, (result = yield).to_s, ttl, true) { repository.incr(cache_key) }
+          result
+        end
+      end
+
+      def decr(key, delta = 1, ttl = nil)
+        ttl ||= cache_config.ttl
+        repository.decr(cache_key = cache_key(key), delta) || begin
+          repository.add(cache_key, (result = yield).to_s, ttl, true) { repository.decr(cache_key) }
+          result
+        end
+      end
+
+      def expire(key)
+        repository.delete(cache_key(key))
+      end
+
+      def cache_key(key)
+        "#{name}:#{cache_config.version}/#{key.to_s.gsub(' ', '+')}"
+      end
+    end
+
+    module InstanceMethods
+      def expire
+        self.class.expire(id)
+      end
+    end
+  end
+end

data/lib/cash/adapter/memcache_client.rb

@@ -0,0 +1,36 @@
+require 'memcache'
+
+module Cash
+  module Adapter
+    class MemcacheClient
+      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)
+        @repository.add(key, value || @default_ttl, ttl, raw)
+      end
+      
+      def set(key, value, ttl=nil, raw=false)
+        @repository.set(key, value || @default_ttl, ttl, raw)
+      end
+      
+      def exception_classes
+        MemCache::MemCacheError
+      end
+      
+      def respond_to?(method)
+        super || @repository.respond_to?(method)
+      end
+      
+      private
+      
+        def method_missing(*args, &block)
+          @repository.send(*args, &block)
+        end
+        
+    end
+  end
+end

data/lib/cash/adapter/memcached.rb

@@ -0,0 +1,127 @@
+require 'memcached'
+
+# Maps memcached methods and semantics to those of memcache-client
+module Cash
+  module Adapter
+    class Memcached
+      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("Memcached add: #{key.inspect}") if debug_logger?
+          @repository.add(key, raw ? value.to_s : value, ttl || @default_ttl, !raw)
+          logger.debug("Memcached hit: #{key.inspect}") if debug_logger?
+          stored
+        end
+      end
+      
+      # Wraps Memcached#get so that it doesn't raise. This has the side-effect of preventing you from 
+      # storing <tt>nil</tt> values.
+      def get(key, raw=false)
+        wrap(key) do
+          logger.debug("Memcached get: #{key.inspect}") if debug_logger?
+          value = wrap(key) { @repository.get(key, !raw) }
+          logger.debug("Memcached hit: #{key.inspect}") if debug_logger?
+          value
+        end
+      end
+      
+      def get_multi(*keys)
+        wrap(keys, {}) do
+          begin
+            keys.flatten!
+            logger.debug("Memcached get_multi: #{keys.inspect}") if debug_logger?
+            values = @repository.get(keys, true)
+            logger.debug("Memcached hit: #{keys.inspect}") if debug_logger?
+            values
+          rescue TypeError
+            log_error($!) if logger
+            keys.each { |key| delete(key) }
+            logger.debug("Memcached deleted: #{keys.inspect}") if debug_logger?
+            {}
+          end
+        end
+      end
+      
+      def set(key, value, ttl=nil, raw=false)
+        wrap(key, not_stored) do
+          logger.debug("Memcached set: #{key.inspect}") if debug_logger?
+          @repository.set(key, raw ? value.to_s : value, ttl || @default_ttl, !raw)
+          logger.debug("Memcached hit: #{key.inspect}") if debug_logger?
+          stored
+        end
+      end
+      
+      def delete(key)
+        wrap(key, not_found) do
+          logger.debug("Memcached delete: #{key.inspect}") if debug_logger?
+          @repository.delete(key)
+          logger.debug("Memcached hit: #{key.inspect}") if debug_logger?
+          deleted
+        end
+      end
+      
+      def incr(key, value = 1)
+        wrap(key) { @repository.incr(key, value) }
+      end
+
+      def decr(key, value = 1)
+        wrap(key) { @repository.decr(key, value) }
+      end
+      
+      def flush_all
+        @repository.flush
+      end
+      
+      def exception_classes
+        ::Memcached::Error
+      end
+      
+      private
+      
+        def logger
+          @logger
+        end
+        
+        def debug_logger?
+          logger && logger.respond_to?(:debug?) && logger.debug?
+        end
+        
+        def wrap(key, error_value = nil, options = {})
+          yield
+        rescue ::Memcached::NotStored, ::Memcached::NotFound
+          logger.debug("Memcached miss: #{key.inspect}") if debug_logger?
+          error_value
+        rescue ::Memcached::Error
+          log_error($!) if logger
+          raise if options[:reraise_error]
+          error_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("#{err}: \n\t#{err.backtrace.join("\n\t")}") if logger
+          logger.error("Memcached ERROR, #{err.class}: #{err}") if logger
+        end
+    end
+  end
+end

data/lib/cash/adapter/redis.rb

@@ -0,0 +1,144 @@
+# 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 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