sreeix-cache-money 0.2.24.1

data/lib/cash/query/abstract.rb

@@ -0,0 +1,210 @@
+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 || {}
+      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] }
+        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]
+          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

data/lib/cash/query/calculation.rb

@@ -0,0 +1,45 @@
+module Cash
+  module Query
+    class Calculation < Abstract
+      delegate :calculate_without_cache, :incr, :to => :@active_record
+
+      def initialize(active_record, operation, column, options1, options2)
+        super(active_record, options1, options2)
+        @operation, @column = operation, column
+      end
+
+      def perform
+        super({}, :raw => true)
+      end
+
+      def calculation?
+        true
+      end
+
+      protected
+      def miss(_, __)
+        calculate_without_cache(@operation, @column, @options1)
+      end
+
+      def uncacheable
+        calculate_without_cache(@operation, @column, @options1)
+      end
+
+      def format_results(_, objects)
+        objects.to_i
+      end
+
+      def serialize_objects(_, objects)
+        objects.to_s
+      end
+
+      def cacheable?(*optionss)
+        @column == :all && super(*optionss)
+      end
+
+      def cache_keys(attribute_value_pairs)
+        "#{super(attribute_value_pairs)}/#{@operation}"
+      end
+    end
+  end
+end

data/lib/cash/query/primary_key.rb

@@ -0,0 +1,50 @@
+module Cash
+  module Query
+    class PrimaryKey < Abstract
+      def initialize(active_record, ids, options1, options2)
+        super(active_record, options1, options2)
+        @expects_array = ids.first.kind_of?(Array)
+        @original_ids = ids
+        @ids = ids.flatten.compact.uniq.collect do |object|
+          object.respond_to?(:quoted_id) ? object.quoted_id : object.to_i
+        end
+      end
+
+      def perform
+        return [] if @expects_array && @ids.empty?
+        raise ActiveRecord::RecordNotFound if @ids.empty?
+
+        super(:conditions => { :id => @ids.first })
+      end
+
+      protected
+      def deserialize_objects(objects)
+        convert_to_active_record_collection(super(objects))
+      end
+
+      def cache_keys(attribute_value_pairs)
+        @ids.collect { |id| "id/#{id}" }
+      end
+
+      def miss(missing_keys, options)
+        find_from_keys(*missing_keys)
+      end
+
+      def uncacheable
+        find_from_ids_without_cache(@original_ids, @options1)
+      end
+
+      private
+      def convert_to_active_record_collection(objects)
+        case objects.size
+        when 0
+          raise ActiveRecord::RecordNotFound
+        when 1
+          @expects_array ? objects : objects.first
+        else
+          objects
+        end
+      end
+    end
+  end
+end

data/lib/cash/query/select.rb

@@ -0,0 +1,16 @@
+module Cash
+  module Query
+    class Select < Abstract
+      delegate :find_every_without_cache, :to => :@active_record
+
+      protected
+      def miss(_, miss_options)
+        find_every_without_cache(miss_options)
+      end
+
+      def uncacheable
+        find_every_without_cache(@options1)
+      end
+    end
+  end
+end

data/lib/cash/request.rb

@@ -0,0 +1,3 @@
+module Cash
+  Request = {}
+end

data/lib/cash/transactional.rb

@@ -0,0 +1,43 @@
+module Cash
+  class Transactional
+    attr_reader :memcache
+
+    def initialize(memcache, lock)
+      @memcache, @cache = [memcache, memcache]
+      @lock = lock
+    end
+
+    def transaction
+      exception_was_raised = false
+      begin_transaction
+      result = yield
+    rescue Object => e
+      exception_was_raised = true
+      raise
+    ensure
+      begin
+        @cache.flush unless exception_was_raised
+      ensure
+        end_transaction
+      end
+    end
+
+    def respond_to?(method)
+      @cache.respond_to?(method)
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      @cache.send(method, *args, &block)
+    end
+
+    def begin_transaction
+      @cache = Buffered.push(@cache, @lock)
+    end
+
+    def end_transaction
+      @cache = @cache.pop
+    end
+  end
+end

data/lib/cash/util/array.rb

