ngmoco-cache-money 0.2.10 → 0.2.13

data/lib/cash/write_through.rb

@@ -36,10 +36,7 @@ module Cash
       end
 
       def shallow_clone
-        clone = self.class.new
-        clone.instance_variable_set("@attributes", instance_variable_get(:@attributes))
-        clone.instance_variable_set("@new_record", new_record?)
-        clone
+        self.class.send(:instantiate, instance_variable_get(:@attributes))
       end
 
       private
@@ -53,19 +50,19 @@ module Cash
 
     module ClassMethods
       def add_to_caches(object)
-        indices.each { |index| index.add(object) }
+        indices.each { |index| index.add(object) } if cache_config
       end
 
       def update_caches(object)
-        indices.each { |index| index.update(object) }
+        indices.each { |index| index.update(object) } if cache_config
       end
 
       def remove_from_caches(object)
-        indices.each { |index| index.remove(object) }
+        indices.each { |index| index.remove(object) } if cache_config
       end
 
       def expire_caches(object)
-        indices.each { |index| index.delete(object) }
+        indices.each { |index| index.delete(object) } if cache_config
       end
     end
   end

data/lib/mem_cached_session_store.rb

@@ -0,0 +1,49 @@
+# 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 LoadError
+#   # Memcached wasn't available so neither can the store be
+# end

data/lib/mem_cached_support_store.rb

@@ -0,0 +1,135 @@
+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

data/lib/memcached_wrapper.rb

@@ -26,7 +26,7 @@ end
 class MemcachedWrapper < ::Memcached
   DEFAULTS = { :servers => '127.0.0.1:11211' }
 
-  attr_reader :logger
+  attr_reader :logger, :default_ttl
 
   # See Memcached#new for details.
   def initialize(*args)
@@ -253,7 +253,8 @@ private
   end
 
   def log_error(err)
-    logger.error("#{err}: \n\t#{err.backtrace.join("\n\t")}") if logger
+    #logger.error("#{err}: \n\t#{err.backtrace.join("\n\t")}") if logger
+    logger.error("Memcached ERROR, #{err.class}: #{err}") if logger
   end
   
 end

data/rails/init.rb

@@ -2,7 +2,7 @@ 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) || memcache_config.nil? || memcache_config[:cache_money] != true
+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)
@@ -13,7 +13,12 @@ else
   require 'cache_money'
 
   memcache_config[:logger] = Rails.logger
-  $memcache = MemcachedWrapper.new(memcache_config[:servers].gsub(' ', '').split(','), memcache_config)
+  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]
@@ -25,15 +30,11 @@ else
   $lock  = Cash::Lock.new($memcache)
   $cache = Cash::Transactional.new($local, $lock)
 
-  class ActiveRecord::Base
-    is_cached(:repository => $cache)
-
-    def <=>(other)
-      if self.id == other.id then 
-        0
-      else
-        self.id < other.id ? -1 : 1
-      end
+  # 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

data/spec/cash/accessor_spec.rb

@@ -1,4 +1,5 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "spec_helper"
+require 'ruby-debug'
 
 module Cash
   describe Accessor do
@@ -80,10 +81,38 @@ module Cash
       end
     end
 
+    describe '#add' do
+      describe 'when the value already exists' do
+        describe 'when a block is given' do
+          it 'yields to the block' do
+            Story.set("count", 1)
+            Story.add("count", 1) { "yield me" }.should == "yield me"
+          end
+        end
+        
+        describe 'when no block is given' do
+          it 'does not error' do
+            Story.set("count", 1)
+            lambda { Story.add("count", 1) }.should_not raise_error
+          end
+        end
+      end
+
+      describe 'when the value does not already exist' do
+        it 'adds the key to the cache' do
+          Story.add("count", 1)
+          Story.get("count").should == 1
+        end
+      end
+    end
+
+    describe '#set' do
+    end
+    
     describe '#incr' do
       describe 'when there is a cache hit' do
         before do
