activesupport 3.0.pre → 3.0.0.rc

data/lib/active_support/cache/memory_store.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/object/duplicable'
+require 'monitor'
 
 module ActiveSupport
   module Cache
@@ -6,54 +6,154 @@ module ActiveSupport
     # same process. If you're running multiple Ruby on Rails server processes
     # (which is the case if you're using mongrel_cluster or Phusion Passenger),
     # then this means that your Rails server process instances won't be able
-    # to share cache data with each other. If your application never performs
-    # manual cache item expiry (e.g. when you're using generational cache keys),
-    # then using MemoryStore is ok. Otherwise, consider carefully whether you
-    # should be using this cache store.
+    # to share cache data with each other and this may not be the most
+    # appropriate cache for you.
     #
-    # MemoryStore is not only able to store strings, but also arbitrary Ruby
-    # objects.
+    # This cache has a bounded size specified by the :size options to the
+    # initializer (default is 32Mb). When the cache exceeds the allotted size,
+    # a cleanup will occur which tries to prune the cache down to three quarters
+    # of the maximum size by removing the least recently used entries.
     #
-    # MemoryStore is not thread-safe. Use SynchronizedMemoryStore instead
-    # if you need thread-safety.
+    # MemoryStore is thread-safe.
     class MemoryStore < Store
-      def initialize
+      def initialize(options = nil)
+        options ||= {}
+        super(options)
         @data = {}
+        @key_access = {}
+        @max_size = options[:size] || 32.megabytes
+        @max_prune_time = options[:max_prune_time] || 2
+        @cache_size = 0
+        @monitor = Monitor.new
+        @pruning = false
       end
 
-      def read(name, options = nil)
-        super do
-          @data[name]
+      def clear(options = nil)
+        synchronize do
+          @data.clear
+          @key_access.clear
+          @cache_size = 0
         end
       end
 
-      def write(name, value, options = nil)
-        super do
-          @data[name] = (value.duplicable? ? value.dup : value).freeze
+      def cleanup(options = nil)
+        options = merged_options(options)
+        instrument(:cleanup, :size => @data.size) do
+          keys = synchronize{ @data.keys }
+          keys.each do |key|
+            entry = @data[key]
+            delete_entry(key, options) if entry && entry.expired?
+          end
         end
       end
 
-      def delete(name, options = nil)
-        super do
-          @data.delete(name)
+      # Prune the cache down so the entries fit within the specified memory size by removing
+      # the least recently accessed entries.
+      def prune(target_size, max_time = nil)
+        return if pruning?
+        @pruning = true
+        begin
+          start_time = Time.now
+          cleanup
+          instrument(:prune, target_size, :from => @cache_size) do
+            keys = synchronize{ @key_access.keys.sort{|a,b| @key_access[a].to_f <=> @key_access[b].to_f} }
+            keys.each do |key|
+              delete_entry(key, options)
+              return if @cache_size <= target_size || (max_time && Time.now - start_time > max_time)
+            end
+          end
+        ensure
+          @pruning = false
         end
       end
 
-      def delete_matched(matcher, options = nil)
-        super do
-          @data.delete_if { |k,v| k =~ matcher }
+      # Return true if the cache is currently be pruned to remove older entries.
+      def pruning?
+        @pruning
+      end
+
+      # Increment an integer value in the cache.
+      def increment(name, amount = 1, options = nil)
+        synchronize do
+          options = merged_options(options)
+          if num = read(name, options)
+            num = num.to_i + amount
+            write(name, num, options)
+            num
+          else
+            nil
+          end
+        end
+      end
+
+      # Decrement an integer value in the cache.
+      def decrement(name, amount = 1, options = nil)
+        synchronize do
+          options = merged_options(options)
+          if num = read(name, options)
+            num = num.to_i - amount
+            write(name, num, options)
+            num
+          else
+            nil
+          end
         end
       end
 
-      def exist?(name,options = nil)
-        super do
-          @data.has_key?(name)
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        instrument(:delete_matched, matcher.inspect) do
+          matcher = key_matcher(matcher, options)
+          keys = synchronize { @data.keys }
+          keys.each do |key|
+            delete_entry(key, options) if key.match(matcher)
+          end
         end
       end
 
