activesupport 5.0.7.2

data/lib/active_support/cache/file_store.rb

@@ -0,0 +1,204 @@
+require 'active_support/core_ext/marshal'
+require 'active_support/core_ext/file/atomic'
+require 'active_support/core_ext/string/conversions'
+require 'uri/common'
+
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores everything on the filesystem.
+    #
+    # FileStore implements the Strategy::LocalCache strategy which implements
+    # an in-memory cache inside of a block.
+    class FileStore < Store
+      prepend Strategy::LocalCache
+      attr_reader :cache_path
+
+      DIR_FORMATTER = "%03X"
+      FILENAME_MAX_SIZE = 228 # max filename size on file system is 255, minus room for timestamp and random characters appended by Tempfile (used by atomic write)
+      FILEPATH_MAX_SIZE = 900 # max is 1024, plus some room
+      EXCLUDED_DIRS = ['.', '..'].freeze
+      GITKEEP_FILES = ['.gitkeep', '.keep'].freeze
+
+      def initialize(cache_path, options = nil)
+        super(options)
+        @cache_path = cache_path.to_s
+      end
+
+      # Deletes all items from the cache. In this case it deletes all the entries in the specified
+      # file store directory except for .keep or .gitkeep. Be careful which directory is specified in your
+      # config file when using +FileStore+ because everything in that directory will be deleted.
+      def clear(options = nil)
+        root_dirs = exclude_from(cache_path, EXCLUDED_DIRS + GITKEEP_FILES)
+        FileUtils.rm_r(root_dirs.collect{|f| File.join(cache_path, f)})
+      rescue Errno::ENOENT
+      end
+
+      # Preemptively iterates through all stored keys and removes the ones which have expired.
+      def cleanup(options = nil)
+        options = merged_options(options)
+        search_dir(cache_path) do |fname|
+          key = file_path_key(fname)
+          entry = read_entry(key, options)
+          delete_entry(key, options) if entry && entry.expired?
+        end
+      end
+
+      # Increments an already existing integer value that is stored in the cache.
+      # If the key is not found nothing is done.
+      def increment(name, amount = 1, options = nil)
+        modify_value(name, amount, options)
+      end
+
+      # Decrements an already existing integer value that is stored in the cache.
+      # If the key is not found nothing is done.
+      def decrement(name, amount = 1, options = nil)
+        modify_value(name, -amount, options)
+      end
+
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        instrument(:delete_matched, matcher.inspect) do
+          matcher = key_matcher(matcher, options)
+          search_dir(cache_path) do |path|
+            key = file_path_key(path)
+            delete_entry(path, options) if key.match(matcher)
+          end
+        end
+      end
+
+      protected
+
+        def read_entry(key, options)
+          if File.exist?(key)
+            File.open(key) { |f| Marshal.load(f) }
+          end
+        rescue => e
+          logger.error("FileStoreError (#{e}): #{e.message}") if logger
+          nil
+        end
+
+        def write_entry(key, entry, options)
+          return false if options[:unless_exist] && File.exist?(key)
+          ensure_cache_path(File.dirname(key))
+          File.atomic_write(key, cache_path) {|f| Marshal.dump(entry, f)}
+          true
+        end
+
+        def delete_entry(key, options)
+          if File.exist?(key)
+            begin
+              File.delete(key)
+              delete_empty_directories(File.dirname(key))
+              true
+            rescue => e
+              # Just in case the error was caused by another process deleting the file first.
+              raise e if File.exist?(key)
+              false
+            end
+          end
+        end
+
+      private
+        # Lock a file for a block so only one process can modify it at a time.
+        def lock_file(file_name, &block) # :nodoc:
+          if File.exist?(file_name)
+            File.open(file_name, 'r+') do |f|
+              begin
+                f.flock File::LOCK_EX
+                yield
+              ensure
+                f.flock File::LOCK_UN
+              end
+            end
+          else
+            yield
+          end
+        end
+
+        # Translate a key into a file path.
+        def normalize_key(key, options)
+          key = super
+          fname = URI.encode_www_form_component(key)
+
+          if fname.size > FILEPATH_MAX_SIZE
+            fname = Digest::MD5.hexdigest(key)
+          end
+
+          hash = Zlib.adler32(fname)
+          hash, dir_1 = hash.divmod(0x1000)
+          dir_2 = hash.modulo(0x1000)
+          fname_paths = []
+
+          # Make sure file name doesn't exceed file system limits.
+          begin
+            fname_paths << fname[0, FILENAME_MAX_SIZE]
+            fname = fname[FILENAME_MAX_SIZE..-1]
+          end until fname.blank?
+
+          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, *fname_paths)
+        end
+
+        def key_file_path(key)
+          ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+            `key_file_path` is deprecated and will be removed from Rails 5.1.
+            Please use `normalize_key` which will return a fully resolved key or nothing.
+          MESSAGE
+          key
+        end
+
+        # Translate a file path into a key.
+        def file_path_key(path)
+          fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last
+          URI.decode_www_form_component(fname, Encoding::UTF_8)
+        end
+
+        # Delete empty directories in the cache.
+        def delete_empty_directories(dir)
+          return if File.realpath(dir) == File.realpath(cache_path)
+          if exclude_from(dir, EXCLUDED_DIRS).empty?
+            Dir.delete(dir) rescue nil
+            delete_empty_directories(File.dirname(dir))
+          end
+        end
+
+        # Make sure a file path's directories exist.
+        def ensure_cache_path(path)
+          FileUtils.makedirs(path) unless File.exist?(path)
+        end
+
+        def search_dir(dir, &callback)
+          return if !File.exist?(dir)
+          Dir.foreach(dir) do |d|
+            next if EXCLUDED_DIRS.include?(d)
+            name = File.join(dir, d)
+            if File.directory?(name)
+              search_dir(name, &callback)
+            else
+              callback.call name
+            end
+          end
+        end
+
+        # Modifies the amount of an already existing integer value that is stored in the cache.
+        # If the key is not found nothing is done.
+        def modify_value(name, amount, options)
+          file_name = normalize_key(name, options)
+
+          lock_file(file_name) do
+            options = merged_options(options)
+
+            if num = read(name, options)
+              num = num.to_i + amount
+              write(name, num, options)
+              num
+            end
+          end
+        end
+
+        # Exclude entries from source directory
+        def exclude_from(source, excludes)
+          Dir.entries(source).reject { |f| excludes.include?(f) }
+        end
+    end
+  end
+end

