cached_model 1.0.0

data/Manifest.txt

@@ -0,0 +1,4 @@
+Manifest.txt
+README
+Rakefile
+lib/cached_model.rb

data/README

@@ -0,0 +1,66 @@
+= CachedModel
+
+Rubyforge Project:
+
+http://rubyforge.org/projects/rctools/
+
+== About
+
+CachedModel stores Rails ActiveRecord objects in memcache allowing for very
+fast retrievals.  CachedModel uses the ActiveRecord::Locking to ensure that
+you don't perform multiple updates.
+
+== Using CachedModel
+
+First, install the cached_model gem:
+
+  $ sudo gem install cached_model
+
+Then set up memcache-client:
+
+  $ tail -n 20  config/environments/production.rb
+  memcache_options = {
+    :c_threshold => 10_000,
+    :compression => true,
+    :debug => false,
+    :namespace => 'my_rails_app',
+    :readonly => false,
+    :urlencode => false
+  }
+  
+  CACHE = MemCache.new memcache_options
+  CACHE.servers = 'localhost:11211'
+  
+  session_options = {
+    :database_manager => CGI::Session::MemCacheStore,
+    :cache => CACHE,
+    :session_domain => 'trackmap.robotcoop.com'
+  }
+  
+  ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.update session_options
+
+You will need separate namespaces for production and development, if using
+memcache on the same machine.
+
+Note that using memcache with tests will cause test failures, so set your
+memcache to be readonly for the test environment.
+
+Then make Rails load the gem:
+
+  $ tail -n 4 config/environment.rb 
+  # Include your application configuration below
+  
+  require_gem 'cached_model'
+
+Then edit your ActiveRecord model to inherit from CachedModel instead of
+ActiveRecord::Base:
+
+  $ head -n 8 app/models/photo.rb
+  ##
+  # A Photo from Flickr.
+  
+  class Photo < CachedModel
+  
+    belongs_to :point
+    belongs_to :route
+

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$VERBOSE = nil
+
+spec = Gem::Specification.new do |s|
+  s.name = 'cached_model'
+  s.version = '1.0.0'
+  s.summary = 'An ActiveRecord::Base model that caches records'
+  s.authors = 'Robert Cottrell, Eric Hodel'
+  s.email = 'bob@robotcoop.com'
+
+  s.has_rdoc = true
+  s.files = File.read('Manifest.txt').split($/)
+  s.require_path = 'lib'
+
+  s.add_dependency 'memcache-client', '1.0.3'
+end
+
+desc 'Run tests'
+task :default => [ :test ]
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'test'
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
+end
+
+desc 'Update Manifest.txt'
+task :update_manifest do
+  sh "find . -type f | sed -e 's%./%%' | egrep -v 'svn|swp|~' | egrep -v '^(doc|pkg)/' | sort > Manifest.txt"
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new :rdoc do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.add 'lib', 'README', 'LICENSE'
+  rd.main = 'README'
+  rd.options << '-d' if `which dot` =~ /\/dot/
+end
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_rdoc, :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]
+
+# vim: syntax=Ruby
+

data/lib/cached_model.rb

