Class: Sprockets::Cache::FileStore

Inherits:
Object
  • Object
show all
Defined in:
lib/sprockets/cache/file_store.rb

Overview

Public: A file system cache store that automatically cleans up old keys.

Assign the instance to the Environment#cache.

environment.cache = Sprockets::Cache::FileStore.new("/tmp")

See Also

ActiveSupport::Cache::FileStore

Constant Summary collapse

DEFAULT_MAX_SIZE =

Internal: Default key limit for store.

25 * 1024 * 1024
EXCLUDED_DIRS =
['.', '..'].freeze
GITKEEP_FILES =
['.gitkeep', '.keep'].freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(root, max_size = DEFAULT_MAX_SIZE, logger = self.class.default_logger) ⇒ FileStore

Public: Initialize the cache store.

root - A String path to a directory to persist cached values to. max_size - A Integer of the maximum size the store will hold (in bytes).

(default: 25MB).

logger - The logger to which some info will be printed.

(default logger level is FATAL and won't output anything).

42
43
44
45
46
47
# File 'lib/sprockets/cache/file_store.rb', line 42

def initialize(root, max_size = DEFAULT_MAX_SIZE, logger = self.class.default_logger)
  @root     = root
  @max_size = max_size
  @gc_size  = max_size * 0.75
  @logger   = logger
end

Class Method Details

.default_loggerObject

Internal: Default standard error fatal logger.

Returns a Logger.


29
30
31
32
33
# File 'lib/sprockets/cache/file_store.rb', line 29

def self.default_logger
  logger = Logger.new($stderr)
  logger.level = Logger::FATAL
  logger
end

Instance Method Details

#clear(options = nil) ⇒ Object

Public: Clear the cache

adapted from ActiveSupport::Cache::FileStore#clear

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 as @root because everything in that directory will be deleted.

Returns true


139
140
141
142
143
144
145
# File 'lib/sprockets/cache/file_store.rb', line 139

def clear(options=nil)
  if File.exist?(@root)
    root_dirs = Dir.entries(@root).reject { |f| (EXCLUDED_DIRS + GITKEEP_FILES).include?(f) }
    FileUtils.rm_r(root_dirs.collect{ |f| File.join(@root, f) })
  end
  true
end

#get(key) ⇒ Object

Public: Retrieve value from cache.

This API should not be used directly, but via the Cache wrapper API.

key - String cache key.

Returns Object or nil or the value is not set.


56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
# File 'lib/sprockets/cache/file_store.rb', line 56

def get(key)
  path = File.join(@root, "#{key}.cache")

  value = safe_open(path) do |f|
    begin
      EncodingUtils.unmarshaled_deflated(f.read, Zlib::MAX_WBITS)
    rescue Exception => e
      @logger.error do
        "#{self.class}[#{path}] could not be unmarshaled: " +
          "#{e.class}: #{e.message}"
      end
      nil
    end
  end

  if value
    FileUtils.touch(path)
    value
  end
end

#inspectObject

Public: Pretty inspect

Returns String.


126
127
128
# File 'lib/sprockets/cache/file_store.rb', line 126

def inspect
  "#<#{self.class} size=#{size}/#{@max_size}>"
end

#set(key, value) ⇒ Object

Public: Set a key and value in the cache.

This API should not be used directly, but via the Cache wrapper API.

key - String cache key. value - Object value.

Returns Object value.


85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
# File 'lib/sprockets/cache/file_store.rb', line 85

def set(key, value)
  path = File.join(@root, "#{key}.cache")

  # Ensure directory exists
  FileUtils.mkdir_p File.dirname(path)

  # Check if cache exists before writing
  exists = File.exist?(path)

  # Serialize value
  marshaled = Marshal.dump(value)

  # Compress if larger than 4KB
  if marshaled.bytesize > 4 * 1024
    deflater = Zlib::Deflate.new(
      Zlib::BEST_COMPRESSION,
      Zlib::MAX_WBITS,
      Zlib::MAX_MEM_LEVEL,
      Zlib::DEFAULT_STRATEGY
    )
    deflater << marshaled
    raw = deflater.finish
  else
    raw = marshaled
  end

  # Write data
  PathUtils.atomic_write(path) do |f|
    f.write(raw)
    @size = size + f.size unless exists
  end

  # GC if necessary
  gc! if size > @max_size

  value
end