netshade-cache-money 0.2.5.2

data/README

@@ -0,0 +1 @@
+README.markdown

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,14 @@
+* 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
+* ActiveRecord::Rollback is unsupported - the exception gets swallowed so there isn't an opportunity to rollback the cache transaction - not 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,6 @@
+require 'activerecord'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :dbfile => ':memory:'
+)

data/config/memcache.yml

@@ -0,0 +1,6 @@
+test:
+  ttl: 604800
+  namespace: cache
+  sessions: false
+  debug: false
+  servers: localhost:11211

data/db/schema.rb

@@ -0,0 +1,12 @@
+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
+end

data/lib/cache_money.rb

@@ -0,0 +1,54 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'activesupport'
+require 'activerecord'
+
+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/mock'
+require 'cash/local'
+
+require 'cash/query/abstract'
+require 'cash/query/select'
+require 'cash/query/primary_key'
+require 'cash/query/calculation'
+
+require 'cash/util/array'
+
+class << ActiveRecord::Base
+  def is_cached(options = {})
+    options.assert_valid_keys(:ttl, :repository, :version)
+    include Cash
+    Cash::Config::Config.create(self, options)        
+  end
+end
+
+module Cash
+  def self.included(active_record_class)
+    active_record_class.class_eval do
+      extend Cash::ClassMethods            
+      include Cash::Config, Cash::Accessor, Cash::WriteThrough, Cash::Finders
+    end
+  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(&block)
+      repository.transaction { transaction_without_cache_transaction(&block) }
+    end
+  end
+end

data/lib/cash/accessor.rb

@@ -0,0 +1,79 @@
+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
+          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)
+          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] || 0, options[:raw]) == "NOT_STORED\r\n"
+          yield
+        end
+      end
+
+      def set(key, value, options = {})
+        repository.set(cache_key(key), value, options[:ttl] || 0, options[:raw])
+      end
+
+      def incr(key, delta = 1, ttl = 0)
+        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 = 0)
+        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/buffered.rb

@@ -0,0 +1,126 @@
+module Cash
+  class Buffered
+    def self.push(cache, lock)
+      if cache.is_a?(Buffered)
+        cache.push
+      else
+        Buffered.new(cache, lock)
+      end
+    end
+
+    def initialize(memcache, lock)
+      @buffer = {}
+      @commands = []
+      @cache = memcache
+      @lock = lock
+    end
+
+    def pop
+      @cache
+    end
+
+    def push
+      NestedBuffered.new(self, @lock)
+    end
+
+    def get(key, *options)
+      if @buffer.has_key?(key)
+        @buffer[key]
+      else
+        @buffer[key] = @cache.get(key, *options)
+      end
+    end
+
+    def set(key, value, *options)
+      @buffer[key] = value
+      buffer_command Command.new(:set, key, value, *options)
+    end
+
+    def incr(key, amount = 1)
+      return unless value = get(key, true)
+
+      @buffer[key] = value.to_i + amount
+      buffer_command Command.new(:incr, key, amount)
+      @buffer[key]
+    end
+
+    def decr(key, amount = 1)
+      return unless value = get(key, true)
+
+      @buffer[key] = [value.to_i - amount, 0].max
+      buffer_command Command.new(:decr, key, amount)
+      @buffer[key]
+    end
+
+    def add(key, value, *options)
+      @buffer[key] = value
+      buffer_command Command.new(:add, key, value, *options)
+    end
+
+    def delete(key, *options)
+      @buffer[key] = nil
+      buffer_command Command.new(:delete, key, *options)
+    end
+
+    def get_multi(keys)
+      values = keys.collect { |key| get(key) }
+      keys.zip(values).to_hash
+    end
+
+    def flush
+      sorted_keys = @commands.select(&:requires_lock?).collect(&:key).uniq.sort
+      sorted_keys.each do |key|
+        @lock.acquire_lock(key)
+      end
+      perform_commands
+    ensure
+      @buffer = {}
+      sorted_keys.each do |key|
+        @lock.release_lock(key)
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      @cache.send(method, *args, &block)
+    end
+
+    def respond_to?(method)
+      @cache.respond_to?(method)
+    end
+
+    protected
+    def perform_commands
+      @commands.each do |command|
+        command.call(@cache)
+      end
+    end
+
+    def buffer_command(command)
+      @commands << command
+    end
+  end
+
+  class NestedBuffered < Buffered
+    def flush
+      perform_commands
+    end
+  end
+
+  class Command
+    attr_accessor :key
+
+    def initialize(name, key, *args)
+      @name = name
+      @key = key
+      @args = args
+    end
+
+    def requires_lock?
+      @name == :set
+    end
+
+    def call(cache)
+      cache.send @name, @key, *@args
+    end
+  end
+end

data/lib/cash/config.rb

