CachedSupermodel 0.1.0

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2006-11-13
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/cached_supermodel
+lib/cached_supermodel.rb
+lib/cs_active_record.rb
+lib/cs_associations.rb
+test/test_cached_supermodel.rb

data/README.txt

@@ -0,0 +1,42 @@
+CachedSupermodel
+    by Adocca AB
+    http://rubyforge.org/projects/adocca-plugins
+
+== DESCRIPTION:
+  
+A library that overloads lots of methods in ActiveRecord::Base and ActiveRecord::Associations
+to automatically cache all descendants of ActiveRecord::Base and their associations and finders
+etc in memcached using the AdoccaMemcache gem.
+
+== FEATURES/PROBLEMS:
+  
+* FIX (list of features or problems)
+
+== SYNOPSYS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+

data/Rakefile

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/cached_supermodel.rb'
+
+Hoe.new('CachedSupermodel', '0.1.0') do |p|
+  p.rubyforge_name = 'adocca-plugins'
+  p.summary = 'A library that automatically caches all ActiveRecord::Base instances in memcache using the AdoccaMemcache gem.'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.extra_deps << ['AdoccaMemcache', '>= 0.1.0']
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/cached_supermodel.rb

@@ -0,0 +1,7 @@
+
+$: << File.dirname(__FILE__)
+
+require_gem 'rails'
+
+require 'cs_active_record'
+require 'cs_associations'

data/lib/cs_active_record.rb

