cache_fu 0.1.2

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2007 Chris Wanstrath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,18 @@
+== cache_fu
+
+A rewrite of acts_as_cached.
+This version is only compatible with rails 3 and above.
+
+== Changes from acts_as_cached 1
+
+- You can no longer set a 'ttl' method on a class.  Instead,
+  pass :ttl to acts_as_cached:
+    >> acts_as_cached :ttl => 15.minutes
+
+- The is_cached? method is aliased as cached?
+
+- set_cache on an instance can take a ttl
+    >> @story.set_cache(15.days)
+
+
+Chris Wanstrath [ chris[at]ozmm[dot]org ]

data/defaults/extensions.rb.default

@@ -0,0 +1,40 @@
+##
+# Copy this file to vendor/plugins/acts_as_cached/extensions.rb if you 
+# wish to extend acts_as_cached with your own instance or class methods.
+#
+# You can, of course, do this directly in your cached classes,
+# but keeping your custom methods here allows you to define
+# methods for all cached objects DRYly.
+module ActsAsCached
+  module Extensions
+    module ClassMethods
+      ##
+      # All acts_as_cached classes will be extended with 
+      # this method.
+      #
+      # >> Story.multi_get_cache(13, 353, 1231, 505)
+      # => [<Story:13>, <Story:353>, ...]
+      def multi_get_cache(*ids)
+        ids.flatten.map { |id| get_cache(id) }
+      end
+    end
+
+    module InstanceMethods
+      ##
+      # All instances of a acts_as_cached class will be 
+      # extended with this method.
+      #
+      # => story = Story.get_cache(1)
+      # => <Story:1>
+      # >> story.reset_included_caches
+      # => true
+      def reset_included_caches
+        return false unless associations = cache_config[:include]
+        associations.each do |association| 
+          Array(send(association)).each { |item| item.reset_cache }
+        end
+        true
+      end
+    end
+  end
+end

data/defaults/memcached.yml.default

@@ -0,0 +1,34 @@
+defaults:
+  ttl: 1800
+  readonly: false
+  urlencode: false
+  c_threshold: 10000
+  compression: true
+  debug: false
+  namespace: app
+  sessions: false
+  session_servers: false
+  fragments: false
+  memory: 64
+  servers: localhost:11211
+  benchmarking: true
+  raise_errors: true
+  fast_hash: false
+  fastest_hash: false
+
+development:
+  sessions: false
+  fragments: false
+  servers: localhost:11211
+
+# turn off caching
+test: 
+  disabled: true
+
+production:
+  memory: 256
+  benchmarking: false
+  servers:
+    - 192.185.254.121:11211
+    - 192.185.254.138:11211
+    - 192.185.254.160:11211

data/defaults/memcached_ctl.default

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+# By atmos@atmos.org
+# this goes in your script/ directory
+# it parses your memcached.yml file and hooks you up w/ some info
+# it keeps you from having to mess w/ stale memcached daemons for whatever reason.
+require 'yaml'
+require 'timeout'
+require 'erb'
+
+class MemcachedCtl
+  attr_accessor :memcached, :memory, :pids, :servers, :ip_address, :ethernet_device
+
+  def initialize
+    env = ENV['RAILS_ENV'] || 'development'
+    self.memcached = `which memcached`.chomp
+    self.servers = [ ]
+    self.pids    = { }
+    self.ethernet_device = ENV['ETH'] || 'eth0'
+    self.ip_address = get_ip_address || '0.0.0.0'
+    self.memory = '128'
+    
+    config = YAML.load(ERB.new(IO.read((File.expand_path(File.dirname(__FILE__) + "/../config/memcached.yml")))).result)
+    self.servers = [ config['defaults']['servers'] ].flatten rescue ['127.0.0.1:11211']
+    self.servers = [ config[env]['servers'] ].flatten if config[env]['servers']
+    self.servers.reject! { |server| host,port = server.split(/:/); self.ip_address == host }
+    self.memory = config[env]['memory'] unless config[env]['memory'].nil?
+    
+    each_server do |host,port|
+      `ps auwwx | grep memcached | grep '\\-l #{ip_address} \\-p #{port}' | grep -v grep`.split(/\n/).each do |line|
+        self.pids[port] = line.split(/\s+/)[1]
+      end
+      self.pids[port] ||= 'Down'
+    end
+  end
+  
+  def execute(cmd)
+    send(cmd) rescue usage
+  end
+  
+  def restart; stop; sleep 1; start end
+  
+  def status
+    each_server { |host,port| puts "Port #{port} -> #{pids[port] =~ /\d+/ ? 'Up' : 'Down'}" }
+  end
+  
+  def kill
+    each_server { |host,port| `kill -9 #{pids[port]} > /dev/null 2>&1` if pids[port] =~ /\d+/ }
+  end
+  
+  def stop; kill end
+  
+  def start
+    each_server do |host,port|
+      `#{memcached} -d -m #{memory} -l #{ip_address} -p #{port}`
+      STDERR.puts "Try memcached_ctl status" unless $? == 0
+    end
+  end
+
+  def usage
+    methods = %w[start stop restart kill status]
+    puts "Usage: script/memcached_ctl [ " + (methods * ' | ') + " ]"
+  end
+    
+protected
+  def each_server
+    servers.each do |server|
+      host, port = server.split(/:/)
+      yield host, port
+    end
+  end
+  
+  def get_ip_address # this works on linux you might have to tweak this on other oses
+    line = `/sbin/ifconfig #{ethernet_device} | grep inet | grep -v inet6`.chomp
+    if line =~ /\s*inet addr:((\d+\.){3}\d+)\s+.*/
+      self.ip_address = $1
+    end
+  end
+end
+###########################################################################
+
+MemcachedCtl.new.execute(ARGV.first)