@@ -0,0 +1,78 @@
+module Cash
+  module Config
+    def self.included(a_module)
+      a_module.module_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def self.extended(a_class)
+        class << a_class
+          delegate :repository, :indices, :to => :cache_config
+          alias_method_chain :inherited, :cache_config
+        end
+      end
+
+      def cache_config
+        unless c = @cache_config
+          if self.superclass.respond_to?(:cache_config) && (c = self.superclass.cache_config)
+            c.inherit(self)
+          end
+        end
+        @cache_config
+      end
+
+      def inherited_with_cache_config(subclass)
+        inherited_without_cache_config(subclass)
+        cache_config.inherit(subclass)          
+      end
+
+      def index(attributes, options = {})
+        options.assert_valid_keys(:ttl, :order, :limit, :buffer)
+        (cache_config.indices.unshift(Index.new(cache_config, self, attributes, options))).uniq!
+      end
+
+      def version(number)
+        cache_config.options[:version] = number
+      end
+
+      def cache_config=(config)
+        @cache_config = config
+      end
+    end
+
+    class Config
+      attr_reader :active_record, :options
+
+      def self.create(active_record, options, indices = [])
+        active_record.cache_config = new(active_record, options)
+        indices.each { |i| active_record.index i.attributes, i.options }
+      end
+
+      def initialize(active_record, options = {})
+        @active_record, @options = active_record, options
+      end
+
+      def repository
+        @options[:repository]
+      end
+
+      def ttl
+        @options[:ttl]
+      end
+
+      def version
+        @options[:version] || 1
+      end
+
+      def indices
+        @indices ||= active_record == ActiveRecord::Base ? [] : [Index.new(self, active_record, active_record.primary_key)]
+      end
+
+      def inherit(active_record)
+        self.class.create(active_record, @options, indices)
+      end
+    end
+  end
+end

data/lib/cash/finders.rb

@@ -0,0 +1,38 @@
+module Cash
+  module Finders
+    def self.included(active_record_class)
+      active_record_class.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def self.extended(active_record_class)
+        class << active_record_class
+          alias_method_chain :find_every, :cache
+          alias_method_chain :find_from_ids, :cache
+          alias_method_chain :calculate, :cache
+        end
+      end
+
+      def without_cache(&block)
+        with_scope(:find => {:readonly => true}, &block)
+      end
+
+      # 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))
+      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))
+      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))
+      end
+    end
+  end
+end

data/lib/cash/index.rb

