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
GITKEEP_FILES

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 22
def initialize(cache_path, options = nil)
  super(options)
  @cache_path = cache_path.to_s
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 37
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 .keep or .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 30
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
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 54
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 58
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
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 48
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)
  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
read_entry(key, options) click to toggle source
# File lib/active_support/cache/file_store.rb, line 71
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
write_entry(key, entry, options) click to toggle source
# File lib/active_support/cache/file_store.rb, line 80
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

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 156
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
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 165
def ensure_cache_path(path)
  FileUtils.makedirs(path) unless File.exist?(path)
end
exclude_from(source, excludes) click to toggle source

Exclude entries from source directory

# File lib/active_support/cache/file_store.rb, line 199
def exclude_from(source, excludes)
  Dir.entries(source).reject { |f| excludes.include?(f) }
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 150
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
# File lib/active_support/cache/file_store.rb, line 141
        def key_file_path(key)
          ActiveSupport::Deprecation.warn("            `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.
".strip_heredoc)
          key
        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 184
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
normalize_key(key, options) click to toggle source

Translate a key into a file path.

# File lib/active_support/cache/file_store.rb, line 119
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
search_dir(dir, &callback) click to toggle source
# File lib/active_support/cache/file_store.rb, line 169
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