data/lib/acts_as_cached/benchmarking.rb

@@ -0,0 +1,82 @@
+require 'benchmark'
+
+module ActsAsCached
+  module Benchmarking #:nodoc:
+    def self.cache_runtime
+      @@cache_runtime ||= 0.0
+    end
+
+    def self.cache_reset_runtime
+      @@cache_runtime = nil
+    end
+
+    def cache_benchmark(title, log_level = Logger::DEBUG, use_silence = true)
+      return yield unless logger && logger.level == log_level
+      result = nil
+
+      seconds = Benchmark.realtime {
+        result = use_silence ? ActionController::Base.silence { yield } : yield
+      }
+
+      @@cache_runtime ||= 0.0
+      @@cache_runtime += seconds
+
+      logger.add(log_level, "==> #{title} (#{'%.5f' % seconds})")
+      result
+    end
+
+    def fetch_cache_with_benchmarking(*args)
+      cache_benchmark "Got #{cache_key args.first} from cache." do
+        fetch_cache_without_benchmarking(*args)
+      end
+    end
+
+    def set_cache_with_benchmarking(*args)
+      cache_benchmark "Set #{cache_key args.first} to cache." do
+        set_cache_without_benchmarking(*args)
+      end
+    end
+
+    def expire_cache_with_benchmarking(*args)
+      cache_benchmark "Deleted #{cache_key args.first} from cache." do
+        expire_cache_without_benchmarking(*args)
+      end
+    end
+
+    def self.add_to(klass)
+      return if klass.respond_to? :fetch_cache_with_benchmarking
+      klass.extend self
+
+      class << klass
+        alias_method_chain :fetch_cache,  :benchmarking
+        alias_method_chain :set_cache,    :benchmarking
+        alias_method_chain :expire_cache, :benchmarking
+
+        def logger; Rails.logger end unless respond_to? :logger
+      end
+    end
+  end
+end
+
+module ActsAsCached
+  module MemcacheRuntime
+    extend ActiveSupport::Concern
+    protected
+
+    def append_info_to_payload(payload)
+      super
+      payload[:memcache_runtime] = ActsAsCached::Benchmarking.cache_runtime
+      ActsAsCached::Benchmarking.cache_reset_runtime
+    end
+
+    module ClassMethods
+      def log_process_action(payload)
+        messages, memcache_runtime = super, payload[:memcache_runtime]
+        messages << ("Memcache: %.1fms" % memcache_runtime.to_f) if memcache_runtime
+        messages
+      end
+    end
+  end
+end
+
+

data/lib/acts_as_cached/cache_methods.rb

