artemk-cache-money 0.2.13.2

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/active_record.rb

@@ -0,0 +1,5 @@
+class ActiveRecord::Base
+  def <=>(other)
+    self.id.to_i <=> other.id.to_i
+  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,50 @@
+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 Exception => e
+   # Memcached wasn't available so neither can the store be.  Reraise any other error.
+   raise unless e.is_a?(LoadError) && e.message =~ /memcached/
+end

data/lib/mem_cached_support_store.rb

@@ -0,0 +1,141 @@
+begin
+  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]) || 0
+        end
+
+        def marshal?(options)
+          !(options && options[:raw])
+        end
+    end
+  
+rescue Exception => e
+   # Memcached wasn't available so neither can the store be.  Reraise any other error.
+   raise unless e.is_a?(LoadError) && e.message =~ /memcached/
+end

data/lib/memcached_wrapper.rb

@@ -0,0 +1,261 @@
+# require 'memcache'
+# require 'memcached'
+
+#typically MemCache/Memcached can be used via the following in rails/init.rb:
+#$memcache = MemCache.new(memcache_config[:servers].gsub(' ', '').split(','), memcache_config)
+#$memcache = Memcached::Rails.new(memcache_config[:servers].gsub(' ', '').split(','), memcache_config)
+
+#this wrapper lets both work.
+
+########## they have Memcached installed (do need the wrapper)
+if defined? Memcached
+Rails.logger.info("cache-money: Memcached installed") if defined? Rails
+
+class Memcached
+  alias :get_multi :get #:nodoc:
+end
+
+class MemcachedWrapper < ::Memcached
+  DEFAULTS = { :servers => '127.0.0.1:11211' }
+
+  attr_reader :logger, :default_ttl
+
+  # See Memcached#new for details.
+  def initialize(*args)
+      opts = DEFAULTS.merge(args.last.is_a?(Hash) ? args.pop : {})
+
+      if opts.respond_to?(:symbolize_keys!)
+        opts.symbolize_keys!
+      else
+        opts = symbolize_keys(opts)
+      end
+      
+      servers = Array(
+        args.any? ? args.unshift : opts.delete(:servers)
+      ).flatten.compact
+
+      opts[:prefix_key] ||= "#{opts[:namespace]}:"
+
+      @logger = opts[:logger]
+      @debug  = opts[:debug]
+
+      super(servers, opts)      
+  end
+
+  def symbolize_keys(opts)
+    # Destructively convert all keys to symbols.
+    if opts.kind_of?(Hash) && !opts.kind_of?(HashWithIndifferentAccess)
+      opts.keys.each do |key|
+        unless key.is_a?(Symbol)
+          opts[key.to_sym] = opts[key]
+          opts.delete(key)
+        end
+      end
+    end
+    opts
+  end
+  
+  def namespace
+    options[:prefix_key]
+  end
+
+  # Wraps Memcached::Rails#add to return a text string - for cache money
+  def add(key, value, ttl=@default_ttl, raw=false)
+    logger.debug("Memcached add: #{key.inspect}") if logger && @debug
+    super(key, value, ttl, !raw)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    stored
+  rescue Memcached::NotStored
+    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
+    not_stored
+  rescue Memcached::Error
+    log_error($!) if logger
+    not_stored
+  end
+
+  def replace(key, value, ttl = @default_ttl, raw = false)
+    logger.debug("Memcached replace: #{key.inspect}") if logger && @debug
+    super(key, value, ttl, !raw)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    stored
+  rescue Memcached::NotStored
+    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
+    not_stored
+  rescue Memcached::Error
+    log_error($!) if logger
+    not_stored
+  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)
+    logger.debug("Memcached get: #{key.inspect}") if logger && @debug
+    value = super(key, !raw)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    value
+  rescue Memcached::NotFound
+    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
+    nil
+  rescue TypeError
+    log_error($!) if logger
+    delete(key)
+    logger.debug("Memcached deleted: #{key.inspect}") if logger && @debug
+    nil
+  rescue Memcached::Error
+    log_error($!) if logger
+    nil
+  end
+
+  def fetch(key, expiry = 0, raw = false)
+    value = get(key, !raw)
+
+    if value.nil? && block_given?
+      value = yield
+      add(key, value, expiry, !raw)
+    end
+
+    value
+  end
+
+  # Wraps Memcached#cas so that it doesn't raise. Doesn't set anything if no value is present.
+  def cas(key, ttl=@default_ttl, raw=false, &block)
+    logger.debug("Memcached cas: #{key.inspect}") if logger && @debug
+    super(key, ttl, !raw, &block)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    stored
+  rescue Memcached::NotFound
+    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
+  rescue TypeError
+    log_error($!) if logger
+    delete(key)
+    logger.debug("Memcached deleted: #{key.inspect}") if logger && @debug
+  rescue Memcached::Error
+    if $!.is_a?(Memcached::ClientError)
+      raise $!
+    end
+    log_error($!) if logger
+  end
+  
+  def get_multi(*keys)
+    keys.flatten!
+    logger.debug("Memcached get_multi: #{keys.inspect}") if logger && @debug
+    values = super(keys, true)
+    logger.debug("Memcached hit: #{keys.inspect}") if logger && @debug
+    values
+  rescue Memcached::NotFound
+    logger.debug("Memcached miss: #{keys.inspect}") if logger && @debug
+    {}
+  rescue TypeError
+    log_error($!) if logger
+    keys.each { |key| delete(key) }
+    logger.debug("Memcached deleted: #{keys.inspect}") if logger && @debug
+    {}
+  rescue Memcached::Error
+    log_error($!) if logger
+    {}
+  end
+
+  def set(key, value, ttl=@default_ttl, raw=false)
+    logger.debug("Memcached set: #{key.inspect}") if logger && @debug
+    super(key, value, ttl, !raw)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    stored
+  rescue Memcached::Error
+    log_error($!) if logger
+    not_stored
+  end
+
+  def append(key, value)
+    logger.debug("Memcached append: #{key.inspect}") if logger && @debug
+    super(key, value)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    stored
+  rescue Memcached::NotStored
+    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
+    not_stored
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+
+  def prepend(key, value)
+    logger.debug("Memcached prepend: #{key.inspect}") if logger && @debug
+    super(key, value)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    stored
+  rescue Memcached::NotStored
+    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
+    not_stored
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+
+  def delete(key)
+    logger.debug("Memcached delete: #{key.inspect}") if logger && @debug
+    super(key)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    deleted
+  rescue Memcached::NotFound
+    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
+    not_found
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+  
+  def incr(*args)
+    super
+  rescue Memcached::NotFound
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+
+  def decr(*args)
+    super
+  rescue Memcached::NotFound
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+
+  def get_server_for_key(key, options = {})
+    server_by_key(key)
+  end
+
+  alias :reset :quit
+  alias :close :quit #nodoc
+  alias :flush_all :flush
+  alias :compare_and_swap :cas
+  alias :"[]" :get
+  alias :"[]=" :set    
+
+private
+
+  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
+####### they have MemCache installed (don't need the wrapper)
+elsif defined? MemCache
+  Rails.logger.info("cache-money: MemCache installed") if defined? Rails
+  #TODO add logging?
+  class MemcachedWrapper < ::MemCache
+  end
+else
+  Rails.logger.warn 'unable to determine memcache implementation' if defined? Rails
+end #include the wraper