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.

Methods
C
D
I
N
R
W
Constants
DIR_FORMATTER = "%03X"
 
FILENAME_MAX_SIZE = 228
 
FILEPATH_MAX_SIZE = 900
 
EXCLUDED_DIRS = ['.', '..'].freeze
 
Attributes
[R] cache_path
Class Public methods
new(cache_path, options = nil)
# File activesupport/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
Instance Public methods
cleanup(options = nil)

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

# File activesupport/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)

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 activesupport/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)

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

# File activesupport/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)
# File activesupport/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)

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

# File activesupport/lib/active_support/cache/file_store.rb, line 46
def increment(name, amount = 1, options = nil)
  modify_value(name, amount, options)
end
Instance Protected methods
delete_entry(key, options)
# File activesupport/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)
# File activesupport/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)
# File activesupport/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