@@ -0,0 +1,307 @@
+module ActsAsCached
+  module ClassMethods
+    @@nil_sentinel = :_nil
+
+    def cache_config
+      config = ActsAsCached::Config.class_config[cache_name] ||= {}
+      if name == cache_name
+        config
+      else
+        # sti
+        ActsAsCached::Config.class_config[name] ||= config.dup
+      end
+    end
+
+    def cache_options
+      cache_config[:options] ||= {}
+    end
+
+    def get_cache(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args    = args.flatten
+
+      ##
+      # head off to get_caches if we were passed multiple cache_ids
+      if args.size > 1
+        return get_caches(args, options)
+      else
+        cache_id = args.first
+      end
+
+      if (item = fetch_cache(cache_id)).nil?
+        set_cache(cache_id, block_given? ? yield : fetch_cachable_data(cache_id), options[:ttl])
+      else
+        @@nil_sentinel == item ? nil : item
+      end
+    end
+
+    ##
+    # This method accepts an array of cache_ids which it will use to call
+    # get_multi on your cache store.  Any misses will be fetched and saved to
+    # the cache, and a hash keyed by cache_id will ultimately be returned.
+    #
+    # If your cache store does not support #get_multi an exception will be raised.
+    def get_caches(*args)
+      raise NoGetMulti unless cache_store.respond_to? :get_multi
+
+      options   = args.last.is_a?(Hash) ? args.pop : {}
+      cache_ids = args.flatten.map(&:to_s)
+      keys      = cache_keys(cache_ids)
+
+      # Map memcache keys to object cache_ids in { memcache_key => object_id } format
+      keys_map = Hash[*keys.zip(cache_ids).flatten]
+
+      # Call get_multi and figure out which keys were missed based on what was a hit
+      hits = ActsAsCached.config[:disabled] ? {} : (cache_store(:get_multi, *keys) || {})
+
+      # Misses can take the form of key => nil
+      hits.delete_if { |key, value| value.nil? }
+
+      misses = keys - hits.keys
+      hits.each { |k, v| hits[k] = nil if v == @@nil_sentinel }
+
+      # Return our hash if there are no misses
+      return hits.values.index_by(&:cache_id) if misses.empty?
+
+      # Find any missed records
+      needed_ids     = keys_map.values_at(*misses)
+      missed_records = Array(fetch_cachable_data(needed_ids))
+
+      # Cache the missed records
+      missed_records.each { |missed_record| missed_record.set_cache(options[:ttl]) }
+
+      # Return all records as a hash indexed by object cache_id
+      (hits.values + missed_records).index_by(&:cache_id)
+    end
+
+    # simple wrapper for get_caches that
+    # returns the items as an ordered array
+    def get_caches_as_list(*args)
+      cache_ids = args.last.is_a?(Hash) ? args.first : args
+      cache_ids = [cache_ids].flatten
+      hash      = get_caches(*args)
+
+      cache_ids.map do |key|
+        hash[key]
+      end
+    end
+
+    def set_cache(cache_id, value, ttl = nil)
+      value.tap do |v|
+        v = @@nil_sentinel if v.nil?
+        cache_store(:set, cache_key(cache_id), v, ttl || cache_config[:ttl] || 1500)
+      end
+    end
+
+    def expire_cache(cache_id = nil)
+      cache_store(:delete, cache_key(cache_id))
+      true
+    end
+    alias :clear_cache :expire_cache
+
+    def reset_cache(cache_id = nil)
+      set_cache(cache_id, fetch_cachable_data(cache_id))
+    end
+
+    ##
+    # Encapsulates the pattern of writing custom cache methods
+    # which do nothing but wrap custom finders.
+    #
+    #   => Story.caches(:find_popular)
+    #
+    #   is the same as
+    #
+    #   def self.cached_find_popular
+    #     get_cache(:find_popular) { find_popular }
+    #   end
+    #
+    #  The method also accepts both a :ttl and/or a :with key.
+    #  Obviously the :ttl value controls how long this method will
+    #  stay cached, while the :with key's value will be passed along
+    #  to the method.  The hash of the :with key will be stored with the key,
+    #  making two near-identical #caches calls with different :with values utilize
+    #  different caches.
+    #
+    #  => Story.caches(:find_popular, :with => :today)
+    #
+    #  is the same as
+    #
+    #   def self.cached_find_popular
+    #     get_cache("find_popular:today") { find_popular(:today) }
+    #   end
+    #
+    # If your target method accepts multiple parameters, pass :withs an array.
+    #
+    # => Story.caches(:find_popular, :withs => [ :one, :two ])
+    #
+    # is the same as
+    #
+    #   def self.cached_find_popular
+    #     get_cache("find_popular:onetwo") { find_popular(:one, :two) }
+    #   end
+    def caches(method, options = {})
+      if options.keys.include?(:with)
+        with = options.delete(:with)
+        get_cache("#{method}:#{with}", options) { send(method, with) }
+      elsif withs = options.delete(:withs)
+        get_cache("#{method}:#{withs}", options) { send(method, *withs) }
+      else
+        get_cache(method, options) { send(method) }
+      end
+    end
+    alias :cached :caches
+
+    def cached?(cache_id = nil)
+      fetch_cache(cache_id).nil? ? false : true
+    end
+    alias :is_cached? :cached?
+
+    def fetch_cache(cache_id)
+      return if ActsAsCached.config[:skip_gets]
+
+      autoload_missing_constants do
+        cache_store(:get, cache_key(cache_id))
+      end
+    end
+
+    def fetch_cachable_data(cache_id = nil)
+      finder = cache_config[:finder] || :find
+      return send(finder) unless cache_id
+
+      args = [cache_id]
+      args << cache_options.dup unless cache_options.blank?
+      send(finder, *args)
+    end
+
+    def cache_namespace
+      cache_store.respond_to?(:namespace) ? cache_store(:namespace) : (CACHE.instance_variable_get('@options') && CACHE.instance_variable_get('@options')[:namespace])
+    end
+
+    # Memcache-client automatically prepends the namespace, plus a colon, onto keys, so we take that into account for the max key length.
+    # Rob Sanheim
+    def max_key_length
+      unless @max_key_length
+        key_size = cache_config[:key_size] || 250
+        @max_key_length = cache_namespace ? (key_size - cache_namespace.length - 1) : key_size
+      end
+      @max_key_length
+    end
+
+    def cache_name
+      @cache_name ||= respond_to?(:base_class) ? base_class.name : name
+    end
+
+    def cache_keys(*cache_ids)
+      cache_ids.flatten.map { |cache_id| cache_key(cache_id) }
+    end
+
+    def cache_key(cache_id)
+      [cache_name, cache_config[:version], cache_id].compact.join(':').gsub(' ', '_')[0..(max_key_length - 1)]
+    end
+
+    def cache_store(method = nil, *args)
+      return cache_config[:store] unless method
+
+      load_constants = %w( get get_multi ).include? method.to_s
+
+      swallow_or_raise_cache_errors(load_constants) do
+        cache_config[:store].send(method, *args)
+      end
+    end
+
+    def swallow_or_raise_cache_errors(load_constants = false, &block)
+      load_constants ? autoload_missing_constants(&block) : yield
+    rescue TypeError => error
+      if error.to_s.include? 'Proc'
+        raise MarshalError, "Most likely an association callback defined with a Proc is triggered, see http://ar.rubyonrails.com/classes/ActiveRecord/Associations/ClassMethods.html (Association Callbacks) for details on converting this to a method based callback"
+      else
+        raise error
+      end
+    rescue Exception => error
+      if ActsAsCached.config[:raise_errors]
+        raise error
+      else
+        Rails.logger.debug "MemCache Error: #{error.message}" rescue nil
+        nil
+      end
+    end
+
+    def autoload_missing_constants
+      yield
+    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.sub(/::$/, '').constantize] then retry
+      else raise error end
+    end
+  end
+
+  module InstanceMethods
+    def self.included(base)
+      base.send :delegate, :cache_config,  :to => 'self.class'
+      base.send :delegate, :cache_options, :to => 'self.class'
+    end
+
+    def get_cache(key = nil, options = {}, &block)
+      self.class.get_cache(cache_id(key), options, &block)
+    end
+
+    def set_cache(ttl = nil)
+      self.class.set_cache(cache_id, self, ttl)
+    end
+
+    def reset_cache(key = nil)
+      self.class.reset_cache(cache_id(key))
+    end
+
+    def expire_cache(key = nil)
+      self.class.expire_cache(cache_id(key))
+    end
+    alias :clear_cache :expire_cache
+
+    def cached?(key = nil)
+      self.class.cached? cache_id(key)
+    end
+
+    def cache_key
+      self.class.cache_key(cache_id)
+    end
+
+    def cache_id(key = nil)
+      id = send(cache_config[:cache_id] || :id)
+      key.nil? ? id : "#{id}:#{key}"
+    end
+
+    def caches(method, options = {})
+      key = "#{id}:#{method}"
+      if options.keys.include?(:with)
+        with = options.delete(:with)
+        self.class.get_cache("#{key}:#{with}", options) { send(method, with) }
+      elsif withs = options.delete(:withs)
+        self.class.get_cache("#{key}:#{withs}", options) { send(method, *withs) }
+      else
+        self.class.get_cache(key, options) { send(method) }
+      end
+    end
+    alias :cached :caches
+
+    # Ryan King
+    def set_cache_with_associations
+      Array(cache_options[:include]).each do |assoc|
+        send(assoc).reload
+      end if cache_options[:include]
+      set_cache
+    end
+
+    # Lourens Naud
+    def expire_cache_with_associations(*associations_to_sweep)
+      (Array(cache_options[:include]) + associations_to_sweep).flatten.uniq.compact.each do |assoc|
+        Array(send(assoc)).compact.each { |item| item.expire_cache if item.respond_to?(:expire_cache) }
+      end
+      expire_cache
+    end
+  end
+
+  class MarshalError < StandardError; end
+  class MemCache; end
+  class MemCache::MemCacheError < StandardError; end
+end