-          Story.set("count", 0)
+          Story.set("count", 0, :raw => true)
         end
 
         it 'increments the value of the cache' do
@@ -108,31 +137,6 @@ module Cash
       end
     end
 
-    describe '#add' do
-      describe 'when the value already exists' do
-        describe 'when a block is given' do
-          it 'yields to the block' do
-            Story.set("count", 1)
-            Story.add("count", 1) { "yield me" }.should == "yield me"
-          end
-        end
-        
-        describe 'when no block is given' do
-          it 'does not error' do
-            Story.set("count", 1)
-            lambda { Story.add("count", 1) }.should_not raise_error
-          end
-        end
-      end
-
-      describe 'when the value does not already exist' do
-        it 'adds the key to the cache' do
-          Story.add("count", 1)
-          Story.get("count").should == 1
-        end
-      end
-    end
-
     describe '#decr' do
       describe 'when there is a cache hit' do
         before do
@@ -161,6 +165,14 @@ module Cash
       end
     end
 
+    describe '#expire' do
+      it 'deletes the key' do
+        Story.set("bobo", 1)
+        Story.expire("bobo")
+        Story.get("bobo").should == nil
+      end
+    end
+    
     describe '#cache_key' do
       it 'uses the version number' do
         Story.version 1

data/spec/cash/active_record_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "spec_helper"
 
 module Cash
   describe Finders do
@@ -207,5 +207,18 @@ module Cash
         end
       end
     end
+    
+    describe 'loading' do
+      it "should be able to create a record for an ar subclass that was loaded before cache money" do
+        $debug = true
+        session = ActiveRecord::SessionStore::Session.new
+        session.session_id = "12345"
+        session.data = "foobarbaz"
+
+        lambda {
+          session.save!
+        }.should_not raise_error
+      end
+    end
   end
 end

data/spec/cash/buffered_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+module Cash
+  describe Buffered do
+    it "should have method missing as a private method" do
+      Buffered.private_instance_methods.should include("method_missing")
+    end
+  end
+end

data/spec/cash/calculations_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "spec_helper"
 
 module Cash
   describe Finders do

data/spec/cash/finders_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "spec_helper"
 
 module Cash
   describe Finders do
@@ -339,10 +339,20 @@ module Cash
         end
 
         describe '#find_by_attr' do
+          before(:each) do
+            Story.find_by_title(@story.title)  # populates cache for title with [@story.id]
+          end
+          
           it 'populates the cache' do
-            Story.find_by_title(@story.title)
             Story.fetch("title/#{@story.title}").should == [@story.id]
           end
+          
+          it 'populates the cache when finding by non-primary-key attribute' do
+            Story.find_by_title(@story.title)  # populates cache for id with record
+            
+            mock(Story.connection).execute.never  # should hit cache only
+            Story.find_by_title(@story.title).id.should == @story.id
+          end
         end
 
         describe '#find(:all, :conditions => ...)' do
@@ -352,6 +362,32 @@ module Cash
           end
         end
 
+        describe '#find(:all, :conditions => ..., :order => ...)' do
+          before(:each) do
+            @short1 = Short.create(:title => 'title',
+              :subtitle => 'subtitle')
+            @short2 = Short.create(:title => 'another title',
+              :subtitle => 'subtitle')
+            $memcache.flush_all
+            Short.find(:all, :conditions => { :subtitle => @short1.subtitle },
+              :order => 'title')
+          end
+
+          it 'populates the cache' do
+            Short.fetch("subtitle/subtitle").should_not be_blank
+          end
+
+          it 'returns objects in the correct order' do
+            Short.fetch("subtitle/subtitle").should ==
+              [@short2.id, @short1.id]
+          end
+
+          it 'finds objects in the correct order' do
+            Short.find(:all, :conditions => { :subtitle => @short1.subtitle },
+              :order => 'title').map(&:id).should == [@short2.id, @short1.id]
+          end
+        end
+
         describe '#find(1)' do
           it 'populates the cache' do
             Story.find(@story.id)