@@ -0,0 +1,190 @@
+require 'memcache_util'
+
+##
+# An abstract ActiveRecord descendant that caches records in memcache and in
+# local memory.
+
+class CachedModel < ActiveRecord::Base
+
+  KEY = 'active_record'
+  TTL = 60 * 15 # seconds
+  
+  @cache_local = {}
+
+  class << self; attr_reader :cache_local; end
+
+  ##
+  # Override the flawed assumption ActiveRecord::Base makes about inheritance.
+
+  def self.descends_from_active_record?
+    superclass == CachedModel
+  end
+          
+  ##
+  # Override the flawed assumption ActiveRecord::Base makes about inheritance.
+
+  def self.class_name_of_active_record_descendant(klass)
+    if klass.superclass == CachedModel then
+      return klass.name
+    elsif klass.superclass.nil? then
+      raise ActiveRecordError, "#{name} doesn't descend from ActiveRecord::Base"
+    else
+      class_name_of_active_record_descendant klass.superclass
+    end
+  end
+
+  ##      
+  # Invalidate the cache entry for an record.  The update method will
+  # automatically invalidate the cache when updates are made through
+  # ActiveRecord model record.  However, several methods update tables with
+  # direct sql queries for effeciency.  These methods should call this method
+  # to invalidate the cache after making those changes.
+  #   
+  # NOTE - if a SQL query updates multiple rows with one query, there is
+  # currently no way to invalidate the affected entries unless the entire
+  # cache is dumped or until the TTL expires, so try not to do this.
+
+  def self.cache_delete(klass, id)
+    key = "#{klass}:#{id}"
+    CachedModel.cache_local.delete key
+    Cache.delete "#{KEY}:#{key}"
+  end
+
+  ##
+  # Invalidate the per-request cache.  This should be called from a before
+  # filter at the beginning of each request.
+
+  def self.cache_reset
+    CachedModel.cache_local.clear
+  end
+
+  ##
+  # Override the find method to look for values in the cache before going to
+  # the database.
+
+  def self.find(*args)
+    args[0] = args.first.to_i if args.first =~ /\A\d+\Z/
+    # Only handle simple find requests.  If the request was more complicated,
+    # let the base class handle it, but store the retrieved records in the
+    # local cache in case we need them later.
+    if $TESTING or args.length != 1 or not Fixnum === args.first then
+      records = super
+      if RAILS_ENV != 'test' and Array === records then
+        records.each { |r| r.cache_store }
+      end
+      return records
+    end
+
+    # Try to find the record in the local cache.
+    id = args.first
+    cache_key_local = "#{name}:#{id}"
+    record = CachedModel.cache_local[cache_key_local]
+    return record unless record.nil?
+
+    # Try to find the record in memcache and add it to the local cache
+    record = Cache.get "#{KEY}:#{cache_key_local}"
+    unless record.nil? then
+      CachedModel.cache_local[cache_key_local] = record
+      return record
+    end
+
+    # Fetch the record from the DB and cache it.
+    #
+    # We don't want the subsequent find_by_sql to loop back here, so guard
+    # the call.
+    #
+    # NOTE - this guard isn't thread safe.
+    begin
+      @skip_find_hack = true
+      record = super(args).first
+      record.cache_store
+    ensure
+      @skip_find_hack = false
+    end
+
+    return record
+  end
+
+  ##
+  # Skip the special handling for find by primary key if this method was
+  # called from find. If this is really a lookup for a single row by primary
+  # key, use a simple find call instead.
+
+  def self.find_by_sql(*args)
+    unless @skip_find_hack or $TESTING then
+      if args.first =~ /SELECT \* FROM #{table_name} WHERE \(#{table_name}\.#{primary_key} = '?(\d+)'?\) LIMIT 1/ then
+        return [self.find($1.to_i)]
+      end
+    end
+
+    return super
+  end
+
+  ##
+  # Delete the entry from the cache so that the next call goes to the database
+  # for the freshest copy of the record.  This will also ensure that if for
+  # some reason a stale copy of the record was cached we can get rid of it.
+
+  def update
+    cache_delete
+    val = super
+    cache_store
+    return val
+  end
+
+  ##
+  # Delete the entry from the cache now that it isn't in the DB.
+
+  def destroy
+    return super
+  ensure
+    cache_delete
+  end
+
+  ##
+  # Invalidate the cache for this record before reloading from the DB.
+
+  def reload
+    cache_delete
+    return super
+  end
+
+  ##
+  # The local object cache.
+
+  def cache_local
+    return CachedModel.cache_local
+  end
+
+  ##
+  # Store this record in the cache.
+
+  def cache_store
+    cache_local[cache_key_memcache] = self
+    Cache.put cache_key_memcache, self, TTL
+  end
+
+  ##
+  # Remove this record from the cache.
+
+  def cache_delete
+    cache_local.delete cache_key_local
+    Cache.delete cache_key_memcache
+  end
+
+  ##
+  # The local cache key for this record.
+
+  def cache_key_local
+    return "#{self.class.name}:#{self.id}"
+  end
+
+  ##
+  # The memcache key for this record.
+
+  def cache_key_memcache
+    return "#{KEY}:#{cache_key_local}"
+  end
+
+end
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11.6
+specification_version: 1
+name: cached_model
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2006-01-17 00:00:00 -08:00
+summary: An ActiveRecord::Base model that caches records
+require_paths: 
+- lib
+email: bob@robotcoop.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Robert Cottrell, Eric Hodel
+files: 
+- Manifest.txt
+- README
+- Rakefile
+- lib/cached_model.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: memcache-client
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.0.3
+    version: