sreeix-cache-money 0.2.24.1

data/lib/cash/index.rb

@@ -0,0 +1,214 @@
+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, :logger, :to => :@active_record
+
+    DEFAULT_OPTIONS = { :ttl => 1.day.to_i }
+
+    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)
+    end
+
+    def ==(other)
+      case other
+      when Index
+        attributes == other.attributes
+      else
+        attributes == Array(other)
+      end
+    end
+    alias_method :eql?, :==
+
+    module Commands
+      def add(object)
+        _, new_attribute_value_pairs = old_and_new_attribute_value_pairs(object)
+        add_to_index_with_minimal_network_operations(new_attribute_value_pairs, object)
+      end
+
+      def update(object)
+        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, object)
+      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
+      
+      def order_column
+        options[:order_column] || 'id'
+      end
+    end
+    include Attributes
+
+    def serialize_object(object)
+      primary_key? ? object.shallow_clone : object.id
+    end
+
+    def matches?(query)
+      query.calculation? ||
+      (query.order == [order_column, 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]
+        if object.changed.include? name
+          original_value = object.send("#{name}_was")
+        else
+          original_value = new_value
+        end
+        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), [serialize_object(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_without_nils
+        find_every_without_cache(: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_without_nils
+      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_without_nils
+      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

data/lib/cash/local.rb

@@ -0,0 +1,76 @@
+module Cash
+  class Local
+    delegate :respond_to?, :to => :@remote_cache
+
+    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, MemCache::MemCacheError => 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
+
+    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
+
+    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
+
+    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,154 @@
+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.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)
+      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
+    
+    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