activesupport 1.2.4 → 8.1.2

data/lib/active_support/cache/mem_cache_store.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+begin
+  require "dalli"
+rescue LoadError => e
+  warn "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+
+require "connection_pool"
+require "delegate"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/numeric/time"
+
+module ActiveSupport
+  module Cache
+    # = Memcached \Cache \Store
+    #
+    # A cache store implementation which stores data in Memcached:
+    # https://memcached.org
+    #
+    # 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 comes back up.
+    #
+    # +MemCacheStore+ implements the Strategy::LocalCache strategy which
+    # implements an in-memory cache inside of a block.
+    class MemCacheStore < Store
+      # These options represent behavior overridden by this implementation and should
+      # not be allowed to get down to the Dalli client
+      OVERRIDDEN_OPTIONS = UNIVERSAL_OPTIONS
+
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      prepend Strategy::LocalCache
+
+      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
+
+      # Creates a new Dalli::Client instance with specified addresses and options.
+      # If no addresses are provided, we give nil to Dalli::Client, so it uses its fallbacks:
+      # - ENV["MEMCACHE_SERVERS"] (if defined)
+      # - "127.0.0.1:11211"        (otherwise)
+      #
+      #   ActiveSupport::Cache::MemCacheStore.build_mem_cache
+      #     # => #<Dalli::Client:0x007f98a47d2028 @servers=["127.0.0.1:11211"], @options={}, @ring=nil>
+      #   ActiveSupport::Cache::MemCacheStore.build_mem_cache('localhost:10290')
+      #     # => #<Dalli::Client:0x007f98a47b3a60 @servers=["localhost:10290"], @options={}, @ring=nil>
+      def self.build_mem_cache(*addresses) # :nodoc:
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        addresses = nil if addresses.compact.empty?
+        pool_options = retrieve_pool_options(options)
+
+        if pool_options
+          ConnectionPool.new(**pool_options) { Dalli::Client.new(addresses, options.merge(threadsafe: false)) }
+        else
+          Dalli::Client.new(addresses, options)
+        end
+      end
+
+      # 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 provided, but <tt>ENV['MEMCACHE_SERVERS']</tt> is defined, it will be used instead. Otherwise,
+      # +MemCacheStore+ will connect to localhost:11211 (the default memcached port).
+      def initialize(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        if options.key?(:cache_nils)
+          options[:skip_nil] = !options.delete(:cache_nils)
+        end
+        options[:max_key_size] ||= MAX_KEY_SIZE
+        super(options)
+
+        unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
+          raise ArgumentError, "First argument must be an empty array, address, or array of addresses."
+        end
+
+        @mem_cache_options = options.dup
+        # The value "compress: false" prevents duplicate compression within Dalli.
+        @mem_cache_options[:compress] = false
+        (OVERRIDDEN_OPTIONS - %i(compress)).each { |name| @mem_cache_options.delete(name) }
+        @data = self.class.build_mem_cache(*(addresses + [@mem_cache_options]))
+      end
+
+      def inspect
+        instance = @data || @mem_cache_options
+        "#<#{self.class} options=#{options.inspect} mem_cache=#{instance.inspect}>"
+      end
+
+      ##
+      # :method: write
+      # :call-seq: write(name, value, options = nil)
+      #
+      # Behaves the same as ActiveSupport::Cache::Store#write, but supports
+      # additional options specific to memcached.
+      #
+      # ==== Additional Options
+      #
+      # * <tt>raw: true</tt> - Sends the value directly to the server as raw
+      #   bytes. The value must be a string or number. You can use memcached
+      #   direct operations like +increment+ and +decrement+ only on raw values.
+
+      # Increment a cached integer value using the memcached incr atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +amount+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.increment("baz") # => 6
+      #
+      # Incrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
+      #
+      # To read the value later, call #read_counter:
+      #
+      #   cache.increment("baz") # => 7
+      #   cache.read_counter("baz") # 7
+      def increment(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:increment, key, amount: amount) do
+          rescue_error_with nil do
+            @data.with { |c| c.incr(key, amount, options[:expires_in], amount) }
+          end
+        end
+      end
+
+      # Decrement a cached integer value using the memcached decr atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to 0. Memcached
+      # does not support negative counters.
+      #
+      #   cache.decrement("foo") # => 0
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.decrement("baz") # => 4
+      #
+      # Decrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
+      #
+      # To read the value later, call #read_counter:
+      #
+      #   cache.decrement("baz") # => 3
+      #   cache.read_counter("baz") # 3
+      def decrement(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:decrement, key, amount: amount) do
+          rescue_error_with nil do
+            @data.with { |c| c.decr(key, amount, options[:expires_in], 0) }
+          end
+        end
+      end
+
+      # Clear the entire cache on all memcached servers. This method should
+      # be used with care when shared cache is being used.
+      def clear(options = nil)
+        rescue_error_with(nil) { @data.with { |c| c.flush_all } }
+      end
+
+      # Get the statistics from the memcached servers.
+      def stats
+        @data.with { |c| c.stats }
+      end
+
+      private
+        # Read an entry from the cache.
+        def read_entry(key, **options)
+          deserialize_entry(read_serialized_entry(key, **options), **options)
+        end
+
+        def read_serialized_entry(key, **options)
+          rescue_error_with(nil) do
+            @data.with { |c| c.get(key, options) }
+          end
+        end
+
+        # Write an entry to the cache.
+        def write_entry(key, entry, **options)
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
+        end
+
+        def write_serialized_entry(key, payload, **options)
+          method = options[:unless_exist] ? :add : :set
+          expires_in = options[:expires_in].to_i
+          if options[:race_condition_ttl] && expires_in > 0 && !options[:raw]
+            # Set the memcache expire a few minutes in the future to support race condition ttls on read
+            expires_in += 5.minutes
+          end
+          rescue_error_with nil do
+            # Don't pass compress option to Dalli since we are already dealing with compression.
+            options.delete(:compress)
+            @data.with { |c| !!c.send(method, key, payload, expires_in, **options) }
+          end
+        end
+
+        # Reads multiple entries from the cache implementation.
+        def read_multi_entries(names, **options)
+          keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+          rescue_error_with({}) do
+            raw_values = @data.with { |c| c.get_multi(keys_to_names.keys) }
+
+            values = {}
+
+            raw_values.each do |key, value|
+              entry = deserialize_entry(value, raw: options[:raw])
+
+              unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
+                begin
+                  values[keys_to_names[key]] = entry.value
+                rescue DeserializationError
+                end
+              end
+            end
+
+            values
+          end
+        end
+
+        # Delete an entry from the cache.
+        def delete_entry(key, **options)
+          rescue_error_with(false) { @data.with { |c| c.delete(key) } }
+        end
+
+        def serialize_entry(entry, raw: false, **options)
+          if raw
+            entry.value.to_s
+          else
+            super(entry, raw: raw, **options)
+          end
+        end
+
+        # Memcache keys are binaries. So we need to force their encoding to binary
+        # before applying the regular expression to ensure we are escaping all
+        # characters properly.
+        def normalize_key(key, options)
+          key = expand_and_namespace_key(key, options)
+          if key
+            key = key.dup.force_encoding(Encoding::ASCII_8BIT)
+            key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
+          end
+          truncate_key(key)
+        end
+
+        def deserialize_entry(payload, raw: false, **)
+          if payload && raw
+            Entry.new(payload)
+          else
+            super(payload)
+          end
+        end
+
+        def rescue_error_with(fallback)
+          yield
+        rescue Dalli::DalliError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
+          logger.error("DalliError (#{error}): #{error.message}") if logger
+          ActiveSupport.error_reporter&.report(
+            error,
+            severity: :warning,
+            source: "mem_cache_store.active_support",
+          )
+          fallback
+        end
+    end
+  end
+end

data/lib/active_support/cache/memory_store.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module ActiveSupport
+  module Cache
+    # = Memory \Cache \Store
+    #
+    # A cache store implementation which stores everything into memory in the
+    # same process. If you're running multiple Ruby on \Rails server processes
+    # (which is the case if you're using Phusion Passenger or puma clustered mode),
+    # then this means that \Rails server process instances won't be able
+    # to share cache data with each other and this may not be the most
+    # appropriate cache in that scenario.
+    #
+    # 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.
+    #
+    # Unlike other Cache store implementations, +MemoryStore+ does not compress
+    # values by default. +MemoryStore+ does not benefit from compression as much
+    # as other Store implementations, as it does not send data over a network.
+    # However, when compression is enabled, it still pays the full cost of
+    # compression in terms of cpu use.
+    #
+    # +MemoryStore+ is thread-safe.
+    class MemoryStore < Store
+      prepend Strategy::LocalCache
+
+      module DupCoder # :nodoc:
+        extend self
+
+        def dump(entry)
+          if entry.value && entry.value != true && !entry.value.is_a?(Numeric)
+            Cache::Entry.new(dump_value(entry.value), expires_at: entry.expires_at, version: entry.version)
+          else
+            entry
+          end
+        end
+
+        def dump_compressed(entry, threshold)
+          compressed_entry = entry.compressed(threshold)
+          compressed_entry.compressed? ? compressed_entry : dump(entry)
+        end
+
+        def load(entry)
+          if !entry.compressed? && entry.value.is_a?(String)
+            Cache::Entry.new(load_value(entry.value), expires_at: entry.expires_at, version: entry.version)
+          else
+            entry
+          end
+        end
+
+        private
+          MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+          def dump_value(value)
+            if value.is_a?(String) && !value.start_with?(MARSHAL_SIGNATURE)
+              value.dup
+            else
+              Marshal.dump(value)
+            end
+          end
+
+          def load_value(string)
+            if string.start_with?(MARSHAL_SIGNATURE)
+              Marshal.load(string)
+            else
+              string.dup
+            end
+          end
+      end
+
+      def initialize(options = nil)
+        options ||= {}
+        options[:coder] = DupCoder unless options.key?(:coder) || options.key?(:serializer)
+        # Disable compression by default.
+        options[:compress] ||= false
+        super(options)
+        @data = {}
+        @max_size = options[:size] || 32.megabytes
+        @max_prune_time = options[:max_prune_time] || 2
+        @cache_size = 0
+        @monitor = Monitor.new
+        @pruning = false
+      end
+
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      # Delete all data stored in a given cache store.
+      def clear(options = nil)
+        synchronize do
+          @data.clear
+          @cache_size = 0
+        end
+      end
+
+      # Preemptively iterates through all stored keys and removes the ones which have expired.
+      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
+
+      # To ensure entries fit within the specified memory prune the cache by removing the least
+      # recently accessed entries.
+      def prune(target_size, max_time = nil)
+        return if pruning?
+        @pruning = true
+        begin
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          cleanup
+          instrument(:prune, target_size, from: @cache_size) do
+            keys = synchronize { @data.keys }
+            keys.each do |key|
+              delete_entry(key, **options)
+              return if @cache_size <= target_size || (max_time && Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time > max_time)
+            end
+          end
+        ensure
+          @pruning = false
+        end
+      end
+
+      # Returns true if the cache is currently being pruned.
+      def pruning?
+        @pruning
+      end
+
+      # Increment a cached integer value. Returns the updated value.
+      #
+      # If the key is unset, it will be set to +amount+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.increment("baz") # => 6
+      #
+      def increment(name, amount = 1, **options)
+        instrument(:increment, name, amount: amount) do
+          modify_value(name, amount, **options)
+        end
+      end
+
+      # Decrement a cached integer value. Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +-amount+.
+      #
+      #   cache.decrement("foo") # => -1
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.decrement("baz") # => 4
+      #
+      def decrement(name, amount = 1, **options)
+        instrument(:decrement, name, amount: amount) do
+          modify_value(name, -amount, **options)
+        end
+      end
+
+      # Deletes cache entries if the cache key matches a given pattern.
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        matcher = key_matcher(matcher, options)
+
+        instrument(:delete_matched, matcher.inspect) do
+          keys = synchronize { @data.keys }
+          keys.each do |key|
+            delete_entry(key, **options) if key.match(matcher)
+          end
+        end
+      end
+
+      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
+
+      private
+        PER_ENTRY_OVERHEAD = 240
+
+        def cached_size(key, payload)
+          key.to_s.bytesize + payload.bytesize + PER_ENTRY_OVERHEAD
+        end
+
+        def read_entry(key, **options)
+          entry = nil
+          synchronize do
+            payload = @data.delete(key)
+            if payload
+              @data[key] = payload
+              entry = deserialize_entry(payload)
+            end
+          end
+          entry
+        end
+
+        def write_entry(key, entry, **options)
+          payload = serialize_entry(entry, **options)
+          synchronize do
+            return false if options[:unless_exist] && exist?(key, namespace: nil)
+
+            old_payload = @data[key]
+            if old_payload
+              @cache_size -= (old_payload.bytesize - payload.bytesize)
+            else
+              @cache_size += cached_size(key, payload)
+            end
+            @data[key] = payload
+            prune(@max_size * 0.75, @max_prune_time) if @cache_size > @max_size
+            true
+          end
+        end
+
+        def delete_entry(key, **options)
+          synchronize do
+            payload = @data.delete(key)
+            @cache_size -= cached_size(key, payload) if payload
+            !!payload
+          end
+        end
+
+        # Modifies the amount of an integer value that is stored in the cache.
+        # If the key is not found it is created and set to +amount+.
+        def modify_value(name, amount, **options)
+          options = merged_options(options)
+          key     = normalize_key(name, options)
+          version = normalize_version(name, options)
+
+          synchronize do
+            entry = read_entry(key, **options)
+
+            if !entry || entry.expired? || entry.mismatched?(version)
+              write(name, Integer(amount), options)
+              amount
+            else
+              num = entry.value.to_i + amount
+              entry = Entry.new(num, expires_at: entry.expires_at, version: entry.version)
+              write_entry(key, entry)
+              num
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_support/cache/null_store.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Cache
+    # = Null \Cache \Store
+    #
+    # A cache store implementation which doesn't actually store anything. Useful in
+    # development and test environments where you don't want caching turned on but
+    # need to go through the caching interface.
+    #
+    # This cache does implement the local cache strategy, so values will actually
+    # be cached inside blocks that utilize this strategy. See
+    # ActiveSupport::Cache::Strategy::LocalCache for more details.
+    class NullStore < Store
+      prepend Strategy::LocalCache
+
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      def clear(options = nil)
+      end
+
+      def cleanup(options = nil)
+      end
+
+      def increment(name, amount = 1, **options)
+      end
+
+      def decrement(name, amount = 1, **options)
+      end
+
+      def delete_matched(matcher, options = nil)
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name} options=#{@options.inspect}>"
+      end
+
+      private
+        def read_entry(key, **s)
+          deserialize_entry(read_serialized_entry(key))
+        end
+
+        def read_serialized_entry(_key, **)
+        end
+
+        def write_entry(key, entry, **)
+          write_serialized_entry(key, serialize_entry(entry))
+        end
+
+        def write_serialized_entry(_key, _payload, **)
+          true
+        end
+
+        def delete_entry(key, **options)
+          false
+        end
+    end
+  end
+end