class ActiveSupport::Cache::FileStore - activesupport-4.2.3 Documentation

# class ActiveSupport::Cache::FileStore

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.

### Constants

DIR_FORMATTER
EXCLUDED_DIRS
FILENAME_MAX_SIZE
FILEPATH_MAX_SIZE

### Attributes

cache_path[R]

### Public Class Methods

new(cache_path, options = nil) click to toggle source
Calls superclass method ActiveSupport::Cache::Store.new

    # File lib/active_support/cache/file_store.rb, line 20
    def initialize(cache_path, options = nil)
      super(options)
      @cache_path = cache_path.to_s
      extend Strategy::LocalCache
    end

### Public Instance Methods

cleanup(options = nil) click to toggle source

Preemptively iterates through all stored keys and removes the ones which have expired.

    # File lib/active_support/cache/file_store.rb, line 35
    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

clear(options = nil) click to toggle source

Deletes all items from the cache. In this case it deletes all the entries in the specified file store directory except for .gitkeep. Be careful which directory is specified in your config file when using `FileStore` because everything in that directory will be deleted.

    # File lib/active_support/cache/file_store.rb, line 29
    def clear(options = nil)
      root_dirs = Dir.entries(cache_path).reject {|f| (EXCLUDED_DIRS + [".gitkeep"]).include?(f)}
      FileUtils.rm_r(root_dirs.collect{|f| File.join(cache_path, f)})
    end

decrement(name, amount = 1, options = nil) click to toggle source

Decrements an already existing integer value that is stored in the cache. If the key is not found nothing is done.

    # File lib/active_support/cache/file_store.rb, line 52
    def decrement(name, amount = 1, options = nil)
      modify_value(name, -amount, options)
    end

delete_matched(matcher, options = nil) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 56
    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(key, options) if key.match(matcher)
        end
      end
    end

increment(name, amount = 1, options = nil) click to toggle source

Increments an already existing integer value that is stored in the cache. If the key is not found nothing is done.

    # File lib/active_support/cache/file_store.rb, line 46
    def increment(name, amount = 1, options = nil)
      modify_value(name, amount, options)
    end

### Protected Instance Methods

delete_entry(key, options) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 87
    def delete_entry(key, options)
      file_name = key_file_path(key)
      if File.exist?(file_name)
        begin
          File.delete(file_name)
          delete_empty_directories(File.dirname(file_name))
          true
        rescue => e
          # Just in case the error was caused by another process deleting the file first.
          raise e if File.exist?(file_name)
          false
        end
      end
    end

read_entry(key, options) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 69
    def read_entry(key, options)
      file_name = key_file_path(key)
      if File.exist?(file_name)
        File.open(file_name) { |f| Marshal.load(f) }
      end
    rescue => e
      logger.error("FileStoreError (#{e}): #{e.message}") if logger
      nil
    end

write_entry(key, entry, options) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 79
    def write_entry(key, entry, options)
      file_name = key_file_path(key)
      return false if options[:unless_exist] && File.exist?(file_name)
      ensure_cache_path(File.dirname(file_name))
      File.atomic_write(file_name, cache_path) {|f| Marshal.dump(entry, f)}
      true
    end

### Private Instance Methods

delete_empty_directories(dir) click to toggle source

Delete empty directories in the cache.

    # File lib/active_support/cache/file_store.rb, line 147
    def delete_empty_directories(dir)
      return if File.realpath(dir) == File.realpath(cache_path)
      if Dir.entries(dir).reject {|f| EXCLUDED_DIRS.include?(f)}.empty?
        Dir.delete(dir) rescue nil
        delete_empty_directories(File.dirname(dir))
      end
    end

ensure_cache_path(path) click to toggle source

Make sure a file path's directories exist.

    # File lib/active_support/cache/file_store.rb, line 156
    def ensure_cache_path(path)
      FileUtils.makedirs(path) unless File.exist?(path)
    end

file_path_key(path) click to toggle source

Translate a file path into a key.

    # File lib/active_support/cache/file_store.rb, line 141
    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

key_file_path(key) click to toggle source

Translate a key into a file path.

    # File lib/active_support/cache/file_store.rb, line 120
    def key_file_path(key)
      if key.size > FILEPATH_MAX_SIZE
        key = Digest::MD5.hexdigest(key)
      end

      fname = URI.encode_www_form_component(key)
      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

modify_value(name, amount, options) click to toggle source

Modifies the amount of an already existing integer value that is stored in the cache. If the key is not found nothing is done.

    # File lib/active_support/cache/file_store.rb, line 175
    def modify_value(name, amount, options)
      file_name = key_file_path(namespaced_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

search_dir(dir, &callback) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 160
    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