class ActiveSupport::Cache::FileStore

Parent:: ActiveSupport::Cache::Store

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

Attributes

cache_path[R]

Public Class Methods

new(cache_path, options = nil) Show source

Calls superclass method ActiveSupport::Cache::Store.new

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

Public Instance Methods

cleanup(options = nil) Show source

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

# File activesupport/lib/active_support/cache/file_store.rb, line 34
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) Show 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 activesupport/lib/active_support/cache/file_store.rb, line 28
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) Show source

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 51
def decrement(name, amount = 1, options = nil)
  modify_value(name, -amount, options)
end

delete_matched(matcher, options = nil) Show source

# File activesupport/lib/active_support/cache/file_store.rb, line 55
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) Show source

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 45
def increment(name, amount = 1, options = nil)
  modify_value(name, amount, options)
end

Protected Instance Methods

delete_entry(key, options) Show source

# File activesupport/lib/active_support/cache/file_store.rb, line 86
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) Show source

# File activesupport/lib/active_support/cache/file_store.rb, line 68
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) Show source

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