@@ -0,0 +1,9 @@
+class Array
+  alias_method :count, :size
+
+  def to_hash_without_nils
+    keys_and_values_without_nils = reject { |key, value| value.nil? }
+    shallow_flattened_keys_and_values_without_nils = keys_and_values_without_nils.inject([]) { |result, pair| result += pair }
+    Hash[*shallow_flattened_keys_and_values_without_nils]
+  end
+end

data/lib/cash/util/marshal.rb

@@ -0,0 +1,19 @@
+module Marshal
+  class << self
+    def constantize(name)
+      name.constantize
+    end
+
+    def load_with_constantize(value)
+      begin
+        Marshal.load_without_constantize value
+      rescue ArgumentError => e
+        _, class_name = *(/undefined class\/module ([\w:]*\w)/.match(e.message))
+        raise if !class_name
+        constantize(class_name)
+        Marshal.load value
+      end
+    end
+    alias_method_chain :load, :constantize
+  end
+end

data/lib/cash/write_through.rb

@@ -0,0 +1,69 @@
+module Cash
+  module WriteThrough
+    DEFAULT_TTL = 12.hours
+
+    def self.included(active_record_class)
+      active_record_class.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    module InstanceMethods
+      def self.included(active_record_class)
+        active_record_class.class_eval do
+          after_create :add_to_caches
+          after_update :update_caches
+          after_destroy :remove_from_caches
+        end
+      end
+
+      def add_to_caches
+        InstanceMethods.unfold(self.class, :add_to_caches, self)
+      end
+
+      def update_caches
+        InstanceMethods.unfold(self.class, :update_caches, self)
+      end
+
+      def remove_from_caches
+        return if new_record?
+        InstanceMethods.unfold(self.class, :remove_from_caches, self)
+      end
+
+      def expire_caches
+        InstanceMethods.unfold(self.class, :expire_caches, self)
+      end
+
+      def shallow_clone
+        self.class.send(:instantiate, instance_variable_get(:@attributes))
+      end
+
+      private
+      def self.unfold(klass, operation, object)
+        while klass < ActiveRecord::Base && klass.ancestors.include?(WriteThrough)
+          klass.send(operation, object)
+          klass = klass.superclass
+        end
+      end
+    end
+
+    module ClassMethods
+      def add_to_caches(object)
+        indices.each { |index| index.add(object) } if cache_config
+      end
+
+      def update_caches(object)
+        indices.each { |index| index.update(object) } if cache_config
+      end
+
+      def remove_from_caches(object)
+        indices.each { |index| index.remove(object) } if cache_config
+      end
+
+      def expire_caches(object)
+        indices.each { |index| index.delete(object) } if cache_config
+      end
+    end
+  end
+end

data/lib/mem_cached_session_store.rb

@@ -0,0 +1,49 @@
+# begin
+  require 'memcached'
+
+      class MemCachedSessionStore < ActionController::Session::AbstractStore
+        def initialize(app, options = {})
+          # Support old :expires option
+          options[:expire_after] ||= options[:expires]
+
+          super
+
+          @default_options = {
+            :namespace => 'rack:session',
+            :servers => 'localhost:11211'
+          }.merge(@default_options)
+
+          @default_options[:prefix_key] ||= @default_options[:namespace]
+
+          @pool = options[:cache] || Memcached.new(@default_options[:servers], @default_options)
+          # unless @pool.servers.any? { |s| s.alive? }
+          #   raise "#{self} unable to find server during initialization."
+          # end
+          @mutex = Mutex.new
+
+          super
+        end
+
+        private
+          def get_session(env, sid)
+            sid ||= generate_sid
+            begin
+              session = @pool.get(sid) || {}
+            rescue Memcached::NotFound, MemCache::MemCacheError, Errno::ECONNREFUSED
+              session = {}
+            end
+            [sid, session]
+          end
+
+          def set_session(env, sid, session_data)
+            options = env['rack.session.options']
+            expiry  = options[:expire_after] || 0
+            @pool.set(sid, session_data, expiry)
+            return true
+          rescue Memcached::NotStored, MemCache::MemCacheError, Errno::ECONNREFUSED
+            return false
+          end
+      end
+# rescue LoadError
+#   # Memcached wasn't available so neither can the store be
+# end