data/lib/acts_as_cached/config.rb

@@ -0,0 +1,111 @@
+module ActsAsCached
+  module Config
+    extend self
+
+    @@class_config = {}
+    mattr_reader :class_config
+
+    def valued_keys
+      [ :store, :version, :pages, :per_page, :ttl, :finder, :cache_id, :find_by, :key_size ]
+    end
+
+    def setup(options)
+      config = options['defaults']
+
+      case options[Rails.env]
+      when Hash   then config.update(options[Rails.env])
+      when String then config[:disabled] = true
+      end
+
+      config.symbolize_keys!
+
+      setup_benchmarking! if config[:benchmarking] && !config[:disabled]
+
+      setup_cache_store! config
+      config
+    end
+
+    def setup_benchmarking!
+      ActiveSupport.on_load(:action_controller) do
+        include ActsAsCached::MemcacheRuntime
+      end
+    end
+
+    def setup_cache_store!(config)
+      config[:store] =
+        if config[:store].nil?
+          setup_memcache config
+        elsif config[:store].respond_to? :constantize
+          config[:store].constantize.new
+        else
+          config[:store]
+        end
+    end
+
+    def setup_memcache(config)
+      config[:namespace] << "-#{Rails.env}"
+
+      # if someone (e.g., interlock) already set up memcached, then
+      # we need to stop here
+      return CACHE if Object.const_defined?(:CACHE)
+
+      silence_warnings do
+        Object.const_set :CACHE, memcache_client(config)
+        Object.const_set :SESSION_CACHE, memcache_client(config) if config[:session_servers]
+      end
+
+      CACHE.respond_to?(:servers=) ? (CACHE.servers = Array(config.delete(:servers))) : CACHE.instance_variable_set('@servers', Array(config.delete(:servers)))
+      CACHE.instance_variable_get('@options')[:namespace] = config[:namespace] if CACHE.instance_variable_get('@options')
+
+      SESSION_CACHE.servers = Array(config[:session_servers]) if config[:session_servers]
+
+      setup_session_store   if config[:sessions]
+      setup_fragment_store! if config[:fragments]
+      setup_fast_hash!      if config[:fast_hash]
+      setup_fastest_hash!   if config[:fastest_hash]
+
+      CACHE
+    end
+
+    def memcache_client(config)
+      (config[:client] || "MemCache").classify.constantize.new(config)
+    end
+
+    def setup_session_store
+      return # Set up session store like normal in config/application.rb
+      
+      ActionController::Base.session_store = :mem_cache_store
+      cache = defined?(SESSION_CACHE) ? SESSION_CACHE : CACHE
+      ActionController::Session::AbstractStore::DEFAULT_OPTIONS.update(
+        :memcache_server => cache.servers,
+        :readonly => cache.readonly?,
+        :failover => cache.failover,
+        :timeout => cache.timeout,
+        :logger => cache.logger,
+        :namespace => cache.namespace
+      )
+    end
+
+    def setup_fragment_store!
+      ActsAsCached::FragmentCache.setup!
+    end
+
+    # break compatiblity with non-ruby memcache clients in exchange for speedup.
+    # consistent across all platforms.
+    def setup_fast_hash!
+      def CACHE.hash_for(key)
+        (0...key.length).inject(0) do |sum, i|
+          sum + key[i]
+        end
+      end
+    end
+
+    # break compatiblity with non-ruby memcache clients in exchange for speedup.
+    # NOT consistent across all platforms.  Object#hash gives different results
+    # on different architectures.  only use if all your apps are running the
+    # same arch.
+    def setup_fastest_hash!
+      def CACHE.hash_for(key) key.hash end
+    end
+  end
+end