Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Fixed #11675 -- Added support for the PyLibMC cache library. In order…

… to support this, and clean up some other 1.3 caching additions, this patch also includes some changes to the way caches are defined. This means you can now have multiple caches, in the same way you have multiple databases. A huge thanks to Jacob Burch for the work on the PyLibMC backend, and to Jannis for his work on the cache definition changes.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@15005 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
commit 673e6fc7fb243ed44841b9969d26a161c25733b3 1 parent 3cf8502
@freakboy3742 freakboy3742 authored
View
7 django/conf/global_settings.py
@@ -431,14 +431,15 @@
# CACHE #
#########
+# New format
+CACHES = {
+}
# The cache backend to use. See the docstring in django.core.cache for the
# possible values.
CACHE_BACKEND = 'locmem://'
-CACHE_VERSION = 1
-CACHE_KEY_PREFIX = ''
-CACHE_KEY_FUNCTION = None
CACHE_MIDDLEWARE_KEY_PREFIX = ''
CACHE_MIDDLEWARE_SECONDS = 600
+CACHE_MIDDLEWARE_ALIAS = 'default'
####################
# COMMENTS #
View
13 django/contrib/gis/db/backends/spatialite/creation.py
@@ -1,5 +1,7 @@
import os
from django.conf import settings
+from django.core.cache import get_cache
+from django.core.cache.backends.db import BaseDatabaseCache
from django.core.exceptions import ImproperlyConfigured
from django.core.management import call_command
from django.db.backends.sqlite3.creation import DatabaseCreation
@@ -28,11 +30,12 @@ def create_test_db(self, verbosity=1, autoclobber=False):
self.load_spatialite_sql()
call_command('syncdb', verbosity=verbosity, interactive=False, database=self.connection.alias)
- if settings.CACHE_BACKEND.startswith('db://'):
- from django.core.cache import parse_backend_uri
- _, cache_name, _ = parse_backend_uri(settings.CACHE_BACKEND)
- call_command('createcachetable', cache_name)
-
+ for cache_alias in settings.CACHES:
+ cache = get_cache(cache_alias)
+ if isinstance(cache, BaseDatabaseCache):
+ from django.db import router
+ if router.allow_syncdb(self.connection.alias, cache.cache_model_class):
+ call_command('createcachetable', cache._table, database=self.connection.alias)
# Get a cursor (even though we don't need one yet). This has
# the side effect of initializing the test database.
cursor = self.connection.cursor()
View
128 django/core/cache/__init__.py
@@ -12,8 +12,13 @@
(e.g. "memcached://127.0.0.1:11211/") and returns an instance of a backend
cache class.
-See docs/cache.txt for information on the public API.
+See docs/topics/cache.txt for information on the public API.
"""
+from django.conf import settings
+from django.core import signals
+from django.core.cache.backends.base import (
+ InvalidCacheBackendError, CacheKeyWarning, BaseCache)
+from django.utils import importlib
try:
# The mod_python version is more efficient, so try importing it first.
@@ -27,10 +32,9 @@
# PendingDeprecationWarning
from cgi import parse_qsl
-from django.conf import settings
-from django.core import signals
-from django.core.cache.backends.base import InvalidCacheBackendError, CacheKeyWarning
-from django.utils import importlib
+__all__ = [
+ 'get_cache', 'cache', 'DEFAULT_CACHE_ALIAS'
+]
# Name for use in settings file --> name of module in "backends" directory.
# Any backend scheme that is not in this dictionary is treated as a Python
@@ -43,6 +47,8 @@
'dummy': 'dummy',
}
+DEFAULT_CACHE_ALIAS = 'default'
+
def parse_backend_uri(backend_uri):
"""
Converts the "backend_uri" into a cache scheme ('db', 'memcached', etc), a
@@ -67,32 +73,102 @@ def parse_backend_uri(backend_uri):
return scheme, host, params
-def get_cache(backend_uri, key_prefix=None, version=None, key_func=None):
- if key_prefix is None:
- key_prefix = settings.CACHE_KEY_PREFIX
- if version is None:
- version = settings.CACHE_VERSION
- if key_func is None:
- key_func = settings.CACHE_KEY_FUNCTION
-
- if key_func is not None and not callable(key_func):
- key_func_module_path, key_func_name = key_func.rsplit('.', 1)
- key_func_module = importlib.import_module(key_func_module_path)
- key_func = getattr(key_func_module, key_func_name)
-
- scheme, host, params = parse_backend_uri(backend_uri)
- if scheme in BACKENDS:
- name = 'django.core.cache.backends.%s' % BACKENDS[scheme]
+if not settings.CACHES:
+ import warnings
+ warnings.warn(
+ "settings.CACHE_* is deprecated; use settings.CACHES instead.",
+ PendingDeprecationWarning
+ )
+ # Mapping for new-style cache backend api
+ backend_classes = {
+ 'memcached': 'memcached.CacheClass',
+ 'locmem': 'locmem.LocMemCache',
+ 'file': 'filebased.FileBasedCache',
+ 'db': 'db.DatabaseCache',
+ 'dummy': 'dummy.DummyCache',
+ }
+ engine, host, params = parse_backend_uri(settings.CACHE_BACKEND)
+ if engine in backend_classes:
+ engine = 'django.core.cache.backends.%s' % backend_classes[engine]
+ defaults = {
+ 'BACKEND': engine,
+ 'LOCATION': host,
+ }
+ defaults.update(params)
+ settings.CACHES[DEFAULT_CACHE_ALIAS] = defaults
+
+if DEFAULT_CACHE_ALIAS not in settings.CACHES:
+ raise ImproperlyConfigured("You must define a '%s' cache" % DEFAULT_CACHE_ALIAS)
+
+def parse_backend_conf(backend, **kwargs):
+ """
+ Helper function to parse the backend configuration
+ that doesn't use the URI notation.
+ """
+ # Try to get the CACHES entry for the given backend name first
+ conf = settings.CACHES.get(backend, None)
+ if conf is not None:
+ args = conf.copy()
+ backend = args.pop('BACKEND')
+ location = args.pop('LOCATION', '')
+ return backend, location, args
else:
- name = scheme
- module = importlib.import_module(name)
- return module.CacheClass(host, params, key_prefix=key_prefix, version=version, key_func=key_func)
+ # Trying to import the given backend, in case it's a dotted path
+ mod_path, cls_name = backend.rsplit('.', 1)
+ try:
+ mod = importlib.import_module(mod_path)
+ backend_cls = getattr(mod, cls_name)
+ except (AttributeError, ImportError):
+ raise InvalidCacheBackendError("Could not find backend '%s'" % backend)
+ location = kwargs.pop('LOCATION', '')
+ return backend, location, kwargs
+ raise InvalidCacheBackendError(
+ "Couldn't find a cache backend named '%s'" % backend)
-cache = get_cache(settings.CACHE_BACKEND)
+def get_cache(backend, **kwargs):
+ """
+ Function to load a cache backend dynamically. This is flexible by design
+ to allow different use cases:
+
+ To load a backend with the old URI-based notation::
+
+ cache = get_cache('locmem://')
+
+ To load a backend that is pre-defined in the settings::
+
+ cache = get_cache('default')
+
+ To load a backend with its dotted import path,
+ including arbitrary options::
+
+ cache = get_cache('django.core.cache.backends.memcached.MemcachedCache', **{
+ 'LOCATION': '127.0.0.1:11211', 'TIMEOUT': 30,
+ })
+
+ """
+ try:
+ if '://' in backend:
+ # for backwards compatibility
+ backend, location, params = parse_backend_uri(backend)
+ if backend in BACKENDS:
+ backend = 'django.core.cache.backends.%s' % BACKENDS[backend]
+ params.update(kwargs)
+ mod = importlib.import_module(backend)
+ backend_cls = mod.CacheClass
+ else:
+ backend, location, params = parse_backend_conf(backend, **kwargs)
+ mod_path, cls_name = backend.rsplit('.', 1)
+ mod = importlib.import_module(mod_path)
+ backend_cls = getattr(mod, cls_name)
+ except (AttributeError, ImportError), e:
+ raise InvalidCacheBackendError(
+ "Could not find backend '%s': %s" % (backend, e))
+ return backend_cls(location, params)
+
+cache = get_cache(DEFAULT_CACHE_ALIAS)
# Some caches -- python-memcached in particular -- need to do a cleanup at the
# end of a request cycle. If the cache provides a close() method, wire it up
# here.
if hasattr(cache, 'close'):
signals.request_finished.connect(cache.close)
-
View
37 django/core/cache/backends/base.py
@@ -2,8 +2,10 @@
import warnings
+from django.conf import settings
from django.core.exceptions import ImproperlyConfigured, DjangoRuntimeWarning
from django.utils.encoding import smart_str
+from django.utils.importlib import import_module
class InvalidCacheBackendError(ImproperlyConfigured):
pass
@@ -15,38 +17,55 @@ class CacheKeyWarning(DjangoRuntimeWarning):
MEMCACHE_MAX_KEY_LENGTH = 250
def default_key_func(key, key_prefix, version):
- """Default function to generate keys.
+ """
+ Default function to generate keys.
Constructs the key used by all other methods. By default it prepends
- the `key_prefix'. CACHE_KEY_FUNCTION can be used to specify an alternate
+ the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
function with custom key making behavior.
"""
return ':'.join([key_prefix, str(version), smart_str(key)])
+def get_key_func(key_func):
+ """
+ Function to decide which key function to use.
+
+ Defaults to ``default_key_func``.
+ """
+ if key_func is not None:
+ if callable(key_func):
+ return key_func
+ else:
+ key_func_module_path, key_func_name = key_func.rsplit('.', 1)
+ key_func_module = import_module(key_func_module_path)
+ return getattr(key_func_module, key_func_name)
+ return default_key_func
+
class BaseCache(object):
- def __init__(self, params, key_prefix='', version=1, key_func=None):
- timeout = params.get('timeout', 300)
+ def __init__(self, params):
+ timeout = params.get('timeout', params.get('TIMEOUT', 300))
try:
timeout = int(timeout)
except (ValueError, TypeError):
timeout = 300
self.default_timeout = timeout
- max_entries = params.get('max_entries', 300)
+ options = params.get('OPTIONS', {})
+ max_entries = params.get('max_entries', options.get('MAX_ENTRIES', 300))
try:
self._max_entries = int(max_entries)
except (ValueError, TypeError):
self._max_entries = 300
- cull_frequency = params.get('cull_frequency', 3)
+ cull_frequency = params.get('cull_frequency', options.get('CULL_FREQUENCY', 3))
try:
self._cull_frequency = int(cull_frequency)
except (ValueError, TypeError):
self._cull_frequency = 3
- self.key_prefix = smart_str(key_prefix)
- self.version = version
- self.key_func = key_func or default_key_func
+ self.key_prefix = smart_str(params.get('KEY_PREFIX', ''))
+ self.version = params.get('VERSION', 1)
+ self.key_func = get_key_func(params.get('KEY_FUNCTION', None))
def make_key(self, key, version=None):
"""Constructs the key used by all other methods. By default it
View
12 django/core/cache/backends/db.py
@@ -25,16 +25,16 @@ def __init__(self, table):
self.managed = True
self.proxy = False
-class BaseDatabaseCacheClass(BaseCache):
- def __init__(self, table, params, key_prefix='', version=1, key_func=None):
- BaseCache.__init__(self, params, key_prefix, version, key_func)
+class BaseDatabaseCache(BaseCache):
+ def __init__(self, table, params):
+ BaseCache.__init__(self, params)
self._table = table
class CacheEntry(object):
_meta = Options(table)
self.cache_model_class = CacheEntry
-class CacheClass(BaseDatabaseCacheClass):
+class DatabaseCache(BaseDatabaseCache):
def get(self, key, default=None, version=None):
key = self.make_key(key, version=version)
self.validate_key(key)
@@ -140,3 +140,7 @@ def clear(self):
table = connections[db].ops.quote_name(self._table)
cursor = connections[db].cursor()
cursor.execute('DELETE FROM %s' % table)
+
+# For backwards compatibility
+class CacheClass(DatabaseCache):
+ pass
View
6 django/core/cache/backends/dummy.py
@@ -2,7 +2,7 @@
from django.core.cache.backends.base import BaseCache
-class CacheClass(BaseCache):
+class DummyCache(BaseCache):
def __init__(self, host, *args, **kwargs):
BaseCache.__init__(self, *args, **kwargs)
@@ -40,3 +40,7 @@ def delete_many(self, keys, version=None):
def clear(self):
pass
+
+# For backwards compatibility
+class CacheClass(DummyCache):
+ pass
View
10 django/core/cache/backends/filebased.py
@@ -11,9 +11,9 @@
from django.core.cache.backends.base import BaseCache
from django.utils.hashcompat import md5_constructor
-class CacheClass(BaseCache):
- def __init__(self, dir, params, key_prefix='', version=1, key_func=None):
- BaseCache.__init__(self, params, key_prefix, version, key_func)
+class FileBasedCache(BaseCache):
+ def __init__(self, dir, params):
+ BaseCache.__init__(self, params)
self._dir = dir
if not os.path.exists(self._dir):
self._createdir()
@@ -161,3 +161,7 @@ def clear(self):
shutil.rmtree(self._dir)
except (IOError, OSError):
pass
+
+# For backwards compatibility
+class CacheClass(FileBasedCache):
+ pass
View
23 django/core/cache/backends/locmem.py
@@ -9,12 +9,19 @@
from django.core.cache.backends.base import BaseCache
from django.utils.synch import RWLock
-class CacheClass(BaseCache):
- def __init__(self, _, params, key_prefix='', version=1, key_func=None):
- BaseCache.__init__(self, params, key_prefix, version, key_func)
- self._cache = {}
- self._expire_info = {}
- self._lock = RWLock()
+# Global in-memory store of cache data. Keyed by name, to provide
+# multiple named local memory caches.
+_caches = {}
+_expire_info = {}
+_locks = {}
+
+class LocMemCache(BaseCache):
+ def __init__(self, name, params):
+ BaseCache.__init__(self, params)
+ global _caches, _expire_info, _locks
+ self._cache = _caches.setdefault(name, {})
+ self._expire_info = _expire_info.setdefault(name, {})
+ self._lock = _locks.setdefault(name, RWLock())
def add(self, key, value, timeout=None, version=None):
key = self.make_key(key, version=version)
@@ -133,3 +140,7 @@ def delete(self, key, version=None):
def clear(self):
self._cache.clear()
self._expire_info.clear()
+
+# For backwards compatibility
+class CacheClass(LocMemCache):
+ pass
View
117 django/core/cache/backends/memcached.py
@@ -1,26 +1,34 @@
"Memcached cache backend"
import time
+from threading import local
from django.core.cache.backends.base import BaseCache, InvalidCacheBackendError
-
-try:
- import cmemcache as memcache
- import warnings
- warnings.warn(
- "Support for the 'cmemcache' library has been deprecated. Please use python-memcached instead.",
- DeprecationWarning
- )
-except ImportError:
- try:
- import memcache
- except:
- raise InvalidCacheBackendError("Memcached cache backend requires either the 'memcache' or 'cmemcache' library")
-
-class CacheClass(BaseCache):
- def __init__(self, server, params, key_prefix='', version=1, key_func=None):
- BaseCache.__init__(self, params, key_prefix, version, key_func)
- self._cache = memcache.Client(server.split(';'))
+from django.utils import importlib
+
+class BaseMemcachedCache(BaseCache):
+ def __init__(self, server, params, library, value_not_found_exception):
+ super(BaseMemcachedCache, self).__init__(params)
+ if isinstance(server, basestring):
+ self._servers = server.split(';')
+ else:
+ self._servers = server
+
+ # The exception type to catch from the underlying library for a key
+ # that was not found. This is a ValueError for python-memcache,
+ # pylibmc.NotFound for pylibmc, and cmemcache will return None without
+ # raising an exception.
+ self.LibraryValueNotFoundException = value_not_found_exception
+
+ self._lib = library
+ self._options = params.get('OPTIONS', None)
+
+ @property
+ def _cache(self):
+ """
+ Implements transparent thread-safe access to a memcached client.
+ """
+ return self._lib.Client(self._servers)
def _get_memcache_timeout(self, timeout):
"""
@@ -79,13 +87,13 @@ def incr(self, key, delta=1, version=None):
val = self._cache.incr(key, delta)
# python-memcache responds to incr on non-existent keys by
- # raising a ValueError. Cmemcache returns None. In both
- # cases, we should raise a ValueError though.
- except ValueError:
+ # raising a ValueError, pylibmc by raising a pylibmc.NotFound
+ # and Cmemcache returns None. In all cases,
+ # we should raise a ValueError though.
+ except self.LibraryValueNotFoundException:
val = None
if val is None:
raise ValueError("Key '%s' not found" % key)
-
return val
def decr(self, key, delta=1, version=None):
@@ -93,10 +101,11 @@ def decr(self, key, delta=1, version=None):
try:
val = self._cache.decr(key, delta)
- # python-memcache responds to decr on non-existent keys by
- # raising a ValueError. Cmemcache returns None. In both
- # cases, we should raise a ValueError though.
- except ValueError:
+ # python-memcache responds to incr on non-existent keys by
+ # raising a ValueError, pylibmc by raising a pylibmc.NotFound
+ # and Cmemcache returns None. In all cases,
+ # we should raise a ValueError though.
+ except self.LibraryValueNotFoundException:
val = None
if val is None:
raise ValueError("Key '%s' not found" % key)
@@ -117,3 +126,59 @@ def delete_many(self, keys, version=None):
def clear(self):
self._cache.flush_all()
+
+# For backwards compatibility -- the default cache class tries a
+# cascading lookup of cmemcache, then memcache.
+class CacheClass(BaseMemcachedCache):
+ def __init__(self, server, params):
+ try:
+ import cmemcache as memcache
+ import warnings
+ warnings.warn(
+ "Support for the 'cmemcache' library has been deprecated. Please use python-memcached or pyblimc instead.",
+ DeprecationWarning
+ )
+ except ImportError:
+ try:
+ import memcache
+ except:
+ raise InvalidCacheBackendError(
+ "Memcached cache backend requires either the 'memcache' or 'cmemcache' library"
+ )
+ super(CacheClass, self).__init__(server, params,
+ library=memcache,
+ value_not_found_exception=ValueError)
+
+class MemcachedCache(BaseMemcachedCache):
+ "An implementation of a cache binding using python-memcached"
+ def __init__(self, server, params):
+ import memcache
+ super(MemcachedCache, self).__init__(server, params,
+ library=memcache,
+ value_not_found_exception=ValueError)
+
+class PyLibMCCache(BaseMemcachedCache):
+ "An implementation of a cache binding using pylibmc"
+ def __init__(self, server, params):
+ import pylibmc
+ self._local = local()
+ super(PyLibMCCache, self).__init__(server, params,
+ library=pylibmc,
+ value_not_found_exception=pylibmc.NotFound)
+
+ @property
+ def _cache(self):
+ # PylibMC uses cache options as the 'behaviors' attribute.
+ # It also needs to use threadlocals, because some versions of
+ # PylibMC don't play well with the GIL.
+ client = getattr(self._local, 'client', None)
+ if client:
+ return client
+
+ client = self._lib.Client(self._servers)
+ if self._options:
+ client.behaviors = self._options
+
+ self._local.client = client
+
+ return client
View
14 django/db/backends/creation.py
@@ -359,12 +359,14 @@ def create_test_db(self, verbosity=1, autoclobber=False):
# (unless you really ask to be flooded)
call_command('syncdb', verbosity=max(verbosity - 1, 0), interactive=False, database=self.connection.alias)
- if settings.CACHE_BACKEND.startswith('db://'):
- from django.core.cache import parse_backend_uri, cache
- from django.db import router
- if router.allow_syncdb(self.connection.alias, cache.cache_model_class):
- _, cache_name, _ = parse_backend_uri(settings.CACHE_BACKEND)
- call_command('createcachetable', cache_name, database=self.connection.alias)
+ from django.core.cache import get_cache
+ from django.core.cache.backends.db import BaseDatabaseCache
+ for cache_alias in settings.CACHES:
+ cache = get_cache(cache_alias)
+ if isinstance(cache, BaseDatabaseCache):
+ from django.db import router
+ if router.allow_syncdb(self.connection.alias, cache.cache_model_class):
+ call_command('createcachetable', cache._table, database=self.connection.alias)
# Get a cursor (even though we don't need one yet). This has
# the side effect of initializing the test database.
View
37 django/middleware/cache.py
@@ -49,7 +49,7 @@
"""
from django.conf import settings
-from django.core.cache import cache
+from django.core.cache import get_cache, DEFAULT_CACHE_ALIAS
from django.utils.cache import get_cache_key, learn_cache_key, patch_response_headers, get_max_age
class UpdateCacheMiddleware(object):
@@ -65,6 +65,7 @@ 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 = get_cache(settings.CACHE_MIDDLEWARE_ALIAS)
def process_response(self, request, response):
"""Sets the cache, if needed."""
@@ -85,7 +86,7 @@ def process_response(self, request, response):
patch_response_headers(response, timeout)
if timeout:
cache_key = learn_cache_key(request, response, timeout, self.key_prefix)
- cache.set(cache_key, response, timeout)
+ self.cache.set(cache_key, response, timeout)
return response
class FetchFromCacheMiddleware(object):
@@ -100,6 +101,7 @@ 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 = get_cache(settings.CACHE_MIDDLEWARE_ALIAS)
def process_request(self, request):
"""
@@ -124,12 +126,12 @@ def process_request(self, request):
request._cache_update_cache = True
return None # No cache information available, need to rebuild.
- response = cache.get(cache_key, None)
+ 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')
- response = cache.get(cache_key, None)
+ response = self.cache.get(cache_key, None)
if response is None:
request._cache_update_cache = True
@@ -146,14 +148,33 @@ class CacheMiddleware(UpdateCacheMiddleware, FetchFromCacheMiddleware):
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, key_prefix=None, cache_anonymous_only=None):
+ def __init__(self, cache_timeout=None, cache_anonymous_only=None, **kwargs):
self.cache_timeout = cache_timeout
if cache_timeout is None:
self.cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS
- self.key_prefix = key_prefix
- if key_prefix is None:
- self.key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
+
+ # 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.
+ try:
+ cache_alias = kwargs.get('cache_alias')
+ if cache_alias is None:
+ cache_alias = DEFAULT_CACHE_ALIAS
+ except KeyError:
+ cache_alias = settings.CACHE_MIDDLEWARE_ALIAS
+
+ cache_kwargs = {}
+ try:
+ key_prefix = kwargs.get('key_prefix')
+ if key_prefix is not None:
+ cache_kwargs['KEY_PREFIX'] = key_prefix
+ except KeyError:
+ cache_kwargs['KEY_PREFIX'] = settings.CACHE_MIDDLEWARE_KEY_PREFIX
+
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
+
+ self.cache = get_cache(cache_alias, **cache_kwargs)
View
13 django/views/decorators/cache.py
@@ -40,23 +40,24 @@ def cache_page(*args, **kwargs):
# We also add some asserts to give better error messages in case people are
# using other ways to call cache_page that no longer work.
+ cache_alias = kwargs.pop('cache', None)
key_prefix = kwargs.pop('key_prefix', None)
- assert not kwargs, "The only keyword argument accepted is key_prefix"
+ assert not kwargs, "The only keyword arguments are cache and key_prefix"
if len(args) > 1:
assert len(args) == 2, "cache_page accepts at most 2 arguments"
if callable(args[0]):
- return decorator_from_middleware_with_args(CacheMiddleware)(cache_timeout=args[1], key_prefix=key_prefix)(args[0])
+ return decorator_from_middleware_with_args(CacheMiddleware)(cache_timeout=args[1], cache_alias=cache_alias, key_prefix=key_prefix)(args[0])
elif callable(args[1]):
- return decorator_from_middleware_with_args(CacheMiddleware)(cache_timeout=args[0], key_prefix=key_prefix)(args[1])
+ return decorator_from_middleware_with_args(CacheMiddleware)(cache_timeout=args[0], cache_alias=cache_alias, key_prefix=key_prefix)(args[1])
else:
assert False, "cache_page must be passed a view function if called with two arguments"
elif len(args) == 1:
if callable(args[0]):
- return decorator_from_middleware_with_args(CacheMiddleware)(key_prefix=key_prefix)(args[0])
+ return decorator_from_middleware_with_args(CacheMiddleware)(cache_alias=cache_alias, key_prefix=key_prefix)(args[0])
else:
- return decorator_from_middleware_with_args(CacheMiddleware)(cache_timeout=args[0], key_prefix=key_prefix)
+ return decorator_from_middleware_with_args(CacheMiddleware)(cache_timeout=args[0], cache_alias=cache_alias, key_prefix=key_prefix)
else:
- return decorator_from_middleware_with_args(CacheMiddleware)(key_prefix=key_prefix)
+ return decorator_from_middleware_with_args(CacheMiddleware)(cache_alias=cache_alias, key_prefix=key_prefix)
def cache_control(**kwargs):
View
2  docs/internals/contributing.txt
@@ -940,7 +940,7 @@ dependencies:
* gettext_ (:ref:`gettext_on_windows`)
If you want to test the memcached cache backend, you will also need to define
-a :setting:`CACHE_BACKEND` setting that points at your memcached instance.
+a :setting:`CACHES` setting that points at your memcached instance.
Each of these dependencies is optional. If you're missing any of them, the
associated tests will be skipped.
View
150 docs/ref/settings.txt
@@ -127,21 +127,63 @@ Default: Not defined
The site-specific user profile model used by this site. See
:ref:`auth-profiles`.
-.. setting:: CACHE_BACKEND
+.. setting:: CACHES
-CACHE_BACKEND
--------------
+CACHES
+------
-Default: ``'locmem://'``
+.. versionadded:: 1.3
-The cache backend to use. See :doc:`/topics/cache`.
+Default::
-.. setting:: CACHE_KEY_FUNCTION
+ {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
+ }
+ }
-CACHE_KEY_FUNCTION
-------------------
+A dictionary containing the settings for all caches to be used with
+Django. It is a nested dictionary whose contents maps cache aliases
+to a dictionary containing the options for an individual cache.
-Default: ``None``
+The :setting:`CACHES` setting must configure a ``default`` cache;
+any number of additional caches may also be specified. If you
+are using a cache backend other than the local memory cache, or
+you need to define multiple caches, other options will be required.
+The following cache options are available.
+
+.. setting:: CACHES-BACKEND
+
+BACKEND
+~~~~~~~
+
+Default: ``''`` (Empty string)
+
+The cache backend to use. The built-in cache backends are:
+
+ * ``'django.core.cache.backends.db.DatabaseCache'``
+ * ``'django.core.cache.backends.dummy.DummyCache'``
+ * ``'django.core.cache.backends.filebased.FileBasedCache'``
+ * ``'django.core.cache.backends.locmem.LocMemCache'``
+ * ``'django.core.cache.backends.memcached.MemcachedCache'``
+ * ``'django.core.cache.backends.memcached.PyLibMCCache'``
+
+You can use a cache backend that doesn't ship with Django by setting
+:setting:`BACKEND <CACHE-BACKEND>` to a fully-qualified path of a cache
+backend class (i.e. ``mypackage.backends.whatever.WhateverCache``).
+Writing a whole new cache backend from scratch is left as an exercise
+to the reader; see the other backends for examples.
+
+.. note::
+ Prior to Django 1.3, you could use a URI based version of the backend
+ name to reference the built-in cache backends (e.g., you could use
+ ``'db://tablename'`` to refer to the database backend). This format has
+ been deprecated, and will be removed in Django 1.5.
+
+.. setting:: CACHES-KEY_FUNCTION
+
+KEY_FUNCTION
+~~~~~~~~~~~~
A string containing a dotted path to a function that defines how to
compose a prefix, version and key into a final cache key. The default
@@ -155,10 +197,10 @@ argument signature.
See the :ref:`cache documentation <cache_key_transformation>` for more information.
-.. setting:: CACHE_KEY_PREFIX
+.. setting:: CACHES-KEY_PREFIX
-CACHE_KEY_PREFIX
-----------------
+KEY_PREFIX
+~~~~~~~~~~
Default: ``''`` (Empty string)
@@ -167,6 +209,67 @@ all cache keys used by the Django server.
See the :ref:`cache documentation <cache_key_prefixing>` for more information.
+.. setting:: CACHES-LOCATION
+
+LOCATION
+~~~~~~~~
+
+Default: ``''`` (Empty string)
+
+The location of the cache to use. This might be the directory for a
+file system cache, a host and port for a memcache server, or simply an
+identifying name for a local memory cache. e.g.::
+
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
+ 'LOCATION': '/var/tmp/django_cache',
+ }
+ }
+
+.. setting:: CACHES-OPTIONS
+
+OPTIONS
+~~~~~~~
+
+Default: None
+
+Extra parameters to pass to the cache backend. Available parameters
+vary depending on your cache backend.
+
+Some information on available parameters can be found in the
+:doc:`Cache Backends </topics/cache>` documentation. For more information,
+consult your backend module's own documentation.
+
+.. setting:: CACHES-TIMEOUT
+
+TIMEOUT
+~~~~~~~
+
+Default: 300
+
+The number of seconds before a cache entry is considered stale.
+
+.. setting:: CACHES-VERSION
+
+VERSION
+~~~~~~~
+
+Default: ``1``
+
+The default version number for cache keys generated by the Django server.
+
+See the :ref:`cache documentation <cache_versioning>` for more information.
+
+.. setting:: CACHE_MIDDLEWARE_ALIAS
+
+CACHE_MIDDLEWARE_ALIAS
+----------------------
+
+Default: ``default``
+
+The cache connection to use for the cache middleware.
+
.. setting:: CACHE_MIDDLEWARE_ANONYMOUS_ONLY
CACHE_MIDDLEWARE_ANONYMOUS_ONLY
@@ -206,18 +309,6 @@ The default number of seconds to cache a page when the caching middleware or
See :doc:`/topics/cache`.
-.. setting:: CACHE_VERSION
-
-CACHE_VERSION
--------------
-
-Default: ``1``
-
-The default version number for cache keys generated by the Django server.
-
-See the :ref:`cache documentation <cache_versioning>` for more information.
-
-
.. setting:: CSRF_COOKIE_DOMAIN
CSRF_COOKIE_DOMAIN
@@ -293,7 +384,7 @@ SQLite. This can be configured using the following::
For other database backends, or more complex SQLite configurations, other options
will be required. The following inner options are available.
-.. setting:: ENGINE
+.. setting:: DATABASE-ENGINE
ENGINE
~~~~~~
@@ -1896,6 +1987,15 @@ See :tfilter:`allowed date format strings <date>`. See also ``DATE_FORMAT``,
Deprecated settings
===================
+.. setting:: CACHE_BACKEND
+
+CACHE_BACKEND
+-------------
+
+.. deprecated:: 1.3
+ This setting has been replaced by :setting:`BACKEND <CACHES-BACKEND>` in
+ :setting:`CACHES`.
+
.. setting:: DATABASE_ENGINE
DATABASE_ENGINE
View
27 docs/releases/1.3.txt
@@ -154,6 +154,29 @@ it is needed, later in the response process.
For more details, see the :ref:`documentation </ref/template-response>`
on the :class:`~django.template.TemplateResponse` class.
+Caching changes
+~~~~~~~~~~~~~~~
+
+Django 1.3 sees the introduction of several improvements to the
+Django's caching infrastructure.
+
+Firstly, Django now supports multiple named caches. In the same way
+that Django 1.2 introduced support for multiple database connections,
+Django 1.3 allows you to use the new :setting:`CACHES` setting to
+define multiple named cache connections.
+
+Secondly, :ref:`Versioning <cache_versioning>`, :ref:`site-wide
+prefixing <cache_key_prefixing>` and :ref:`transformation
+<cache_key_transformation>` has been added to the cache API.
+
+Lastly, support for pylibmc_ has been added to the memcached cache
+backend.
+
+For more details, see the :ref:`documentation on
+caching in Django<topics/cache>`.
+
+.. _pylibmc: http://sendapatch.se/projects/pylibmc/
+
Everything else
~~~~~~~~~~~~~~~
@@ -176,10 +199,6 @@ requests. These include:
:meth:`~django.test.client.Client.assertNumQueries` -- making it
easier to test the database activity associated with a view.
- * :ref:`Versioning <cache_versioning>`, :ref:`site-wide prefixing
- <cache_key_prefixing>` and :ref:`transformation
- <cache_key_transformation>` has been added to the cache API.
-
* Support for lookups spanning relations in admin's ``list_filter``.
* Support for _HTTPOnly cookies.
View
285 docs/topics/cache.txt
@@ -47,9 +47,16 @@ where your cached data should live -- whether in a database, on the filesystem
or directly in memory. This is an important decision that affects your cache's
performance; yes, some cache types are faster than others.
-Your cache preference goes in the :setting:`CACHE_BACKEND` setting in your
+Your cache preference goes in the :setting:`CACHES` setting in your
settings file. Here's an explanation of all available values for
-:setting:`CACHE_BACKEND`.
+:setting:`CACHES`.
+
+.. versionchanged:: 1.3
+ The settings used to configure caching changed in Django 1.3. In
+ Django 1.2 and earlier, you used a single string-based
+ :setting:`CACHE_BACKEND` setting to configure caches. This has
+ been replaced with the new dictionary-based :setting:`CACHES`
+ setting.
Memcached
---------
@@ -66,9 +73,12 @@ fast interface for adding, retrieving and deleting arbitrary data in the cache.
All data is stored directly in memory, so there's no overhead of database or
filesystem usage.
-After installing Memcached itself, you'll need to install
-``python-memcached``, which provides Python bindings to Memcached.
-This is available at ftp://ftp.tummy.com/pub/python-memcached/
+After installing Memcached itself, you'll need to install a memcached
+binding. There are several python memcached bindings available; the
+two most common are `python-memcached`_ and `pylibmc`_.
+
+.. _`python-memcached`: ftp://ftp.tummy.com/pub/python-memcached/
+.. _`pylibmc`: http://sendapatch.se/projects/pylibmc/
.. versionchanged:: 1.2
In Django 1.0 and 1.1, you could also use ``cmemcache`` as a binding.
@@ -76,31 +86,64 @@ This is available at ftp://ftp.tummy.com/pub/python-memcached/
a lack of maintenance on the ``cmemcache`` library itself. Support for
``cmemcache`` will be removed completely in Django 1.4.
-To use Memcached with Django, set :setting:`CACHE_BACKEND` to
-``memcached://ip:port/``, where ``ip`` is the IP address of the Memcached
-daemon and ``port`` is the port on which Memcached is running.
+.. versionchanged:: 1.3
+ Support for ``pylibmc`` was added.
+
+To use Memcached with Django:
+
+ * Set :setting:`BACKEND <CACHES-BACKEND>` to
+ ``django.core.cache.backends.memcached.MemcachedCache`` or
+ ``django.core.cache.backends.memcached.PyLibMCCache`` (depending
+ on your chosen memcached binding)
+
+ * Set :setting:`LOCATION <CACHES-LOCATION>` to ``ip:port`` values,
+ where ``ip`` is the IP address of the Memcached daemon and
+ ``port`` is the port on which Memcached is running.
-In this example, Memcached is running on localhost (127.0.0.1) port 11211::
+In this example, Memcached is running on localhost (127.0.0.1) port 11211, using
+the ``python-memcached`` binding::
- CACHE_BACKEND = 'memcached://127.0.0.1:11211/'
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
+ 'LOCATION': '127.0.0.1:11211',
+ }
+ }
One excellent feature of Memcached is its ability to share cache over multiple
servers. This means you can run Memcached daemons on multiple machines, and the
program will treat the group of machines as a *single* cache, without the need
to duplicate cache values on each machine. To take advantage of this feature,
-include all server addresses in :setting:`CACHE_BACKEND`, separated by
-semicolons.
+include all server addresses in :setting:`BACKEND <CACHES-BACKEND>`, either
+separated by semicolons or as a list.
In this example, the cache is shared over Memcached instances running on IP
address 172.19.26.240 and 172.19.26.242, both on port 11211::
- CACHE_BACKEND = 'memcached://172.19.26.240:11211;172.19.26.242:11211/'
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
+ 'LOCATION': [
+ '172.19.26.240:11211',
+ '172.19.26.242:11211',
+ ]
+ }
+ }
In the following example, the cache is shared over Memcached instances running
on the IP addresses 172.19.26.240 (port 11211), 172.19.26.242 (port 11212), and
172.19.26.244 (port 11213)::
- CACHE_BACKEND = 'memcached://172.19.26.240:11211;172.19.26.242:11212;172.19.26.244:11213/'
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
+ 'LOCATION': [
+ '172.19.26.240:11211',
+ '172.19.26.242:11211',
+ '172.19.26.244:11213',
+ ]
+ }
+ }
A final point about Memcached is that memory-based caching has one
disadvantage: Because the cached data is stored in memory, the data will be
@@ -125,12 +168,19 @@ not already being used in your database.) This command creates a single table
in your database that is in the proper format that Django's database-cache
system expects.
-Once you've created that database table, set your :setting:`CACHE_BACKEND`
-setting to ``"db://tablename"``, where ``tablename`` is the name of the
-database table. In this example, the cache table's name is
-``my_cache_table``::
+Once you've created that database table, set your
+:setting:`BACKEND <CACHES-BACKEND>` setting to
+``"django.core.cache.backends.db.DatabaseCache"``, and
+:setting:`LOCATION <CACHES-LOCATION>` to ``tablename`` -- the name of the
+database table. In this example, the cache table's name is ``my_cache_table``::
+
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
+ 'LOCATION': 'my_cache_table',
+ }
+ }
- CACHE_BACKEND = 'db://my_cache_table'
The database caching backend uses the same database as specified in your
settings file. You can't use a different database backend for your cache table.
@@ -183,18 +233,28 @@ model.
Filesystem caching
------------------
-To store cached items on a filesystem, use the ``"file://"`` cache type for
-:setting:`CACHE_BACKEND`. For example, to store cached data in
+To store cached items on a filesystem, use
+``"django.core.cache.backends.filebased.FileBasedCache"`` for
+:setting:`BACKEND <CACHES-BACKEND>`. For example, to store cached data in
``/var/tmp/django_cache``, use this setting::
- CACHE_BACKEND = 'file:///var/tmp/django_cache'
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
+ 'LOCATION': '/var/tmp/django_cache',
+ }
+ }
+
-Note that there are three forward slashes toward the beginning of that example.
-The first two are for ``file://``, and the third is the first character of the
-directory path, ``/var/tmp/django_cache``. If you're on Windows, put the
-drive letter after the ``file://``, like this::
+If you're on Windows, put the drive letter at the beginning of the path,
+like this::
- file://c:/foo/bar
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
+ 'LOCATION': 'c:/foo/bar',
+ }
+ }
The directory path should be absolute -- that is, it should start at the root
of your filesystem. It doesn't matter whether you put a slash at the end of the
@@ -215,10 +275,22 @@ Local-memory caching
If you want the speed advantages of in-memory caching but don't have the
capability of running Memcached, consider the local-memory cache backend. This
-cache is multi-process and thread-safe. To use it, set :setting:`CACHE_BACKEND`
-to ``"locmem://"``. For example::
-
- CACHE_BACKEND = 'locmem://'
+cache is multi-process and thread-safe. To use it, set
+:setting:`BACKEND <CACHES-BACKEND>` to
+``"django.core.cache.backends.locmem.LocMemCache"``. For example::
+
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
+ 'LOCATION': 'unique-snowflake'
+ }
+ }
+
+The cache :setting:`LOCATION <CACHES-LOCATION>` is used to identify individual
+memory stores. If you only have one locmem cache, you can omit the
+:setting:`LOCATION <CACHES-LOCATION>`; however, if you have more that one local
+memory cache, you will need to assign a name to at least one of them in
+order to keep them separate.
Note that each process will have its own private cache instance, which means no
cross-process caching is possible. This obviously also means the local memory
@@ -234,9 +306,13 @@ just implements the cache interface without doing anything.
This is useful if you have a production site that uses heavy-duty caching in
various places but a development/test environment where you don't want to cache
and don't want to have to change your code to special-case the latter. To
-activate dummy caching, set :setting:`CACHE_BACKEND` like so::
+activate dummy caching, set :setting:`BACKEND <CACHES-BACKEND>` like so::
- CACHE_BACKEND = 'dummy://'
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
+ }
+ }
Using a custom cache backend
----------------------------
@@ -245,10 +321,14 @@ Using a custom cache backend
While Django includes support for a number of cache backends out-of-the-box,
sometimes you might want to use a customized cache backend. To use an external
-cache backend with Django, use a Python import path as the scheme portion (the
-part before the initial colon) of the :setting:`CACHE_BACKEND` URI, like so::
+cache backend with Django, use the Python import path as the
+:setting:`BACKEND <CACHES-BACKEND>` of the :setting:`CACHES` setting, like so::
- CACHE_BACKEND = 'path.to.backend://'
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'path.to.backend',
+ }
+ }
If you're building your own backend, you can use the standard cache backends
as reference implementations. You'll find the code in the
@@ -258,35 +338,77 @@ Note: Without a really compelling reason, such as a host that doesn't support
them, you should stick to the cache backends included with Django. They've
been well-tested and are easy to use.
-CACHE_BACKEND arguments
------------------------
+Cache arguments
+---------------
+
+In addition to the defining the engine and name of the each cache
+backend, each cache backend can be given additional arguments to
+control caching behavior. These arguments are provided as additional
+keys in the :setting:`CACHES` setting. Valid arguments are as follows:
+
+ * :setting:`TIMEOUT <CACHES-TIMEOUT>`: The default timeout, in
+ seconds, to use for the cache. This argument defaults to 300
+ seconds (5 minutes).
-Each cache backend may take arguments. They're given in query-string style on
-the :setting:`CACHE_BACKEND` setting. Valid arguments are as follows:
+ * :setting:`OPTIONS <CACHES-OPTIONS>`: Any options that should be
+ passed to cache backend. The list options understood by each
+ backend vary with each backend.
- * ``timeout``: The default timeout, in seconds, to use for the cache.
- This argument defaults to 300 seconds (5 minutes).
+ Cache backends that implement their own culling strategy (i.e.,
+ the ``locmem``, ``filesystem`` and ``database`` backends) will
+ honor the following options:
- * ``max_entries``: For the ``locmem``, ``filesystem`` and ``database``
- backends, the maximum number of entries allowed in the cache before old
- values are deleted. This argument defaults to 300.
+ * ``MAX_ENTRIES``: the maximum number of entries allowed in
+ the cache before old values are deleted. This argument
+ defaults to ``300``.
- * ``cull_frequency``: The fraction of entries that are culled when
- ``max_entries`` is reached. The actual ratio is ``1/cull_frequency``, so
- set ``cull_frequency=2`` to cull half of the entries when ``max_entries``
- is reached.
+ * ``CULL_FREQUENCY``: The fraction of entries that are culled
+ when ``MAX_ENTRIES`` is reached. The actual ratio is
+ ``1/CULL_FREQUENCY``, so set ``CULL_FREQUENCY``: to ``2`` to
+ cull half of the entries when ``MAX_ENTRIES`` is reached.
- A value of ``0`` for ``cull_frequency`` means that the entire cache will
- be dumped when ``max_entries`` is reached. This makes culling *much*
- faster at the expense of more cache misses.
+ A value of ``0`` for ``CULL_FREQUENCY`` means that the
+ entire cache will be dumped when ``MAX_ENTRIES`` is reached.
+ This makes culling *much* faster at the expense of more
+ cache misses.
-In this example, ``timeout`` is set to ``60``::
+ Cache backends backed by a third-party library will pass their
+ options directly to the underlying cache library. As a result,
+ the list of valid options depends on the library in use.
- CACHE_BACKEND = "memcached://127.0.0.1:11211/?timeout=60"
+ * :setting:`KEY_PREFIX <CACHES-KEY_PREFIX>`: A string that will be
+ automatically included (prepended by default) to all cache keys
+ used by the Django server.
-In this example, ``timeout`` is ``30`` and ``max_entries`` is ``400``::
+ See the :ref:`cache documentation <cache_key_prefixing>` for
+ more information.
- CACHE_BACKEND = "locmem://?timeout=30&max_entries=400"
+ * :setting:`VERSION <CACHES-VERSION>`: The default version number
+ for cache keys generated by the Django server.
+
+ See the :ref:`cache documentation <cache_versioning>` for more
+ information.
+
+ * :setting:`KEY_FUNCTION <CACHES-KEY_FUNCTION>`
+ A string containing a dotted path to a function that defines how
+ to compose a prefix, version and key into a final cache key.
+
+ See the :ref:`cache documentation <cache_key_transformation>`
+ for more information.
+
+In this example, a filesystem backend is being configured with a timeout
+of 60 seconds, and a maximum capacity of 1000 items::
+
+ CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.filebased.FileCache',
+ 'LOCATION': '127.0.0.1:11211',
+ 'TIMEOUT': 60,
+ 'OPTIONS': {
+ 'MAX_ENTRIES': 1000
+ }
+ }
+ }
Invalid arguments are silently ignored, as are invalid values of known
arguments.
@@ -318,6 +440,7 @@ entire site. You'll need to add
Then, add the following required settings to your Django settings file:
+* :setting:`CACHE_MIDDLEWARE_ALIAS` -- The cache alias to use for storage.
* :setting:`CACHE_MIDDLEWARE_SECONDS` -- The number of seconds each page should
be cached.
* :setting:`CACHE_MIDDLEWARE_KEY_PREFIX` -- If the cache is shared across
@@ -408,7 +531,17 @@ then requests to ``/foo/1/`` and ``/foo/23/`` will be cached separately, as
you may expect. But once a particular URL (e.g., ``/foo/23/``) has been
requested, subsequent requests to that URL will use the cache.
-``cache_page`` can also take an optional keyword argument, ``key_prefix``,
+``cache_page`` can also take an optional keyword argument, ``cache``,
+which directs the decorator to use a specific cache alias when caching view
+results. By default, the ``default`` alias will be used, but you can specify
+any cache alias you want::
+
+ @cache_page(60 * 15, cache="special_cache")
+ def my_view(request):
+ ...
+
+You can also override the cache prefix on a per-view basis. ``cache_page``
+takes an optional keyword argument, ``key_prefix``,
which works in the same way as the :setting:`CACHE_MIDDLEWARE_KEY_PREFIX`
setting for the middleware. It can be used like this::
@@ -416,6 +549,10 @@ setting for the middleware. It can be used like this::
def my_view(request):
...
+The two settings can also be combined. If you specify a ``cache`` *and*
+a ``key_prefix``, you will get all the settings of the requested cache
+alias, but with the key_prefix overridden.
+
Specifying per-view cache in the URLconf
----------------------------------------
@@ -535,7 +672,8 @@ can be pickled; refer to the Python documentation for more information about
pickling.)
The cache module, ``django.core.cache``, has a ``cache`` object that's
-automatically created from the :setting:`CACHE_BACKEND` setting::
+automatically created from the ``'default'`` entry in the :setting:`CACHES`
+setting::
>>> from django.core.cache import cache
@@ -546,8 +684,9 @@ The basic interface is ``set(key, value, timeout)`` and ``get(key)``::
'hello, world!'
The ``timeout`` argument is optional and defaults to the ``timeout``
-argument in the :setting:`CACHE_BACKEND` setting (explained above). It's the
-number of seconds the value should be stored in the cache.
+argument of the ``'default'`` backend in :setting:`CACHES` setting
+(explained above). It's the number of seconds the value should be stored
+in the cache.
If the object doesn't exist in the cache, ``cache.get()`` returns ``None``::
@@ -665,10 +804,10 @@ diagnose problems.
To prevent this, Django provides the ability to prefix all cache keys
used by a server. When a particular cache key is saved or retrieved,
Django will automatically prefix the cache key with the value of the
-:setting:`CACHE_KEY_PREFIX` setting.
+:setting:`KEY_PREFIX <CACHES-KEY_PREFIX>` cache setting.
By ensuring each Django instance has a different
-:setting:`CACHE_KEY_PREFIX`, you can ensure that there will be no
+:setting:`KEY_PREFIX <CACHES-KEY_PREFIX>`, you can ensure that there will be no
collisions in cache values.
.. _cache_versioning:
@@ -685,9 +824,9 @@ that are still valid and useful.
Django provides a better way to target individual cache values.
Django's cache framework has a system-wide version identifier,
-specified using the :setting:`CACHE_VERSION` setting. The value of
-this setting is automatically combined with the cache prefix and the
-user-provided cache key to obtain the final cache key.
+specified using the :setting:`VERSION <CACHES-VERSION>` cache setting.
+The value of this setting is automatically combined with the cache
+prefix and the user-provided cache key to obtain the final cache key.
By default, any key request will automatically include the site
default cache key version. However, the primitive cache functions all
@@ -739,10 +878,10 @@ If you want to combine the parts in different ways, or apply other
processing to the final key (e.g., taking a hash digest of the key
parts), you can provide a custom key function.
-The setting :setting:`CACHE_KEY_FUNCTION` specifies a dotted-path to
-a function matching the prototype of :func:`make_key()` above. If
-provided, this custom key function will be used instead of the default
-key combining function.
+The :setting:`KEY_FUNCTION <CACHES-KEY_FUNCTION>` cache setting
+specifies a dotted-path to a function matching the prototype of
+:func:`make_key()` above. If provided, this custom key function will
+be used instead of the default key combining function.
Cache key warnings
------------------
@@ -773,15 +912,15 @@ built-in backends, you can subclass it, override just the ``validate_key``
method, and follow the instructions for `using a custom cache backend`_. For
instance, to do this for the ``locmem`` backend, put this code in a module::
- from django.core.cache.backends.locmem import CacheClass as LocMemCacheClass
+ from django.core.cache.backends.locmem import LocMemCache
- class CacheClass(LocMemCacheClass):
+ class CustomLocMemCache(LocMemCache):
def validate_key(self, key):
"""Custom validation, raising exceptions or warnings as needed."""
# ...
-...and use the dotted Python path to this module as the scheme portion of your
-:setting:`CACHE_BACKEND`.
+...and use the dotted Python path to this class in the
+:setting:`BACKEND <CACHES-BACKEND>` portion of your :setting:`CACHES` setting.
Upstream caches
===============
View
4 tests/regressiontests/cache/liberal_backend.py
@@ -1,9 +1,9 @@
-from django.core.cache.backends.locmem import CacheClass as LocMemCacheClass
+from django.core.cache.backends.locmem import LocMemCache
class LiberalKeyValidationMixin(object):
def validate_key(self, key):
pass
-class CacheClass(LiberalKeyValidationMixin, LocMemCacheClass):
+class CacheClass(LiberalKeyValidationMixin, LocMemCache):
pass
View
107 tests/regressiontests/cache/tests.py
@@ -11,7 +11,7 @@
from django.conf import settings
from django.core import management
-from django.core.cache import get_cache
+from django.core.cache import get_cache, DEFAULT_CACHE_ALIAS
from django.core.cache.backends.base import InvalidCacheBackendError, CacheKeyWarning
from django.http import HttpResponse, HttpRequest
from django.middleware.cache import FetchFromCacheMiddleware, UpdateCacheMiddleware
@@ -33,7 +33,7 @@ class DummyCacheTests(unittest.TestCase):
# The Dummy cache backend doesn't really behave like a test backend,
# so it has different test requirements.
def setUp(self):
- self.cache = get_cache('dummy://')
+ self.cache = get_cache('django.core.cache.backends.dummy.DummyCache')
def test_simple(self):
"Dummy cache backend ignores cache set calls"
@@ -429,9 +429,6 @@ def test_cache_versioning_get_set(self):
self.assertEqual(self.cache.get('answer1', version=2), None)
self.assertEqual(self.v2_cache.get('answer1'), None)
- # print '---'
- # print 'c1',self.cache._cache
- # print 'v2',self.v2_cache._cache
self.assertEqual(self.v2_cache.get('answer1', version=1), 42)
self.assertEqual(self.v2_cache.get('answer1', version=2), None)
@@ -704,11 +701,11 @@ def setUp(self):
# Spaces are used in the table name to ensure quoting/escaping is working
self._table_name = 'test cache table'
management.call_command('createcachetable', self._table_name, verbosity=0, interactive=False)
- self.cache = get_cache('db://%s?max_entries=30' % self._table_name)
- self.prefix_cache = get_cache('db://%s' % self._table_name, key_prefix='cacheprefix')
- self.v2_cache = get_cache('db://%s' % self._table_name, version=2)
- self.custom_key_cache = get_cache('db://%s' % self._table_name, key_func=custom_key_func)
- self.custom_key_cache2 = get_cache('db://%s' % self._table_name, key_func='regressiontests.cache.tests.custom_key_func')
+ self.cache = get_cache('django.core.cache.backends.db.DatabaseCache', LOCATION=self._table_name, OPTIONS={'MAX_ENTRIES': 30})
+ self.prefix_cache = get_cache('django.core.cache.backends.db.DatabaseCache', LOCATION=self._table_name, KEY_PREFIX='cacheprefix')
+ self.v2_cache = get_cache('django.core.cache.backends.db.DatabaseCache', LOCATION=self._table_name, VERSION=2)
+ self.custom_key_cache = get_cache('django.core.cache.backends.db.DatabaseCache', LOCATION=self._table_name, KEY_FUNCTION=custom_key_func)
+ self.custom_key_cache2 = get_cache('django.core.cache.backends.db.DatabaseCache', LOCATION=self._table_name, KEY_FUNCTION='regressiontests.cache.tests.custom_key_func')
def tearDown(self):
from django.db import connection
@@ -719,16 +716,20 @@ def test_cull(self):
self.perform_cull_test(50, 29)
def test_zero_cull(self):
+ self.cache = get_cache('django.core.cache.backends.db.DatabaseCache', LOCATION=self._table_name, OPTIONS={'MAX_ENTRIES': 30, 'CULL_FREQUENCY': 0})
+ self.perform_cull_test(50, 18)
+
+ def test_old_initialization(self):
self.cache = get_cache('db://%s?max_entries=30&cull_frequency=0' % self._table_name)
self.perform_cull_test(50, 18)
class LocMemCacheTests(unittest.TestCase, BaseCacheTests):
def setUp(self):
- self.cache = get_cache('locmem://?max_entries=30')
- self.prefix_cache = get_cache('locmem://', key_prefix='cacheprefix')
- self.v2_cache = get_cache('locmem://', version=2)
- self.custom_key_cache = get_cache('locmem://?max_entries=30', key_func=custom_key_func)
- self.custom_key_cache2 = get_cache('locmem://?max_entries=30', key_func='regressiontests.cache.tests.custom_key_func')
+ self.cache = get_cache('django.core.cache.backends.locmem.LocMemCache', OPTIONS={'MAX_ENTRIES': 30})
+ self.prefix_cache = get_cache('django.core.cache.backends.locmem.LocMemCache', KEY_PREFIX='cacheprefix')
+ self.v2_cache = get_cache('django.core.cache.backends.locmem.LocMemCache', VERSION=2)
+ self.custom_key_cache = get_cache('django.core.cache.backends.locmem.LocMemCache', OPTIONS={'MAX_ENTRIES': 30}, KEY_FUNCTION=custom_key_func)
+ self.custom_key_cache2 = get_cache('django.core.cache.backends.locmem.LocMemCache', OPTIONS={'MAX_ENTRIES': 30}, KEY_FUNCTION='regressiontests.cache.tests.custom_key_func')
# LocMem requires a hack to make the other caches
# share a data store with the 'normal' cache.
@@ -744,24 +745,32 @@ def setUp(self):
self.custom_key_cache2._cache = self.cache._cache
self.custom_key_cache2._expire_info = self.cache._expire_info
+ def tearDown(self):
+ self.cache.clear()
+
def test_cull(self):
self.perform_cull_test(50, 29)
def test_zero_cull(self):
+ self.cache = get_cache('django.core.cache.backends.locmem.LocMemCache', OPTIONS={'MAX_ENTRIES': 30, 'CULL_FREQUENCY': 0})
+ self.perform_cull_test(50, 19)
+
+ def test_old_initialization(self):
self.cache = get_cache('locmem://?max_entries=30&cull_frequency=0')
self.perform_cull_test(50, 19)
# memcached backend isn't guaranteed to be available.
# To check the memcached backend, the test settings file will
-# need to contain a CACHE_BACKEND setting that points at
+# need to contain a cache backend setting that points at
# your memcache server.
class MemcachedCacheTests(unittest.TestCase, BaseCacheTests):
def setUp(self):
- self.cache = get_cache(settings.CACHE_BACKEND)
- self.prefix_cache = get_cache(settings.CACHE_BACKEND, key_prefix='cacheprefix')
- self.v2_cache = get_cache(settings.CACHE_BACKEND, version=2)
- self.custom_key_cache = get_cache(settings.CACHE_BACKEND, key_func=custom_key_func)
- self.custom_key_cache2 = get_cache(settings.CACHE_BACKEND, key_func='regressiontests.cache.tests.custom_key_func')
+ name = settings.CACHES[DEFAULT_CACHE_ALIAS]['LOCATION']
+ self.cache = get_cache('django.core.cache.backends.memcached.MemcachedCache', LOCATION=name)
+ self.prefix_cache = get_cache('django.core.cache.backends.memcached.MemcachedCache', LOCATION=name, KEY_PREFIX='cacheprefix')
+ self.v2_cache = get_cache('django.core.cache.backends.memcached.MemcachedCache', LOCATION=name, VERSION=2)
+ self.custom_key_cache = get_cache('django.core.cache.backends.memcached.MemcachedCache', LOCATION=name, KEY_FUNCTION=custom_key_func)
+ self.custom_key_cache2 = get_cache('django.core.cache.backends.memcached.MemcachedCache', LOCATION=name, KEY_FUNCTION='regressiontests.cache.tests.custom_key_func')
def tearDown(self):
self.cache.clear()
@@ -781,7 +790,7 @@ def test_invalid_keys(self):
# memcached limits key length to 250
self.assertRaises(Exception, self.cache.set, 'a' * 251, 'value')
-MemcachedCacheTests = unittest.skipUnless(settings.CACHE_BACKEND.startswith('memcached://'), "memcached not available")(MemcachedCacheTests)
+MemcachedCacheTests = unittest.skipUnless(settings.CACHES[DEFAULT_CACHE_ALIAS]['BACKEND'].startswith('django.core.cache.backends.memcached.'), "memcached not available")(MemcachedCacheTests)
class FileBasedCacheTests(unittest.TestCase, BaseCacheTests):
"""
@@ -789,11 +798,11 @@ class FileBasedCacheTests(unittest.TestCase, BaseCacheTests):
"""
def setUp(self):
self.dirname = tempfile.mkdtemp()
- self.cache = get_cache('file://%s?max_entries=30' % self.dirname)
- self.prefix_cache = get_cache('file://%s' % self.dirname, key_prefix='cacheprefix')
- self.v2_cache = get_cache('file://%s' % self.dirname, version=2)
- self.custom_key_cache = get_cache('file://%s' % self.dirname, key_func=custom_key_func)
- self.custom_key_cache2 = get_cache('file://%s' % self.dirname, key_func='regressiontests.cache.tests.custom_key_func')
+ self.cache = get_cache('django.core.cache.backends.filebased.FileBasedCache', LOCATION=self.dirname, OPTIONS={'MAX_ENTRIES': 30})
+ self.prefix_cache = get_cache('django.core.cache.backends.filebased.FileBasedCache', LOCATION=self.dirname, KEY_PREFIX='cacheprefix')
+ self.v2_cache = get_cache('django.core.cache.backends.filebased.FileBasedCache', LOCATION=self.dirname, VERSION=2)
+ self.custom_key_cache = get_cache('django.core.cache.backends.filebased.FileBasedCache', LOCATION=self.dirname, KEY_FUNCTION=custom_key_func)
+ self.custom_key_cache2 = get_cache('django.core.cache.backends.filebased.FileBasedCache', LOCATION=self.dirname, KEY_FUNCTION='regressiontests.cache.tests.custom_key_func')
def tearDown(self):
self.cache.clear()
@@ -824,6 +833,10 @@ def test_subdirectory_removal(self):
def test_cull(self):
self.perform_cull_test(50, 29)
+ def test_old_initialization(self):
+ self.cache = get_cache('file://%s?max_entries=30' % self.dirname)
+ self.perform_cull_test(50, 29)
+
class CustomCacheKeyValidationTests(unittest.TestCase):
"""
Tests for the ability to mixin a custom ``validate_key`` method to
@@ -911,28 +924,35 @@ def test_learn_cache_key(self):
class PrefixedCacheUtils(CacheUtils):
def setUp(self):
super(PrefixedCacheUtils, self).setUp()
- self.old_cache_key_prefix = settings.CACHE_KEY_PREFIX
- settings.CACHE_KEY_PREFIX = 'cacheprefix'
+ self.old_cache_key_prefix = settings.CACHES['default'].get('KEY_PREFIX', None)
+ settings.CACHES['default']['KEY_PREFIX'] = 'cacheprefix'
def tearDown(self):
super(PrefixedCacheUtils, self).tearDown()
- settings.CACHE_KEY_PREFIX = self.old_cache_key_prefix
+ if self.old_cache_key_prefix is None:
+ del settings.CACHES['default']['KEY_PREFIX']
+ else:
+ settings.CACHES['default']['KEY_PREFIX'] = self.old_cache_key_prefix
class CacheHEADTest(unittest.TestCase):
def setUp(self):
self.orig_cache_middleware_seconds = settings.CACHE_MIDDLEWARE_SECONDS
self.orig_cache_middleware_key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
- self.orig_cache_backend = settings.CACHE_BACKEND
+ self.orig_caches = settings.CACHES
settings.CACHE_MIDDLEWARE_SECONDS = 60
settings.CACHE_MIDDLEWARE_KEY_PREFIX = 'test'
- settings.CACHE_BACKEND = 'locmem:///'
+ settings.CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'
+ }
+ }
self.path = '/cache/test/'
def tearDown(self):
settings.CACHE_MIDDLEWARE_SECONDS = self.orig_cache_middleware_seconds
settings.CACHE_MIDDLEWARE_KEY_PREFIX = self.orig_cache_middleware_key_prefix
- settings.CACHE_BACKEND = self.orig_cache_backend
+ settings.CACHES = self.orig_caches
def _get_request(self, method):
request = HttpRequest()
@@ -981,7 +1001,7 @@ class CacheI18nTest(unittest.TestCase):
def setUp(self):
self.orig_cache_middleware_seconds = settings.CACHE_MIDDLEWARE_SECONDS
self.orig_cache_middleware_key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
- self.orig_cache_backend = settings.CACHE_BACKEND
+ self.orig_caches = settings.CACHES
self.orig_use_i18n = settings.USE_I18N
self.orig_languages = settings.LANGUAGES
settings.LANGUAGES = (
@@ -994,7 +1014,7 @@ def setUp(self):
def tearDown(self):
settings.CACHE_MIDDLEWARE_SECONDS = self.orig_cache_middleware_seconds
settings.CACHE_MIDDLEWARE_KEY_PREFIX = self.orig_cache_middleware_key_prefix
- settings.CACHE_BACKEND = self.orig_cache_backend
+ settings.CACHES = self.orig_caches
settings.USE_I18N = self.orig_use_i18n
settings.LANGUAGES = self.orig_languages
translation.deactivate()
@@ -1046,8 +1066,12 @@ def set_cache(request, lang, msg):
return UpdateCacheMiddleware().process_response(request, response)
settings.CACHE_MIDDLEWARE_SECONDS = 60
- settings.CACHE_MIDDLEWARE_KEY_PREFIX="test"
- settings.CACHE_BACKEND='locmem:///'
+ settings.CACHE_MIDDLEWARE_KEY_PREFIX = "test"
+ settings.CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'
+ }
+ }
settings.USE_ETAGS = True
settings.USE_I18N = True
en_message ="Hello world!"
@@ -1083,12 +1107,15 @@ def set_cache(request, lang, msg):
class PrefixedCacheI18nTest(CacheI18nTest):
def setUp(self):
super(PrefixedCacheI18nTest, self).setUp()
- self.old_cache_key_prefix = settings.CACHE_KEY_PREFIX
- settings.CACHE_KEY_PREFIX = 'cacheprefix'
+ self.old_cache_key_prefix = settings.CACHES['default'].get('KEY_PREFIX', None)
+ settings.CACHES['default']['KEY_PREFIX'] = 'cacheprefix'
def tearDown(self):
super(PrefixedCacheI18nTest, self).tearDown()
- settings.CACHE_KEY_PREFIX = self.old_cache_key_prefix
+ if self.old_cache_key_prefix is not None:
+ del settings.CACHES['default']['KEY_PREFIX']
+ else:
+ settings.CACHES['default']['KEY_PREFIX'] = self.old_cache_key_prefix
if __name__ == '__main__':
unittest.main()
View
4 tests/regressiontests/templates/tests.py
@@ -1453,8 +1453,6 @@ def get_template_tests(self):
'url-asvar03': ('{% load url from future %}{% url "no_such_view" as url %}{{ url }}', {}, ''),
### CACHE TAG ######################################################
- 'cache01': ('{% load cache %}{% cache -1 test %}cache01{% endcache %}', {}, 'cache01'),
- 'cache02': ('{% load cache %}{% cache -1 test %}cache02{% endcache %}', {}, 'cache02'),
'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
@@ -1463,8 +1461,6 @@ def get_template_tests(self):
# Allow first argument to be a variable.
'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),
- 'cache09': ('{% load cache %}{% cache time test foo %}cache09{% endcache %}', {'foo': 3, 'time': -1}, 'cache09'),
- 'cache10': ('{% load cache %}{% cache time test foo %}cache10{% endcache %}', {'foo': 3, 'time': -1}, 'cache10'),
# Raise exception if we don't have at least 2 args, first one integer.
'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
Please sign in to comment.
Something went wrong with that request. Please try again.