diff options
Diffstat (limited to 'lib/python2.7/site-packages/django/middleware/cache.py')
| -rw-r--r-- | lib/python2.7/site-packages/django/middleware/cache.py | 213 |
1 files changed, 0 insertions, 213 deletions
diff --git a/lib/python2.7/site-packages/django/middleware/cache.py b/lib/python2.7/site-packages/django/middleware/cache.py deleted file mode 100644 index 7bbc167..0000000 --- a/lib/python2.7/site-packages/django/middleware/cache.py +++ /dev/null @@ -1,213 +0,0 @@ -""" -Cache middleware. If enabled, each Django-powered page will be cached based on -URL. The canonical way to enable cache middleware is to set -``UpdateCacheMiddleware`` as your first piece of middleware, and -``FetchFromCacheMiddleware`` as the last:: - - MIDDLEWARE_CLASSES = [ - 'django.middleware.cache.UpdateCacheMiddleware', - ... - 'django.middleware.cache.FetchFromCacheMiddleware' - ] - -This is counter-intuitive, but correct: ``UpdateCacheMiddleware`` needs to run -last during the response phase, which processes middleware bottom-up; -``FetchFromCacheMiddleware`` needs to run last during the request phase, which -processes middleware top-down. - -The single-class ``CacheMiddleware`` can be used for some simple sites. -However, if any other piece of middleware needs to affect the cache key, you'll -need to use the two-part ``UpdateCacheMiddleware`` and -``FetchFromCacheMiddleware``. This'll most often happen when you're using -Django's ``LocaleMiddleware``. - -More details about how the caching works: - -* Only GET or HEAD-requests with status code 200 are cached. - -* The number of seconds each page is stored for is set by the "max-age" section - of the response's "Cache-Control" header, falling back to the - CACHE_MIDDLEWARE_SECONDS setting if the section was not found. - -* This middleware expects that a HEAD request is answered with the same response - headers exactly like the corresponding GET request. - -* When a hit occurs, a shallow copy of the original response object is returned - from process_request. - -* Pages will be cached based on the contents of the request headers listed in - the response's "Vary" header. - -* This middleware also sets ETag, Last-Modified, Expires and Cache-Control - headers on the response object. - -""" - -import warnings - -from django.conf import settings -from django.core.cache import get_cache, DEFAULT_CACHE_ALIAS -from django.utils.cache import (get_cache_key, get_max_age, has_vary_header, - learn_cache_key, patch_response_headers) - - -class UpdateCacheMiddleware(object): - """ - Response-phase cache middleware that updates the cache if the response is - cacheable. - - Must be used as part of the two-part update/fetch cache middleware. - UpdateCacheMiddleware must be the first piece of middleware in - MIDDLEWARE_CLASSES so that it'll get called last during the response phase. - """ - def __init__(self): - self.cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS - self.key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX - self.cache_anonymous_only = getattr(settings, 'CACHE_MIDDLEWARE_ANONYMOUS_ONLY', False) - self.cache_alias = settings.CACHE_MIDDLEWARE_ALIAS - self.cache = get_cache(self.cache_alias) - - def _session_accessed(self, request): - try: - return request.session.accessed - except AttributeError: - return False - - def _should_update_cache(self, request, response): - if not hasattr(request, '_cache_update_cache') or not request._cache_update_cache: - return False - # If the session has not been accessed otherwise, we don't want to - # cause it to be accessed here. If it hasn't been accessed, then the - # user's logged-in status has not affected the response anyway. - if self.cache_anonymous_only and self._session_accessed(request): - assert hasattr(request, 'user'), "The Django cache middleware with CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True requires authentication middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.auth.middleware.AuthenticationMiddleware' before the CacheMiddleware." - if request.user.is_authenticated(): - # Don't cache user-variable requests from authenticated users. - return False - return True - - def process_response(self, request, response): - """Sets the cache, if needed.""" - if not self._should_update_cache(request, response): - # We don't need to update the cache, just return. - return response - - if response.streaming or response.status_code != 200: - return response - - # Don't cache responses that set a user-specific (and maybe security - # sensitive) cookie in response to a cookie-less request. - if not request.COOKIES and response.cookies and has_vary_header(response, 'Cookie'): - return response - - # Try to get the timeout from the "max-age" section of the "Cache- - # Control" header before reverting to using the default cache_timeout - # length. - timeout = get_max_age(response) - if timeout == None: - timeout = self.cache_timeout - elif timeout == 0: - # max-age was set to 0, don't bother caching. - return response - patch_response_headers(response, timeout) - if timeout: - cache_key = learn_cache_key(request, response, timeout, self.key_prefix, cache=self.cache) - if hasattr(response, 'render') and callable(response.render): - response.add_post_render_callback( - lambda r: self.cache.set(cache_key, r, timeout) - ) - else: - self.cache.set(cache_key, response, timeout) - return response - -class FetchFromCacheMiddleware(object): - """ - Request-phase cache middleware that fetches a page from the cache. - - Must be used as part of the two-part update/fetch cache middleware. - FetchFromCacheMiddleware must be the last piece of middleware in - MIDDLEWARE_CLASSES so that it'll get called last during the request phase. - """ - def __init__(self): - self.cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS - self.key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX - self.cache_alias = settings.CACHE_MIDDLEWARE_ALIAS - self.cache = get_cache(self.cache_alias) - - def process_request(self, request): - """ - Checks whether the page is already cached and returns the cached - version if available. - """ - if not request.method in ('GET', 'HEAD'): - request._cache_update_cache = False - return None # Don't bother checking the cache. - - # try and get the cached GET response - cache_key = get_cache_key(request, self.key_prefix, 'GET', cache=self.cache) - if cache_key is None: - request._cache_update_cache = True - return None # No cache information available, need to rebuild. - response = self.cache.get(cache_key, None) - # if it wasn't found and we are looking for a HEAD, try looking just for that - if response is None and request.method == 'HEAD': - cache_key = get_cache_key(request, self.key_prefix, 'HEAD', cache=self.cache) - response = self.cache.get(cache_key, None) - - if response is None: - request._cache_update_cache = True - return None # No cache information available, need to rebuild. - - # hit, return cached response - request._cache_update_cache = False - return response - -class CacheMiddleware(UpdateCacheMiddleware, FetchFromCacheMiddleware): - """ - Cache middleware that provides basic behavior for many simple sites. - - Also used as the hook point for the cache decorator, which is generated - using the decorator-from-middleware utility. - """ - def __init__(self, cache_timeout=None, cache_anonymous_only=None, **kwargs): - # We need to differentiate between "provided, but using default value", - # and "not provided". If the value is provided using a default, then - # we fall back to system defaults. If it is not provided at all, - # we need to use middleware defaults. - - cache_kwargs = {} - - try: - self.key_prefix = kwargs['key_prefix'] - if self.key_prefix is not None: - cache_kwargs['KEY_PREFIX'] = self.key_prefix - else: - self.key_prefix = '' - except KeyError: - self.key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX - cache_kwargs['KEY_PREFIX'] = self.key_prefix - - try: - self.cache_alias = kwargs['cache_alias'] - if self.cache_alias is None: - self.cache_alias = DEFAULT_CACHE_ALIAS - if cache_timeout is not None: - cache_kwargs['TIMEOUT'] = cache_timeout - except KeyError: - self.cache_alias = settings.CACHE_MIDDLEWARE_ALIAS - if cache_timeout is None: - cache_kwargs['TIMEOUT'] = settings.CACHE_MIDDLEWARE_SECONDS - else: - cache_kwargs['TIMEOUT'] = cache_timeout - - if cache_anonymous_only is None: - self.cache_anonymous_only = getattr(settings, 'CACHE_MIDDLEWARE_ANONYMOUS_ONLY', False) - else: - self.cache_anonymous_only = cache_anonymous_only - - if self.cache_anonymous_only: - msg = "CACHE_MIDDLEWARE_ANONYMOUS_ONLY has been deprecated and will be removed in Django 1.8." - warnings.warn(msg, PendingDeprecationWarning, stacklevel=1) - - self.cache = get_cache(self.cache_alias, **cache_kwargs) - self.cache_timeout = self.cache.default_timeout |