-      def clear
-        @data.clear
+      def inspect # :nodoc:
+        "<##{self.class.name} entries=#{@data.size}, size=#{@cache_size}, options=#{@options.inspect}>"
       end
+
+      # Synchronize calls to the cache. This should be called wherever the underlying cache implementation
+      # is not thread safe.
+      def synchronize(&block) # :nodoc:
+        @monitor.synchronize(&block)
+      end
+
+      protected
+        def read_entry(key, options) # :nodoc:
+          entry = @data[key]
+          synchronize do
+            if entry
+              @key_access[key] = Time.now.to_f
+            else
+              @key_access.delete(key)
+            end
+          end
+          entry
+        end
+
+        def write_entry(key, entry, options) # :nodoc:
+          synchronize do
+            old_entry = @data[key]
+            @cache_size -= old_entry.size if old_entry
+            @cache_size += entry.size
+            @key_access[key] = Time.now.to_f
+            @data[key] = entry
+            prune(@max_size * 0.75, @max_prune_time) if @cache_size > @max_size
+            true
+          end
+        end
+
+        def delete_entry(key, options) # :nodoc:
+          synchronize do
+            @key_access.delete(key)
+            entry = @data.delete(key)
+            @cache_size -= entry.size if entry
+            !!entry
+          end
+        end
     end
   end
 end

data/lib/active_support/cache/strategy/local_cache.rb

@@ -1,110 +1,163 @@
 require 'active_support/core_ext/object/duplicable'
+require 'active_support/core_ext/string/inflections'
 
 module ActiveSupport
   module Cache
     module Strategy
+      # Caches that implement LocalCache will be backed by an in memory cache for the
+      # duration of a block. Repeated calls to the cache for the same key will hit the
+      # in memory cache for faster access.
       module LocalCache
-        # this allows caching of the fact that there is nothing in the remote cache
-        NULL = 'remote_cache_store:null'
+        # Simple memory backed cache. This cache is not thread safe but is intended only
+        # for serving as a temporary memory cache for a single thread.
+        class LocalStore < Store
+          def initialize
+            super
+            @data = {}
+          end
+
+          # Since it isn't thread safe, don't allow synchronizing.
+          def synchronize # :nodoc:
+            yield
+          end
+
+          def clear(options = nil)
+            @data.clear
+          end
+
+          def read_entry(key, options)
+            @data[key]
+          end
+
+          def write_entry(key, value, options)
+            @data[key] = value
+            true
+          end
 
+          def delete_entry(key, options)
+            !!@data.delete(key)
+          end
+        end
+
+        # Use a local cache to front for the cache for the duration of a block.
         def with_local_cache
-          Thread.current[thread_local_key] = MemoryStore.new
-          yield
-        ensure
-          Thread.current[thread_local_key] = nil
+          save_val = Thread.current[thread_local_key]
+          begin
+            Thread.current[thread_local_key] = LocalStore.new
+            yield
+          ensure
+            Thread.current[thread_local_key] = save_val
+          end
         end
 
+        # Middleware class can be inserted as a Rack handler to use a local cache for the
+        # duration of a request.
         def middleware
           @middleware ||= begin
             klass = Class.new
-            klass.class_eval(<<-EOS, __FILE__, __LINE__)
+            klass.class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              class << self
+                def name
+                  "ActiveSupport::Cache::Strategy::LocalCache"
+                end
+                alias :to_s :name
+              end
+
               def initialize(app)
                 @app = app
               end
 
               def call(env)
