Class: Rack::ResponseCache

Inherits:
Object
  • Object
show all
Defined in:
lib/rack/contrib/response_cache.rb

Overview

Rack::ResponseCache is a Rack middleware that caches responses for successful GET requests with no query string to disk or any ruby object that has an []= method (so it works with memcached). When caching to disk, it works similar to Rails’ page caching, allowing you to cache dynamic pages to static files that can be served directly by a front end webserver.

Constant Summary collapse

DEFAULT_PATH_PROC =

The default proc used if a block is not provided to .new It unescapes the PATH_INFO of the environment, and makes sure that it doesn’t include ‘..’. If the Content-Type of the response is text/(html|css|xml), return a path with the appropriate extension (.html, .css, or .xml). If the path ends with a / and the Content-Type is text/html, change the basename of the path to index.html.

proc do |env, res|
  path = Rack::Utils.unescape(env['PATH_INFO'])
  if !path.include?('..') and match = /text\/((?:x|ht)ml|css)/o.match(res[1]['Content-Type'])
    type = match[1]
    path = "#{path}.#{type}" unless /\.#{type}\z/.match(path)
    path = File.join(File.dirname(path), 'index.html') if type == 'html' and File.basename(path) == '.html'
    path
  end
end

Instance Method Summary collapse

Constructor Details

#initialize(app, cache, &block) ⇒ ResponseCache

Initialize a new ReponseCache object with the given arguments. Arguments:

  • app : The next middleware in the chain. This is always called.

  • cache : The place to cache responses. If a string is provided, a disk cache is used, and all cached files will use this directory as the root directory. If anything other than a string is provided, it should respond to []=, which will be called with a path string and a body value (the 3rd element of the response).

  • &block : If provided, it is called with the environment and the response from the next middleware. It should return nil or false if the path should not be cached, and should return the pathname to use as a string if the result should be cached. If not provided, the DEFAULT_PATH_PROC is used.



36
37
38
39
40
 
# File 'lib/rack/contrib/response_cache.rb', line 36

def initialize(app, cache, &block)
  @app = app
  @cache = cache
  @path_proc = block || DEFAULT_PATH_PROC
end

Instance Method Details

#call(env) ⇒ Object

Call the next middleware with the environment. If the request was successful (response status 200), was a GET request, and had an empty query string, call the block set up in initialize to get the path. If the cache is a string, create any necessary middle directories, and cache the file in the appropriate subdirectory of cache. Otherwise, cache the body of the reponse as the value with the path as the key.



46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/rack/contrib/response_cache.rb', line 46

def call(env)
  res = @app.call(env)
  if env['REQUEST_METHOD'] == 'GET' and env['QUERY_STRING'] == '' and res[0] == 200 and path = @path_proc.call(env, res)
    if @cache.is_a?(String)
      path = File.join(@cache, path) if @cache
      FileUtils.mkdir_p(File.dirname(path))
      File.open(path, 'wb'){|f| res[2].each{|c| f.write(c)}}
    else
      @cache[path] = res[2]
    end
  end
  res
end