@@ -0,0 +1,392 @@
+require 'timeout'
+
+#
+# Some monkeypatches upon ActiveRecord::Base
+#
+class ActiveRecord::Base
+  #
+  # Removes all association-created attributes from this instance.
+  #
+  def remove_associations!
+    instance_variable_set(:@attributes, attributes_before_type_cast)
+    instance_variables.collect do |var|
+      var[1..-1]
+    end.each do |var|
+      unless self.class.columns_hash.merge({"new_record" => true, "attributes" => true}).include?(var)
+        instance_variable_set("@#{var}", nil)
+      end
+    end
+  end
+  #
+  # Return a copy of this instance with all association-created attributes removed.
+  #
+  def remove_associations
+    obj = dup
+    obj.remove_associations!
+    obj
+  end
+  #
+  # Tell this class to use memcache_memoize to cache certain finders.
+  #
+  # The results of the finders will be automatically cached and reused (unless
+  # you give extra conditions, which will turn off the caching completely!).
+  #
+  # Invalidation will occur on save and destroy.
+  #
+  # Usage:
+  #
+  # class MyModel < ActiveRecord::Base
+  #   cached_finders :find_by_id_and_name_and_something_else
+  # end
+  #
+  def self.cached_finders(*args)
+    args.each do |finder|
+      if (match = finder.to_s.match(/^find_(all_)?by_(.*)$/))
+        attributes = match[2].to_s.split(/_and_/)
+        define_method("invalidate_cached_#{finder}") do
+          unless self.new_record?
+            self.class.find(self.id).send("non_recursive_invalidate_cached_#{finder}")
+          end
+          self.send("non_recursive_invalidate_cached_#{finder}")
+        end
+        define_method("non_recursive_invalidate_cached_#{finder}") do
+          attribute_values = attributes.collect do |attribute|
+            self[attribute.to_sym]
+          end
+          expire_cached_namespace(self.class.name + ":#{finder}:" + attribute_values.inspect)
+        end
+      else
+         raise "Unknown finder type #{finder}"
+      end
+
+      class_eval "
+def self.#{finder}_get_ids(*args)
+    match = '#{finder}'.match(/^find_(all_)?by_(.*)$/)
+    attributes = match[2].to_s.split(/_and_/)
+    normal_arguments = args[0...attributes.size]
+    rest = args[attributes.size..-1]
+    cache_value([self.name + ':#{finder}:' + normal_arguments.inspect, rest.inspect]) do
+       rval = method_missing(:#{finder}, *args)
+       if Array === rval
+          rval.collect(&:id)
+       else
+          rval.nil? ? nil : rval.id
+       end
+    end
+end
+def self.#{finder}(*args)
+    match = '#{finder}'.match(/^find_(all_)?by_(.*)$/)
+    attributes = match[2].to_s.split(/_and_/)
+    normal_arguments = args[0...attributes.size]
+    rest = args[attributes.size..-1]
+    extra_conditions = false
+    rest.each do |arg|
+      if Hash === arg
+        extra_conditions = extra_conditions || arg.include?(:conditions)
+      end
+    end
+    if extra_conditions
+      method_missing(:#{finder}, *args)
+    else
+      rval = self.#{finder}_get_ids(*args)
+      begin
+        if Array === rval
+          rval.collect do |oid|
+             self.find(oid)
+          end
+        else
+          rval.nil? ? nil : self.find(rval)
+        end
+      rescue ActiveRecord::RecordNotFound
+          nil
+      end
+    end
+end
+before_save :invalidate_cached_#{finder}
+before_destroy :invalidate_cached_#{finder}
+"
+    end
+  end
+
+  @@cache_local = {}
+  @@use_local_cache = false
+  @@ttl = 60 * 15
+
+  def self.ttl
+    @@ttl
+  end
+
+  def self.ttl=(t)
+    @@ttl = t
+  end
+
+  def self.use_local_cache?
+    @@use_local_cache
+  end
+
+  def self.use_local_cache=(u)
+    @@use_local_cache = u
+  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)
+    self.cache_local.delete self.cache_key_local(klass, id) if self.use_local_cache?
+    CACHE.delete self.cache_key_memcache(klass, id)
+    logger.debug("deleted #{self.cache_key_memcache(klass, id)}")
+  end
+
+  ##
+  # Invalidate the local process cache.  This should be called from a before
+  # filter at the beginning of each request.
+
+  def self.cache_reset
+    self.cache_local.clear if self.use_local_cache?
+  end
+
+  def self.ok_primary_key(key)
+    case self.columns_hash[self.primary_key].type
+    when :integer
+      key.is_a?(Fixnum)
+    when :string
+      key.is_a?(String)
+    else
+      raise "I dont know about this column type: #{self.columns_hash[self.primary_key_column].type}"
+    end
+  end
+
+  ##
+  # Override the find method to look for values in the cache before going to
+  # the database.
+
+  class << self
+    alias_method :cached_supermodel_find, :find
+  end
+
+  def self.find(*args)
+    args.reject! do |arg|
+      arg.is_a?(Hash) && arg.values.compact.empty?
+    end
+    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 args.length != 1 or !ok_primary_key(args.first) then
+      records = cached_supermodel_find(*args)
+      # Rails requires two levels of indirection to look up a record
+      return records if args.first == :all and @skip_find_hack
+      case records
+      when Array then
+        records.each { |r| r.cache_store }
+      when ActiveRecord then
+        records.cache_store # Model.find 1 gets cached here
+      end
+      return records
+    end
+
+    # Try to find the record in the local cache.
+    id = args.first
+    if self.use_local_cache? then
+      record = self.cache_local[self.cache_key_local(name, id)]
+      return record unless record.nil?
+    end
+
+    # Try to find the record in memcache and add it to the local cache
+    record = CACHE.get self.cache_key_memcache(name, id)
+    unless record == :MemCache_no_such_entry then
+      logger.debug("found #{self.cache_key_memcache(name, id)}")
+      record = nil if record == :MemCache_nil
+      if self.use_local_cache? then
+        self.cache_local[self.cache_key_local(name, id)] = record
+      end
+      return record
+    end
+    
+    # Fetch the record from the DB.  Inside the multiple levels of indirection
+    # of find it will get cached. (no it wont, so i added a cache_store below //martin)
+    #
+    # We don't want the subsequent find_by_sql to loop back here, so guard
+    # the call.
+    #
+    # NOTE This guard is not thread safe, beware use of cached ActiveRecord where
+    # ActiveRecord's thread safety is disabled.
+    begin
+      @skip_find_hack = true
+      record = cached_supermodel_find(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.
+
+  class << self
+    alias_method :cached_supermodel_find_by_sql, :find_by_sql
+  end
+
+  def self.find_by_sql(*args)
+    unless @skip_find_hack
+      if args.first =~ /SELECT \* FROM #{table_name} WHERE \(#{table_name}\.#{primary_key} = '?(\d+)'?\) LIMIT 1/ then
+        return [find($1.to_i)]
+      end
+    end
+
+    return cached_supermodel_find_by_sql(*args)
+  end
+
+  ##
+  # Delete the entry from the cache now that it isn't in the DB.
+
+  alias_method :cached_supermodel_destroy, :destroy
+
+  def destroy
+    return cached_supermodel_destroy
+  ensure
+    cache_delete
+  end
+
+  ##
+  # Invalidate the cache for this record before reloading from the DB.
+
+  alias_method :cached_supermodel_reload, :reload
+
+  def reload
+    cache_delete
+    return cached_supermodel_reload
+  ensure
+    cache_store
+  end
+
+  ##
+  # Store a new copy of ourselves into the cache.
+  
+  alias_method :cached_supermodel_update, :update
+
+  def update
+    return cached_supermodel_update
+  ensure
+    cache_store
+  end
+
+
+  ##
+  # Remove this record from the cache.
+
+  def cache_delete
+    cache_local.delete cache_key_local if self.class.use_local_cache?
+    CACHE.delete cache_key_memcache
+    logger.debug("deleted #{cache_key_memcache}")
+  end
+
+  ##
+  # The local cache key for this record.
+
+  def self.cache_key_local(klass, id)
+    return "#{klass}:#{id}"
+  end
+
+  def cache_key_local
+    self.class.cache_key_local(self.class, self.id)
+  end
+
+  ##
+  # The memcache key for this record.
+
+  def self.cache_key_memcache(klass, id)
+    return "active_record:#{self.cache_key_local(klass, id)}"
+  end
+
+  def cache_key_memcache
+    self.class.cache_key_memcache(self.class, self.id)
+  end
+
+  ##
+  # The local object cache.
+
+  def cache_local
+    return self.class.cache_local
+  end
+
+  ##
+  # Store this record in the cache without associations.  Storing associations
+  # leads to wasted cache space and hard-to-debug problems.
+  def cache_store
+    if self.class.use_local_cache? then
+      cache_local[cache_key_local] = remove_associations
+    end
+    CACHE.set cache_key_memcache, remove_associations, self.class.ttl
+    logger.debug("stored #{cache_key_memcache}")
+  end
+
+  #
+  # Make increment_counter invalidate the cache
+  #
+
+  class << self
+    alias_method :cached_supermodel_increment_counter, :increment_counter
+  end
+
+  def self.increment_counter(counter_name, id)
+    begin
+      return cached_supermodel_increment_counter(counter_name, id)
+    ensure
+      cache_delete(self, id)
+    end
+  end
+
+  #
+  # Make decrement_counter invalidate the cache
+  #
+  
+  class << self
+    alias_method :cached_supermodel_decrement_counter, :decrement_counter
+  end
+
+  def self.decrement_counter(counter_name, id)
+    begin
+      return cached_supermodel_decrement_counter(counter_name, id)
+    ensure
+      cache_delete(self, id)
+    end
+  end
+  
+  #
+  # Make delete invalidate the cache
+  #
+
+  class << self
+    alias_method :cached_supermodel_delete, :delete
+  end
+
+  def self.delete(id)
+    begin
+      return cached_supermodel_delete(id)
+      ensure
+        if id.respond_to?(:each)
+          id.each do |i|
+            cache_delete(self.class, i)
+          end
+        else 
+          cache_delete(self.class, id)
+        end
+    end
+  end
+  
+
+end
+

data/lib/cs_associations.rb

@@ -0,0 +1,251 @@
+#
+# Some monkeypatches upon ActiveRecord::Associations
+#
+ActiveRecord::Associations::ClassMethods.class_eval do
+
+  #
+  # The method that is used to define has_one and belongs_to relationships.
+  #
+  def association_accessor_methods(reflection, association_proxy_class)
+    #
+    # We only handle has_one relations
+    #
+    if reflection.macro == :has_one
+      #
+      # Add invalidations
+      #
+      our_name = name
+      reflection.klass.class_eval do
+        if reflection.options[:as]
+          #
+          # Add invalidations for poly associations.
+          #
+          type_field = reflection.primary_key_name.gsub(/_id$/, "_type")
+          expire_proc = Proc.new do |instance|
+            if instance.send(type_field) == our_name
+              key = "#{our_name}:#{instance.send(reflection.primary_key_name)}:#{reflection.name}"
+              expire_cached_value(key)
+            end
+          end
+        else
+          #
+          # Add invalidations for normal associations.
+          #
+          expire_proc = Proc.new do |instance|
+            key = "#{our_name}:#{instance.send(reflection.primary_key_name)}:#{reflection.name}"
+            expire_cached_value(key)
+          end
+        end        
+        
+        before_destroy expire_proc
+        before_save expire_proc
+
+        var_name = "@@association_invalidations"
+        class_variable_set(var_name, []) unless class_variables.include?(var_name)
+        current_invalidations = class_variable_get(var_name)
+        current_invalidations << expire_proc
+        class_variable_set(var_name, current_invalidations)
+      end
+
+      #
+      # Add a cached getter for the association.
+      #
+      define_method(reflection.name) do |*params|
+        force_reload = params.first unless params.empty?
+        association = instance_variable_get("@#{reflection.name}")
+        
+        if association.nil? || force_reload
+          if new_record?
+            assoc = association_proxy_class.new(self, reflection)
+            retval = assoc.reload
+            association = retval.nil? ? nil : assoc
+          else
+            key = "#{self.class.name}:#{self.id}:#{reflection.name}"
+            expire_cached_value(key) if force_reload
+            association = cache_value(key) do
+              assoc = association_proxy_class.new(self.remove_associations, reflection)
+              retval = assoc.reload
+              retval.nil? ? nil : assoc
+            end
+          end
+          instance_variable_set("@#{reflection.name}", association)
+        end
+
+        association
+      end
+    else
+      #
+      # If this wasnt has_one, do the normal stuff.
+      #
+      
+      define_method(reflection.name) do |*params|
+        force_reload = params.first unless params.empty?
+        association = instance_variable_get("@#{reflection.name}")
+        
+        if association.nil? || force_reload
+          association = association_proxy_class.new(self, reflection)
+          retval = association.reload
+          unless retval.nil?
+            instance_variable_set("@#{reflection.name}", association)
+          else
+            instance_variable_set("@#{reflection.name}", nil)
+            return nil
+          end
+        end
+        association
+      end
+      
+    end
+ 
+    #
+    # Here ends our customization, the rest is just copy and paste except for a few invalidations.
+    #
+
+    define_method("#{reflection.name}=") do |new_value|
+
+      # Here is the magic: Invalidate the current owner before we change it.
+      me = self
+      self.class.class_eval do
+        class_variable_get("@@association_invalidations").each do |invalidation|
+          invalidation.call(me)
+        end if class_variables.include?("@@association_invalidations")
+      end
+      
+      association = instance_variable_get("@#{reflection.name}")
+      if association.nil?
+        association = association_proxy_class.new(self, reflection)
+      end
+
+      association.replace(new_value)
+
+      unless new_value.nil?
+        instance_variable_set("@#{reflection.name}", association)
+      else
+        instance_variable_set("@#{reflection.name}", nil)
+        return nil
+      end
+
+      association
+    end
+
+    define_method("set_#{reflection.name}_target") do |target|
+      return if target.nil?
+      association = association_proxy_class.new(self, reflection)
+      association.target = target
+      instance_variable_set("@#{reflection.name}", association)
+    end
+  end
+
+  #
+  # The method that is used to define has_many relationships.
+  #
+  # Wraps the original collection_reader_method within some memcache magic
+  #
+  def collection_reader_method(reflection, association_proxy_class)
+
+    #
+    # If this is a through reflection, we will invalidate on changes in the
+    # source reflection instead of the reflection itself.
+    #
+    invalidating_reflection = reflection
+    invalidating_reflection = reflection.through_reflection if (is_through_reflection = reflection.through_reflection)
+
+    #
+    # The reflection we invalidate on will expire our cache on destroy and save.
+    #
+    our_name = name
+    invalidating_reflection.klass.class_eval do
+      if invalidating_reflection.options[:as]
+        #
+        # Polymorphic associations should only invalidate their actual object.
+        #
+        # (only if the _type field of the association is of the right class)
+        #
+        type_field = invalidating_reflection.primary_key_name.gsub(/_id$/, '_type')
+        expire_proc = Proc.new do |instance|
+          if instance.send(type_field) == our_name
+            key = "#{our_name}:#{instance.send(invalidating_reflection.primary_key_name)}:#{reflection.name}"
+            expire_cached_value(key)
+            key << ":cached_count"
+            expire_cached_value(key)
+          end
+        end
+      else
+        #
+        # Non-polymorphic associations just invalidate their object regardless.
+        #
+        expire_proc = Proc.new do |instance|
+          key = "#{our_name}:#{instance.send(invalidating_reflection.primary_key_name)}:#{reflection.name}"
+          expire_cached_value(key)
+          key << ":cached_count"
+          expire_cached_value(key)
+        end
+      end
+      before_destroy expire_proc
+      before_save expire_proc
+
+      var_name = "@@association_invalidations"
+      class_variable_set(var_name, []) unless class_variables.include?(var_name)
+      current_invalidations = class_variable_get(var_name)
+      current_invalidations << expire_proc
+      class_variable_set(var_name, current_invalidations)
+    end
+
+    #
+    # We also have to add before_remove callbacks to the owner class
+    #
+    write_inheritable_array("before_remove_for_#{reflection.name}".to_sym, 
+                            [Proc.new do |owner, record|
+                               key = "#{owner.class.name}:#{owner.id}:#{reflection.name}"
+                               expire_cached_value(key)
+                               key << ":cached_count"
+                               expire_cached_value(key)
+                             end])
+    
+    class_eval "
+def self.#{reflection.name}_cached_count_for(oid)
+    key = self.name + ':' + oid.to_s + ':#{reflection.name}:cached_count'
+    cache_value(key) do
+       self.find(oid).#{reflection.name}_cached_count
+    end
+end
+"
+    
+    #
+    # The getter for the cached count of this association.
+    #
+    define_method("#{reflection.name}_cached_count") do |*params|
+      key = "#{self.class.name}:#{self.id}:#{reflection.name}:cached_count"
+      cache_value(key) do
+        association_proxy_class.new(self.remove_associations, reflection).count
+      end
+    end
+
+    #
+    # The getter for the association will cache its value.
+    #
+    define_method(reflection.name) do |*params|
+      force_reload = params.first unless params.empty?
+      association = instance_variable_get("@#{reflection.name}")
+      
+      if !association.respond_to?(:loaded?) || force_reload
+        if new_record?
+          association = association_proxy_class.new(self, reflection)
+        else
+          key = "#{self.class.name}:#{self.id}:#{reflection.name}"
+          expire_cached_value(key) if force_reload
+          association = cache_value(key) do
+            a = association_proxy_class.new(self.remove_associations, reflection)
+            a.reload
+            a
+          end
+        end
+        instance_variable_set("@#{reflection.name}", association)
+      end
+
+      association
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: CachedSupermodel
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-11-13 00:00:00 +01:00
+summary: A library that automatically caches all ActiveRecord::Base instances in memcache using the AdoccaMemcache gem.
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: "    by Adocca AB"
+rubyforge_project: adocca-plugins
+description: "== FEATURES/PROBLEMS:  * FIX (list of features or problems)  == SYNOPSYS:  FIX (code sample of usage)  == REQUIREMENTS:"
+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: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/cached_supermodel
+- lib/cached_supermodel.rb
+- lib/cs_active_record.rb
+- lib/cs_associations.rb
+- test/test_cached_supermodel.rb
+test_files: 
+- test/test_cached_supermodel.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- cached_supermodel
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: AdoccaMemcache
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: