viximo-cache-money 0.3.0

data/lib/cash/local.rb

@@ -0,0 +1,105 @@
+module Cash
+  class Local
+    def initialize(remote_cache)
+      @remote_cache = remote_cache
+    end
+
+    def cache_locally
+      @remote_cache = LocalBuffer.new(original_cache = @remote_cache)
+      yield if block_given?
+    ensure
+      @remote_cache = original_cache
+    end
+    
+    def autoload_missing_constants
+      yield if block_given?
+    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
+      else
+        raise error
+      end
+    end
+
+    def respond_to?(method)
+      super || @remote_cache.respond_to?(method)
+    end
+
+    private
+    
+    def method_missing(method, *args, &block)
+      autoload_missing_constants do
+        @remote_cache.send(method, *args, &block)
+      end
+    end
+  end
+
+  class LocalBuffer
+    delegate :respond_to?, :to => :@remote_cache
+    MULTI_GET_RESULTS_THRESHOLD = 1
+
+    def initialize(remote_cache)
+      @local_cache = {}
+      @remote_cache = remote_cache
+    end
+
+    def get(key, *options)
+      if @local_cache.has_key?(key)
+        @local_cache[key]
+      else
+        @local_cache[key] = @remote_cache.get(key, *options)
+      end
+    end
+
+    # Model.find_by_index() uses get_multi to get the object after getting the id through the index.
+    # Simplest way of utilizing the local cache is to override get_multi and use
+    # a threshold of 1. Using a higher threshold could be an optimization for get_multi calls
+    # returning more than one value.
+    def get_multi(keys, *options)
+      results = {}
+      remaining_keys = []
+      keys.each do |key|
+        if @local_cache.has_key?(key)
+          results[key] = @local_cache[key]
+        else
+          remaining_keys << key
+        end
+      end
+      if !remaining_keys.empty?
+        multi = @remote_cache.get_multi(remaining_keys, *options)
+        if multi
+          multi.each do |k,v|
+            @local_cache[k] = v if multi.size() <= MULTI_GET_RESULTS_THRESHOLD
+            results[k] = v
+          end
+        end
+      end
+      results
+    end
+
+    def set(key, value, *options)
+      @remote_cache.set(key, value, *options)
+      @local_cache[key] = value
+    end
+
+    def add(key, value, *options)
+      result = @remote_cache.add(key, value, *options)
+      if result == "STORED\r\n"
+        @local_cache[key] = value
+      end
+      result
+    end
+
+    def delete(key, *options)
+      @remote_cache.delete(key, *options)
+      @local_cache.delete(key)
+    end
+
+    private
+    
+    def method_missing(method, *args, &block)
+      @remote_cache.send(method, *args, &block)
+    end
+  end
+end

data/lib/cash/lock.rb

