class Rack::Cache::MetaStore

# File lib/rack/cache/meta_store.rb, line 112
def cache_key(request)
  keygen = request.env['rack-cache.cache_key'] || Key
  keygen.call(request)
end

# File lib/rack/cache/meta_store.rb, line 118
def invalidate(request, entity_store)
  modified = false
  key = cache_key(request)
  entries =
    read(key).map do |req, res|
      response = restore_response(res)
      if response.fresh?
        response.expire!
        modified = true
      end
      [req, persist_response(response)]
    end
  write key, entries if modified
end

# File lib/rack/cache/meta_store.rb, line 28
def lookup(request, entity_store)
  key = cache_key(request)
  entries = read(key)

  # bail out if we have nothing cached
  return nil if entries.empty?

  # find a cached entry that matches the request.
  env = request.env
  match = entries.detect{ |req,res| requests_match?((res['vary'] || res['vary']), env, req) }
  return nil if match.nil?

  _, res = match
  entity_key = res['x-content-digest']
  if entity_key && body = entity_store.open(entity_key)
    restore_response(res, body)
  else
    # the metastore referenced an entity that doesn't exist in
    # the entitystore, purge the entry from the meta-store
    begin
      purge(key)
    rescue NotImplementedError
      @@warned_on_purge ||= begin
        warn "WARNING: Future releases may require purge implementation for #{self.class.name}"
        true
      end
      nil
    end
  end
end

# File lib/rack/cache/meta_store.rb, line 62
def store(request, response, entity_store)
  key = cache_key(request)
  stored_env = persist_request(request)

  # write the response body to the entity store if this is the
  # original response.
  if response.headers['x-content-digest'].nil?
    if request.env['rack-cache.use_native_ttl'] && response.fresh?
      digest, size = entity_store.write(response.body, response.ttl)
    else
      digest, size = entity_store.write(response.body)
    end
    response.headers['x-content-digest'] = digest
    response.headers['content-length'] = size.to_s unless response.headers['Transfer-Encoding']

    # If the entitystore backend is a Noop, do not try to read the body from the backend, it always returns an empty array
    unless entity_store.is_a? Rack::Cache::EntityStore::Noop
      # A stream body can only be read once and is currently closed by #write.
      # (To avoid having to keep giant objects in memory when writing to disk cache
      # the body is never converted to a single string)
      # We cannot always reply on body to be re-readable,
      # so we have to read it from the cache.
      # BUG: if the cache was unable to store a stream, the stream will be closed
      #      and rack will try to read it again, resulting in hard to track down exception
      response.body = entity_store.open(digest) || response.body
    end
  end

  # read existing cache entries, remove non-varying, and add this one to
  # the list
  vary = response.vary
  entries =
    read(key).reject do |env, res|
      (vary == (res['vary'])) &&
        requests_match?(vary, env, stored_env)
    end

  headers = persist_response(response)
  headers.delete('age')

  entries.unshift [stored_env, headers]
  if request.env['rack-cache.use_native_ttl'] && response.fresh?
    write key, entries, response.ttl
  else
    write key, entries
  end
  key
end

# File lib/rack/cache/meta_store.rb, line 185
def purge(key)
  raise NotImplementedError
end

# File lib/rack/cache/meta_store.rb, line 172
def read(key)
  raise NotImplementedError
end

# File lib/rack/cache/meta_store.rb, line 179
def write(key, negotiations, ttl = nil)
  raise NotImplementedError
end