mguymon-cache-money 0.2.12

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

@@ -0,0 +1,263 @@
+# 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 MemCache installed (don't need the wrapper)
+if defined? MemCache
+
+Rails.logger.info("cache-money: MemCache installed") if defined? Rails
+#TODO add logging?
+class MemcachedWrapper < ::MemCache
+end
+
+########## they have Memcached installed (do need the wrapper)
+elsif 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
+else
+  Rails.logger.warn 'unable to determine memcache implementation' if defined? Rails
+end #include the wraper

data/rails/init.rb

@@ -0,0 +1,40 @@
+yml = YAML.load(IO.read(File.join(RAILS_ROOT, "config", "memcached.yml")))
+memcache_config = yml[RAILS_ENV]
+memcache_config.symbolize_keys! if memcache_config.respond_to?(:symbolize_keys!)
+
+if defined?(DISABLE_CACHE_MONEY) || ENV['DISABLE_CACHE_MONEY'] == 'true' || memcache_config.nil? || memcache_config[:cache_money] != true
+  Rails.logger.info 'cache-money disabled'
+  class ActiveRecord::Base
+    def self.index(*args)
+    end
+  end
+else
+  Rails.logger.info 'cache-money enabled'
+  require 'cache_money'
+
+  memcache_config[:logger] = Rails.logger
+  memcache_servers = 
+    case memcache_config[:servers].class.to_s
+      when "String"; memcache_config[:servers].gsub(' ', '').split(',')
+      when "Array"; memcache_config[:servers]
+    end
+  $memcache = MemcachedWrapper.new(memcache_servers, memcache_config)
+
+  #ActionController::Base.cache_store = :cache_money_mem_cache_store
+  ActionController::Base.session_options[:cache] = $memcache if memcache_config[:sessions]
+  #silence_warnings {
+  #  Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(:cache_money_mem_cache_store)
+  #}
+
+  $local = Cash::Local.new($memcache)
+  $lock  = Cash::Lock.new($memcache)
+  $cache = Cash::Transactional.new($local, $lock)
+
+  # allow setting up caching on a per-model basis
+  unless memcache_config[:automatic_caching].to_s == 'false'
+    Rails.logger.info "cache-money: global model caching enabled"
+    class ActiveRecord::Base
+      is_cached(:repository => $cache)
+    end
+  end
+end