@@ -0,0 +1,63 @@
+require 'socket'
+
+module Cash
+  class Lock
+    class Error < RuntimeError; end
+
+    INITIAL_WAIT = 2
+    DEFAULT_RETRY = 8
+    DEFAULT_EXPIRY = 30
+
+    def initialize(cache)
+      @cache = cache
+    end
+
+    def synchronize(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY, initial_wait = INITIAL_WAIT)
+      if recursive_lock?(key)
+        yield
+      else
+        acquire_lock(key, lock_expiry, retries, initial_wait)
+        begin
+          yield
+        ensure
+          release_lock(key)
+        end
+      end
+    end
+
+    def acquire_lock(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY, initial_wait = INITIAL_WAIT)
+      retries.times do |count|
+        response = @cache.add("lock/#{key}", host_pid, lock_expiry)
+        return if response == "STORED\r\n"
+        return if recursive_lock?(key)
+        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}")}"
+    end
+
+    def release_lock(key)
+      @cache.delete("lock/#{key}")
+    end
+
+    def exponential_sleep(count, initial_wait)
+      sleep((2**count) / initial_wait)
+    end
+
+    private
+
+    def recursive_lock?(key)
+      @cache.get("lock/#{key}") == host_pid
+    end
+
+    def debug_lock(key)
+      @cache.logger.warn("Cash::Lock[#{key}]: #{@cache.get("lock/#{key}")}") if @cache.respond_to?(:logger) && @cache.logger.respond_to?(:warn)
+    rescue
+      @cache.logger.warn("#{$!}") if @cache.respond_to?(:logger) && @cache.logger.respond_to?(:warn)
+    end
+    
+    def host_pid
+      "#{Socket.gethostname} #{Process.pid}"
+    end
+  end
+end

data/lib/cash/mock.rb

@@ -0,0 +1,158 @@
+module Cash
+  class Mock < HashWithIndifferentAccess
+    attr_accessor :servers
+
+    class CacheEntry
+      attr_reader :value
+      
+      def self.default_ttl
+        1_000_000
+      end
+
+      def self.now
+        Time.now
+      end
+      
+      def initialize(value, raw, ttl)
+        if raw
+          @value = value.to_s
+        else
+          @value = Marshal.dump(value)
+        end
+        
+        if ttl.nil? || ttl.zero?
+          @ttl = self.class.default_ttl
+        else
+          @ttl = ttl
+        end
+        
+        @expires_at = self.class.now + @ttl
+      end
+      
+      
+      def expired?
+        self.class.now > @expires_at
+      end
+      
+      def increment(amount = 1)
+        @value = (@value.to_i + amount).to_s
+      end
+      
+      def decrement(amount = 1)
+        @value = (@value.to_i - amount).to_s
+      end
+      
+      def unmarshal
+        Marshal.load(@value)
+      end
+      
+      def to_i
+        @value.to_i
+      end
+    end
+    
+    attr_accessor :logging
+    
+    def initialize
+      @logging = false
+    end
+    
+    def get_multi(*keys)
+      slice(*keys).collect { |k,v| [k, v.unmarshal] }.to_hash_without_nils
+    end
+
+    def set(key, value, ttl = CacheEntry.default_ttl, raw = false)
+      log "< set #{key} #{ttl}"
+      self[key] = CacheEntry.new(value, raw, ttl)
+      log('> STORED')
+    end
+
+    def get(key, raw = false)
+      if key.is_a?(Array)
+        get_multi(*key)
+      else
+        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
+    
+    def delete(key, options = {})
+      log "< delete #{key}"
+      if self.has_unexpired_key?(key)
+        log "> DELETED"
+        super(key)
+      else
+        log "> NOT FOUND"
+      end
+    end
+
+    def incr(key, amount = 1)
+      if self.has_unexpired_key?(key)
+        self[key].increment(amount)
+        self[key].to_i
+      end
+    end
+
+    def decr(key, amount = 1)
+      if self.has_unexpired_key?(key)
+        self[key].decrement(amount)
+        self[key].to_i
+      end
+    end
+
+    def add(key, value, ttl = CacheEntry.default_ttl, raw = false)
+      if self.has_unexpired_key?(key)
+        "NOT_STORED\r\n"
+      else
+        set(key, value, ttl, raw)
+        "STORED\r\n"
+      end
+    end
+
+    def append(key, value)
+      set(key, get(key, true).to_s + value.to_s, nil, true)
+    end
+
+    def namespace
+      nil
+    end
+
+    def flush_all
+      log('< flush_all')
+      clear
+    end
+
+    def stats
+      {}
+    end
+
+    def reset_runtime
+      [0, Hash.new(0)]
+    end
+
+    def has_unexpired_key?(key)
+      self.has_key?(key) && !self[key].expired?
+    end
+    
+    def log(message)
+      return unless logging
+      logger.debug(message)
+    end
+    
+    def logger
+      @logger ||= ActiveSupport::BufferedLogger.new(Rails.root.join('log/cash_mock.log'))
+    end
+    
+  end
+end

data/lib/cash/query/abstract.rb

@@ -0,0 +1,219 @@
+module Cash
+  module Query
+    class Abstract
+      delegate :with_exclusive_scope, :get, :table_name, :indices, :find_from_ids_without_cache, :cache_key, :columns_hash, :logger, :to => :@active_record
+
+      def self.perform(*args)
+        new(*args).perform
+      end
+
+      def initialize(active_record, options1, options2)
+        @active_record, @options1, @options2 = active_record, options1, options2 || {}
+
+        # if @options2.empty? and active_record.base_class != active_record
+        #   @options2 = { :conditions => { active_record.inheritance_column => active_record.to_s }}
+        # end
+        # if active_record.base_class != active_record
+        #   @options2[:conditions] = active_record.merge_conditions(
+        #     @options2[:conditions], { active_record.inheritance_column => active_record.to_s }
+        #   )
+        # end
+      end
+
+      def perform(find_options = {}, get_options = {})
+        if cache_config = cacheable?(@options1, @options2, find_options)
+          cache_keys, index = cache_keys(cache_config[0]), cache_config[1]
+
+          misses, missed_keys, objects = hit_or_miss(cache_keys, index, get_options)
+          format_results(cache_keys, choose_deserialized_objects_if_possible(missed_keys, cache_keys, misses, objects))
+        else
+          logger.debug("  \e[1;4;31mUNCACHEABLE\e[0m #{table_name} - #{find_options.inspect} - #{get_options.inspect} - #{@options1.inspect} - #{@options2.inspect}") if logger
+          uncacheable
+        end
+      end
+
+      DESC = /DESC/i
+
+      def order
+        @order ||= begin
+          if order_sql = @options1[:order] || @options2[:order]
+            matched, table_name, column_name, direction = *(ORDER.match(order_sql.to_s))
+            [column_name, direction =~ DESC ? :desc : :asc]
+          else
+            ['id', :asc]
+          end
+        end
+      rescue TypeError
+        ['id', :asc]
+      end
+
+      def limit
+        @limit ||= @options1[:limit] || @options2[:limit]
+      end
+
+      def offset
+        @offset ||= @options1[:offset] || @options2[:offset] || 0
+      end
+
+      def calculation?
+        false
+      end
+
+      private
+      def cacheable?(*optionss)
+        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] }
+
+        # attribute_value_pairs.each do |attribute_value_pair|
+        #   return false if attribute_value_pair.last.is_a?(Array)
+        # end
+
+        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
+
+      def hit_or_miss(cache_keys, index, options)
+        misses, missed_keys = nil, nil
+        objects = @active_record.get(cache_keys, options.merge(:ttl => index.ttl)) do |missed_keys|
+          misses = miss(missed_keys, @options1.merge(:limit => index.window))
+          serialize_objects(index, misses)
+        end
+        [misses, missed_keys, objects]
+      end
+
+      def cache_keys(attribute_value_pairs)
+        attribute_value_pairs.flatten.join('/')
+      end
+
+      def safe_options_for_cache?(options)
+        return false unless options.kind_of?(Hash)
+        options.except(:conditions, :readonly, :limit, :offset, :order).values.compact.empty? && !options[:readonly]
+      end
+
+      def attribute_value_pairs_for_conditions(conditions)
+        case conditions
+        when Hash
+          conditions.to_a.collect { |key, value| [key.to_s, value.is_a?(ActiveRecord::Base) ? value.id : value] }
+        when String
+          parse_indices_from_condition(conditions.gsub('1 = 1 AND ', '')) #ignore unnecessary conditions
+        when Array
+          parse_indices_from_condition(*conditions)
+        when NilClass
+          []
+        end
+      end
+
+      AND = /\s+AND\s+/i
+      TABLE_AND_COLUMN = /(?:(?:`|")?(\w+)(?:`|")?\.)?(?:`|")?(\w+)(?:`|")?/              # Matches: `users`.id, `users`.`id`, users.id, id
+      VALUE = /'?(\d+|\?|(?:(?:[^']|'')*))'?/                     # Matches: 123, ?, '123', '12''3'
+      KEY_EQ_VALUE = /^\(?#{TABLE_AND_COLUMN}\s+=\s+#{VALUE}\)?$/ # Matches: KEY = VALUE, (KEY = VALUE)
+      ORDER = /^#{TABLE_AND_COLUMN}\s*(ASC|DESC)?$/i              # Matches: COLUMN ASC, COLUMN DESC, COLUMN
+
+      def parse_indices_from_condition(conditions = '', *values)
+        values = values.dup
+        conditions.split(AND).inject([]) do |indices, condition|
+          matched, table_name, column_name, sql_value = *(KEY_EQ_VALUE.match(condition))
+          if matched
+            # value = sql_value == '?' ? values.shift : columns_hash[column_name].type_cast(sql_value)
+            if sql_value == '?'
+              value = values.shift
+            else
+              column = columns_hash[column_name]
+              raise "could not find column #{column_name} in columns #{columns_hash.keys.join(',')}" if column.nil?
+              if sql_value[0..0] == ':' && values && values.count > 0 && values[0].is_a?(Hash)
+                symb  = sql_value[1..-1].to_sym
+                value = column.type_cast(values[0][symb])
+              else
+                value = column.type_cast(sql_value)
+              end
+            end
+            indices << [column_name, value.is_a?(ActiveRecord::Base) ? value.id : value]
+          else
+            return nil
+          end
+        end
+      end
+
+      def indexed_on?(attributes)
+        indices.detect { |index| index == attributes }
+      rescue NoMethodError
+        nil
+      end
+      alias_method :index_for, :indexed_on?
+
+      def format_results(cache_keys, objects)
+        return objects if objects.blank?
+
+        objects = convert_to_array(cache_keys, objects)
+        objects = apply_limits_and_offsets(objects, @options1)
+        deserialize_objects(objects)
+      end
+
+      def choose_deserialized_objects_if_possible(missed_keys, cache_keys, misses, objects)
+        missed_keys == cache_keys ? misses : objects
+      end
+
+      def serialize_objects(index, objects)
+        Array(objects).collect { |missed| index.serialize_object(missed) }
+      end
+
+      def convert_to_array(cache_keys, object)
+        if object.kind_of?(Hash)
+          cache_keys.collect { |key| object[cache_key(key)] }.flatten.compact
+        else
+          Array(object)
+        end
+      end
+
+      def apply_limits_and_offsets(results, options)
+        results.slice((options[:offset] || 0), (options[:limit] || results.length))
+      end
+
+      def deserialize_objects(objects)
+        if objects.first.kind_of?(ActiveRecord::Base)
+          objects
+        else
+          cache_keys = objects.collect { |id| "id/#{id}" }
+          with_exclusive_scope(:find => {}) { objects = get(cache_keys, &method(:find_from_keys)) }
+          convert_to_array(cache_keys, objects)
+        end
+      end
+
+      def find_from_keys(*missing_keys)
+        missing_ids = Array(missing_keys).flatten.collect { |key| key.split('/')[2].to_i }
+        options = {}
+        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)
+        results
+      end
+    end
+  end
+end