@@ -0,0 +1,207 @@
+module Cash
+  class Index
+    attr_reader :attributes, :options
+    delegate :each, :hash, :to => :@attributes
+    delegate :get, :set, :expire, :find_every_without_cache, :calculate_without_cache, :calculate_with_cache, :incr, :decr, :primary_key, :to => :@active_record
+
+    DEFAULT_OPTIONS = { :ttl => 1.day }
+
+    def initialize(config, active_record, attributes, options = {})
+      @config, @active_record, @attributes, @options = config, active_record, Array(attributes).collect(&:to_s).sort, DEFAULT_OPTIONS.merge(options)
+    end
+
+    def ==(other)
+      case other
+      when Index
+        attributes == other.attributes
+      else
+        attributes == Array(other)
+      end
+    end
+    alias_method :eql?, :==
+
+    module Commands
+      def add(object)
+        clone = object.shallow_clone
+        _, new_attribute_value_pairs = old_and_new_attribute_value_pairs(object)
+        add_to_index_with_minimal_network_operations(new_attribute_value_pairs, clone)
+      end
+
+      def update(object)
+        clone = object.shallow_clone
+        old_attribute_value_pairs, new_attribute_value_pairs = old_and_new_attribute_value_pairs(object)
+        update_index_with_minimal_network_operations(old_attribute_value_pairs, new_attribute_value_pairs, clone)
+      end
+
+      def remove(object)
+        old_attribute_value_pairs, _ = old_and_new_attribute_value_pairs(object)
+        remove_from_index_with_minimal_network_operations(old_attribute_value_pairs, object)
+      end
+
+      def delete(object)
+        old_attribute_value_pairs, _ = old_and_new_attribute_value_pairs(object)
+        key = cache_key(old_attribute_value_pairs)
+        expire(key)
+      end
+    end
+    include Commands
+
+    module Attributes
+      def ttl
+        @ttl ||= options[:ttl] || config.ttl
+      end
+
+      def order
+        @order ||= options[:order] || :asc
+      end
+
+      def limit
+        options[:limit]
+      end
+
+      def buffer
+        options[:buffer]
+      end
+
+      def window
+        limit && limit + buffer
+      end
+    end
+    include Attributes
+
+    def serialize_object(object)
+      primary_key? ? object : object.id
+    end
+
+    def matches?(query)
+      query.calculation? ||
+      (query.order == ['id', order] &&
+      (!limit || (query.limit && query.limit + query.offset <= limit)))
+    end
+
+    private
+    def old_and_new_attribute_value_pairs(object)
+      old_attribute_value_pairs = []
+      new_attribute_value_pairs = []
+      @attributes.each do |name|
+        new_value = object.attributes[name]
+        original_value = object.send("#{name}_was")
+        old_attribute_value_pairs << [name, original_value]
+        new_attribute_value_pairs << [name, new_value]
+      end
+      [old_attribute_value_pairs, new_attribute_value_pairs]
+    end
+
+    def add_to_index_with_minimal_network_operations(attribute_value_pairs, object)
+      if primary_key?
+        add_object_to_primary_key_cache(attribute_value_pairs, object)
+      else
+        add_object_to_cache(attribute_value_pairs, object)
+      end
+    end
+
+    def primary_key?
+      @attributes.size == 1 && @attributes.first == primary_key
+    end
+
+    def add_object_to_primary_key_cache(attribute_value_pairs, object)
+      set(cache_key(attribute_value_pairs), [object], :ttl => ttl)
+    end
+
+    def cache_key(attribute_value_pairs)
+      attribute_value_pairs.flatten.join('/')
+    end
+
+    def add_object_to_cache(attribute_value_pairs, object, overwrite = true)
+      return if invalid_cache_key?(attribute_value_pairs)
+
+      key, cache_value, cache_hit = get_key_and_value_at_index(attribute_value_pairs)
+      if !cache_hit || overwrite
+        object_to_add = serialize_object(object)
+        objects = (cache_value + [object_to_add]).sort do |a, b|
+          (a <=> b) * (order == :asc ? 1 : -1)
+        end.uniq
+        objects = truncate_if_necessary(objects)
+        set(key, objects, :ttl => ttl)
+        incr("#{key}/count") { calculate_at_index(:count, attribute_value_pairs) }
+      end
+    end
+
+    def invalid_cache_key?(attribute_value_pairs)
+      attribute_value_pairs.collect { |_,value| value }.any? { |x| x.nil? }
+    end
+
+    def get_key_and_value_at_index(attribute_value_pairs)
+      key = cache_key(attribute_value_pairs)
+      cache_hit = true
+      cache_value = get(key) do
+        cache_hit = false
+        conditions = attribute_value_pairs.to_hash
+        find_every_without_cache(:select => primary_key, :conditions => conditions, :limit => window).collect do |object|
+          serialize_object(object)
+        end
+      end
+      [key, cache_value, cache_hit]
+    end
+
+    def truncate_if_necessary(objects)
+      objects.slice(0, window || objects.size)
+    end
+
+    def calculate_at_index(operation, attribute_value_pairs)
+      conditions = attribute_value_pairs.to_hash
+      calculate_without_cache(operation, :all, :conditions => conditions)
+    end
+
+    def update_index_with_minimal_network_operations(old_attribute_value_pairs, new_attribute_value_pairs, object)
+      if index_is_stale?(old_attribute_value_pairs, new_attribute_value_pairs)
+        remove_object_from_cache(old_attribute_value_pairs, object)
+        add_object_to_cache(new_attribute_value_pairs, object)
+      elsif primary_key?
+        add_object_to_primary_key_cache(new_attribute_value_pairs, object)
+      else
+        add_object_to_cache(new_attribute_value_pairs, object, false)
+      end
+    end
+
+    def index_is_stale?(old_attribute_value_pairs, new_attribute_value_pairs)
+      old_attribute_value_pairs != new_attribute_value_pairs
+    end
+
+    def remove_from_index_with_minimal_network_operations(attribute_value_pairs, object)
+      if primary_key?
+        remove_object_from_primary_key_cache(attribute_value_pairs, object)
+      else
+        remove_object_from_cache(attribute_value_pairs, object)
+      end
+    end
+
+    def remove_object_from_primary_key_cache(attribute_value_pairs, object)
+      set(cache_key(attribute_value_pairs), [], :ttl => ttl)
+    end
+
+    def remove_object_from_cache(attribute_value_pairs, object)
+      return if invalid_cache_key?(attribute_value_pairs)
+
+      key, cache_value, _ = get_key_and_value_at_index(attribute_value_pairs)
+      object_to_remove = serialize_object(object)
+      objects = cache_value - [object_to_remove]
+      objects = resize_if_necessary(attribute_value_pairs, objects)
+      set(key, objects, :ttl => ttl)
+    end
+
+    def resize_if_necessary(attribute_value_pairs, objects)
+      conditions = attribute_value_pairs.to_hash
+      key = cache_key(attribute_value_pairs)
+      count = decr("#{key}/count") { calculate_at_index(:count, attribute_value_pairs) }
+
+      if limit && objects.size < limit && objects.size < count
+        find_every_without_cache(:select => :id, :conditions => conditions).collect do |object|
+          serialize_object(object)
+        end
+      else
+        objects
+      end
+    end
+  end
+end