-                Thread.current[:#{thread_local_key}] = MemoryStore.new
+                Thread.current[:#{thread_local_key}] = LocalStore.new
                 @app.call(env)
               ensure
                 Thread.current[:#{thread_local_key}] = nil
               end
             EOS
-
-            def klass.to_s
-              "ActiveSupport::Cache::Strategy::LocalCache"
-            end
-
             klass
           end
         end
 
-        def read(key, options = nil)
-          value = local_cache && local_cache.read(key)
-          if value == NULL
-            nil
-          elsif value.nil?
-            value = super
-            local_cache.mute { local_cache.write(key, value || NULL) } if local_cache
-            value.duplicable? ? value.dup : value
-          else
-            # forcing the value to be immutable
-            value.duplicable? ? value.dup : value
-          end
-        end
-
-        def write(key, value, options = nil)
-          value = value.to_s if respond_to?(:raw?) && raw?(options)
-          local_cache.mute { local_cache.write(key, value || NULL) } if local_cache
+        def clear(options = nil) # :nodoc:
+          local_cache.clear(options) if local_cache
           super
         end
 
-        def delete(key, options = nil)
-          local_cache.mute { local_cache.write(key, NULL) } if local_cache
+        def cleanup(options = nil) # :nodoc:
+          local_cache.clear(options) if local_cache
           super
         end
 
-        def exist(key, options = nil)
-          value = local_cache.read(key) if local_cache
-          if value == NULL
-            false
-          elsif value
-            true
-          else
-            super
+        def increment(name, amount = 1, options = nil) # :nodoc:
+          value = bypass_local_cache{super}
+          if local_cache
+            local_cache.mute do
+              if value
+                local_cache.write(name, value, options)
+              else
+                local_cache.delete(name, options)
+              end
+            end
           end
+          value
         end
 
-        def increment(key, amount = 1)
-          if value = super
-            local_cache.mute { local_cache.write(key, value.to_s) } if local_cache
-            value
-          else
-            nil
+        def decrement(name, amount = 1, options = nil) # :nodoc:
+          value = bypass_local_cache{super}
+          if local_cache
+            local_cache.mute do
+              if value
+                local_cache.write(name, value, options)
+              else
+                local_cache.delete(name, options)
+              end
+            end
           end
+          value
         end
 
-        def decrement(key, amount = 1)
-          if value = super
-            local_cache.mute { local_cache.write(key, value.to_s) } if local_cache
-            value
-          else
-            nil
+        protected
+          def read_entry(key, options) # :nodoc:
+            if local_cache
+              entry = local_cache.read_entry(key, options)
+              unless entry
+                entry = super
+                local_cache.write_entry(key, entry, options)
+              end
+              entry
+            else
+              super
+            end
           end
-        end
 
-        def clear
-          local_cache.clear if local_cache
-          super
-        end
+          def write_entry(key, entry, options) # :nodoc:
+            local_cache.write_entry(key, entry, options) if local_cache
+            super
+          end
+
+          def delete_entry(key, options) # :nodoc:
+            local_cache.delete_entry(key, options) if local_cache
+            super
+          end
 
         private
           def thread_local_key
-            @thread_local_key ||= "#{self.class.name.underscore}_local_cache".gsub("/", "_").to_sym
+            @thread_local_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, '_').to_sym
           end
 
           def local_cache
             Thread.current[thread_local_key]
           end
+
+          def bypass_local_cache
+            save_cache = Thread.current[thread_local_key]
+            begin
+              Thread.current[thread_local_key] = nil
+              yield
+            ensure
+              Thread.current[thread_local_key] = save_cache
+            end
+          end
       end
     end
   end

data/lib/active_support/cache/synchronized_memory_store.rb

@@ -2,45 +2,9 @@ module ActiveSupport
   module Cache
     # Like MemoryStore, but thread-safe.
     class SynchronizedMemoryStore < MemoryStore
-      def initialize
+      def initialize(*args)
+        ActiveSupport::Deprecation.warn('ActiveSupport::Cache::SynchronizedMemoryStore has been deprecated in favor of ActiveSupport::Cache::MemoryStore.', caller)
         super
-        @guard = Monitor.new
-      end
-
-      def fetch(key, options = {})
-        @guard.synchronize { super }
-      end
-
-      def read(name, options = nil)
-        @guard.synchronize { super }
-      end
-
-      def write(name, value, options = nil)
-        @guard.synchronize { super }
-      end
-
-      def delete(name, options = nil)
-        @guard.synchronize { super }
-      end
-
-      def delete_matched(matcher, options = nil)
-        @guard.synchronize { super }
-      end
-
-      def exist?(name,options = nil)
-        @guard.synchronize { super }
-      end
-
-      def increment(key, amount = 1)
-        @guard.synchronize { super }
-      end
-
-      def decrement(key, amount = 1)
-        @guard.synchronize { super }
-      end
-
-      def clear
-        @guard.synchronize { super }
       end
     end
   end