data/lib/mem_cached_support_store.rb

@@ -0,0 +1,135 @@
+require 'memcached'
+
+    # A cache store implementation which stores data in Memcached:
+    # http://www.danga.com/memcached/
+    #
+    # This is currently the most popular cache store for production websites.
+    #
+    # Special features:
+    # - Clustering and load balancing. One can specify multiple memcached servers,
+    #   and MemCacheStore will load balance between all available servers. If a
+    #   server goes down, then MemCacheStore will ignore it until it goes back
+    #   online.
+    # - Time-based expiry support. See #write and the +:expires_in+ option.
+    # - Per-request in memory cache for all communication with the MemCache server(s).
+    class MemCachedSupportStore < ActiveSupport::Cache::Store
+
+      attr_reader :addresses
+
+      # Creates a new MemCacheStore object, with the given memcached server
+      # addresses. Each address is either a host name, or a host-with-port string
+      # in the form of "host_name:port". For example:
+      #
+      #   ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")
+      #
+      # If no addresses are specified, then MemCacheStore will connect to
+      # localhost port 11211 (the default memcached port).
+      def initialize(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        options[:prefix_key] ||= options[:namespace]
+        addresses = ["localhost"] if addresses.empty?
+        @addresses = addresses
+        @data = Memcached.new(addresses, options)
+
+        extend ActiveSupport::Cache::Strategy::LocalCache
+      end
+
+      def read(key, options = nil) # :nodoc:
+        super
+        @data.get(key, marshal?(options))
+      rescue Memcached::NotFound
+        nil
+      rescue Memcached::Error => e
+        logger.error("MemcachedError (#{e}): #{e.message}")
+        nil
+      end
+
+      # Writes a value to the cache.
+      #
+      # Possible options:
+      # - +:unless_exist+ - set to true if you don't want to update the cache
+      #   if the key is already set.
+      # - +:expires_in+ - the number of seconds that this value may stay in
+      #   the cache. See ActiveSupport::Cache::Store#write for an example.
+      def write(key, value, options = nil)
+        super
+        method = options && options[:unless_exist] ? :add : :set
+        # memcache-client will break the connection if you send it an integer
+        # in raw mode, so we convert it to a string to be sure it continues working.
+        @data.send(method, key, value, expires_in(options), marshal?(options))
+        true
+      rescue Memcached::NotStored
+        false
+      rescue Memcached::NotFound
+        false
+      rescue Memcached::Error => e
+        logger.error("MemcachedError (#{e}): #{e.message}")
+        false
+      end
+
+      def delete(key, options = nil) # :nodoc:
+        super
+        @data.delete(key)
+        true
+      rescue Memcached::NotFound
+        false
+      rescue Memcached::Error => e
+        logger.error("MemcachedError (#{e}): #{e.message}")
+        false
+      end
+
+      def exist?(key, options = nil) # :nodoc:
+        # Doesn't call super, cause exist? in memcache is in fact a read
+        # But who cares? Reading is very fast anyway
+        # Local cache is checked first, if it doesn't know then memcache itself is read from
+        !read(key, options).nil?
+      end
+
+      def increment(key, amount = 1) # :nodoc:
+        log("incrementing", key, amount)
+
+        @data.incr(key, amount)
+        response
+      rescue Memcached::NotFound
+        nil
+      rescue Memcached::Error
+        nil
+      end
+
+      def decrement(key, amount = 1) # :nodoc:
+        log("decrement", key, amount)
+        @data.decr(key, amount)
+        response
+      rescue Memcached::NotFound
+        nil
+      rescue Memcached::Error
+        nil
+      end
+
+      def delete_matched(matcher, options = nil) # :nodoc:
+        # don't do any local caching at present, just pass
+        # through and let the error happen
+        super
+        raise "Not supported by Memcache"
+      end
+
+      def clear
+        @data.flush
+      rescue Memcached::NotFound
+      end
+
+      def stats
+        @data.stats
+      rescue Memcached::NotFound
+      end
+
+      private
+        def expires_in(options)
+          (options && options[:expires_in] && options[:expires_in].to_i) || 0
+        end
+
+        def marshal?(options)
+          !(options && options[:raw])
+        end
+    end