data/lib/active_support/cache/mem_cache_store.rb

@@ -0,0 +1,207 @@
+begin
+  require 'dalli'
+rescue LoadError => e
+  $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+
+require 'digest/md5'
+require 'active_support/core_ext/marshal'
+require 'active_support/core_ext/array/extract_options'
+
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores data in Memcached:
+    # http://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
+      # Provide support for raw values in the local cache strategy.
+      module LocalCacheWithRaw # :nodoc:
+        protected
+        def read_entry(key, options)
+          entry = super
+          if options[:raw] && local_cache && entry
+            entry = deserialize_entry(entry.value)
+          end
+          entry
+        end
+
+        def write_entry(key, entry, options) # :nodoc:
+          if options[:raw] && local_cache
+            raw_entry = Entry.new(entry.value.to_s)
+            raw_entry.expires_at = entry.expires_at
+            super(key, raw_entry, options)
+          else
+            super
+          end
+        end
+      end
+
+      prepend Strategy::LocalCache
+      prepend LocalCacheWithRaw
+
+      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
+
+      # Creates a new Dalli::Client instance with specified addresses and options.
+      # By default address is equal localhost:11211.
+      #
+      #   ActiveSupport::Cache::MemCacheStore.build_mem_cache
+      #     # => #<Dalli::Client:0x007f98a47d2028 @servers=["localhost: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 = ["localhost:11211"] if addresses.empty?
+        Dalli::Client.new(addresses, options)
+      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 specified, then MemCacheStore will connect to
+      # localhost port 11211 (the default memcached port).
+      def initialize(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        super(options)
+
+        unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
+          raise ArgumentError, "First argument must be an empty array, an array of hosts or a Dalli::Client instance."
+        end
+        if addresses.first.is_a?(Dalli::Client)
+          @data = addresses.first
+        else
+          mem_cache_options = options.dup
+          UNIVERSAL_OPTIONS.each{|name| mem_cache_options.delete(name)}
+          @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
+        end
+      end
+
+      # Reads multiple values from the cache using a single call to the
+      # servers for all keys. Options can be passed in the last argument.
+      def read_multi(*names)
+        options = names.extract_options!
+        options = merged_options(options)
+
+        keys_to_names = Hash[names.map{|name| [normalize_key(name, options), name]}]
+        raw_values = @data.get_multi(keys_to_names.keys)
+        values = {}
+        raw_values.each do |key, value|
+          entry = deserialize_entry(value)
+          values[keys_to_names[key]] = entry.value unless entry.expired?
+        end
+        values
+      end
+
+      # Increment a cached value. This method uses the memcached incr atomic
+      # operator and can only be used on values written with the :raw option.
+      # Calling it on a value not stored with :raw will initialize that value
+      # to zero.
+      def increment(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        instrument(:increment, name, :amount => amount) do
+          rescue_error_with nil do
+            @data.incr(normalize_key(name, options), amount)
+          end
+        end
+      end
+
+      # Decrement a cached value. This method uses the memcached decr atomic
+      # operator and can only be used on values written with the :raw option.
+      # Calling it on a value not stored with :raw will initialize that value
+      # to zero.
+      def decrement(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        instrument(:decrement, name, :amount => amount) do
+          rescue_error_with nil do
+            @data.decr(normalize_key(name, options), amount)
+          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.flush_all }
+      end
+
+      # Get the statistics from the memcached servers.
+      def stats
+        @data.stats
+      end
+
+      protected
+        # Read an entry from the cache.
+        def read_entry(key, options) # :nodoc:
+          rescue_error_with(nil) { deserialize_entry(@data.get(key, options)) }
+        end
+
+        # Write an entry to the cache.
+        def write_entry(key, entry, options) # :nodoc:
+          method = options && options[:unless_exist] ? :add : :set
+          value = options[:raw] ? entry.value.to_s : entry
+          expires_in = options[:expires_in].to_i
+          if 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 false do
+            @data.send(method, key, value, expires_in, options)
+          end
+        end
+
+        # Delete an entry from the cache.
+        def delete_entry(key, options) # :nodoc:
+          rescue_error_with(false) { @data.delete(key) }
+        end
+
+      private
+
+        # 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 = super.dup
+          key = key.force_encoding(Encoding::ASCII_8BIT)
+          key = key.gsub(ESCAPE_KEY_CHARS){ |match| "%#{match.getbyte(0).to_s(16).upcase}" }
+          key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
+          key
+        end
+
+        def escape_key(key)
+          ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+            `escape_key` is deprecated and will be removed from Rails 5.1.
+            Please use `normalize_key` which will return a fully resolved key or nothing.
+          MESSAGE
+          key
+        end
+
+        def deserialize_entry(raw_value)
+          if raw_value
+            entry = Marshal.load(raw_value) rescue raw_value
+            entry.is_a?(Entry) ? entry : Entry.new(entry)
+          end
+        end
+
+        def rescue_error_with(fallback)
+          yield
+        rescue Dalli::DalliError => e
+          logger.error("DalliError (#{e}): #{e.message}") if logger
+          fallback
+        end
+    end
+  end
+end

data/lib/active_support/cache/memory_store.rb

@@ -0,0 +1,167 @@
+require 'monitor'
+
+module ActiveSupport
+  module Cache
+    # 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 mongrel_cluster or Phusion Passenger),
+    # 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.
+    #
+    # MemoryStore is thread-safe.
+    class MemoryStore < Store
+      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 clear(options = nil)
+        synchronize do
+          @data.clear
+          @key_access.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 = 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
+
+      # Returns true if the cache is currently being pruned.
+      def pruning?
+        @pruning
+      end
+
+      # Increment an integer value in the cache.
+      def increment(name, amount = 1, options = nil)
+        modify_value(name, amount, options)
+      end
+
+      # Decrement an integer value in the cache.
+      def decrement(name, amount = 1, options = nil)
+        modify_value(name, -amount, options)
+      end
+
+      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 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
+
+        PER_ENTRY_OVERHEAD = 240
+
+        def cached_size(key, entry) # :nodoc:
+          key.to_s.bytesize + entry.size + PER_ENTRY_OVERHEAD
+        end
+
+        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:
+          entry.dup_value!
+          synchronize do
+            old_entry = @data[key]
+            return false if @data.key?(key) && options[:unless_exist]
+            if old_entry
+              @cache_size -= (old_entry.size - entry.size)
+            else
+              @cache_size += cached_size(key, entry)
+            end
+            @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 -= cached_size(key, entry) if entry
+            !!entry
+          end
+        end
+
+      private
+
+        def modify_value(name, amount, options)
+          synchronize do
+            options = merged_options(options)
+            if num = read(name, options)
+              num = num.to_i + amount
+              write(name, num, options)
+              num
+            end
+          end
+        end
+    end
+  end
+end