Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Fixed #6464 -- Added incr() and decr() operations on cache backends. …

…Atomic on Memcache; implemented as a 2 stage retrieve/update on other backends. Includes refactor of the cache tests to ensure all the backends are actually tested, and a fix to the DB cache backend that was discovered as a result. Thanks to Michael Malone for the original patch.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@10031 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
commit 638dbc3e8320652ba3bd759e0ac1d28590402096 1 parent 1d8e6ea
@freakboy3742 freakboy3742 authored
View
18 django/core/cache/backends/base.py
@@ -65,6 +65,24 @@ def has_key(self, key):
"""
return self.get(key) is not None
+ def incr(self, key, delta=1):
+ """
+ Add delta to value in the cache. If the key does not exist, raise a
+ ValueError exception.
+ """
+ if key not in self:
+ raise ValueError, "Key '%s' not found" % key
+ new_value = self.get(key) + delta
+ self.set(key, new_value)
+ return new_value
+
+ def decr(self, key, delta=1):
+ """
+ Subtract delta from value in the cache. If the key does not exist, raise
+ a ValueError exception.
+ """
+ return self.incr(key, -delta)
+
def __contains__(self, key):
"""
Returns True if the key is in the cache and has not expired.
View
1  django/core/cache/backends/db.py
@@ -64,6 +64,7 @@ def _base_set(self, mode, key, value, timeout=None):
cursor.execute("INSERT INTO %s (cache_key, value, expires) VALUES (%%s, %%s, %%s)" % self._table, [key, encoded, str(exp)])
except DatabaseError:
# To be threadsafe, updates/inserts are allowed to fail silently
+ transaction.rollback()
return False
else:
transaction.commit_unless_managed()
View
5 django/core/cache/backends/memcached.py
@@ -45,3 +45,8 @@ def get_many(self, keys):
def close(self, **kwargs):
self._cache.disconnect_all()
+ def incr(self, key, delta=1):
+ return self._cache.incr(key, delta)
+
+ def decr(self, key, delta=1):
+ return self._cache.decr(key, delta)
View
43 docs/internals/contributing.txt
@@ -184,7 +184,7 @@ Patch style
An exception is for code changes that are described more clearly in plain
English than in code. Indentation is the most common example; it's hard to
read patches when the only difference in code is that it's indented.
-
+
Patches in ``git diff`` format are also acceptable.
* When creating patches, always run ``svn diff`` from the top-level
@@ -402,7 +402,7 @@ translated, here's what to do:
* Join the `Django i18n mailing list`_ and introduce yourself.
- * Create translations using the methods described in the
+ * Create translations using the methods described in the
:ref:`i18n documentation <topics-i18n>`. For this you will use the
``django-admin.py makemessages`` tool. In this particular case it should
be run from the top-level ``django`` directory of the Django source tree.
@@ -697,9 +697,9 @@ repository:
first commit the change to library Y, then commit feature X in a separate
commit. This goes a *long way* in helping all core Django developers
follow your changes.
-
- * Separate bug fixes from feature changes.
-
+
+ * Separate bug fixes from feature changes.
+
Bug fixes need to be added to the current bugfix branch (e.g. the
``1.0.X`` branch) as well as the current trunk.
@@ -782,6 +782,10 @@ dependencies:
* Textile_
* Docutils_
* setuptools_
+ * memcached_, plus the either the python-memcached_ or cmemcached_ Python binding
+
+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.
Each of these dependencies is optional. If you're missing any of them, the
associated tests will be skipped.
@@ -791,6 +795,9 @@ associated tests will be skipped.
.. _Textile: http://pypi.python.org/pypi/textile
.. _docutils: http://pypi.python.org/pypi/docutils/0.4
.. _setuptools: http://pypi.python.org/pypi/setuptools/
+.. _memcached: http://www.danga.com/memcached/
+.. _python-memcached: http://pypi.python.org/pypi/python-memcached/
+.. _cmemcached: http://pypi.python.org/pypi/cmemcache
To run a subset of the unit tests, append the names of the test modules to the
``runtests.py`` command line. See the list of directories in
@@ -862,28 +869,28 @@ for feature branches:
1. Feature branches using a distributed revision control system like
Git_, Mercurial_, Bazaar_, etc.
-
- If you're familiar with one of these tools, this is probably your best
+
+ If you're familiar with one of these tools, this is probably your best
option since it doesn't require any support or buy-in from the Django
core developers.
-
+
However, do keep in mind that Django will continue to use Subversion for
the foreseeable future, and this will naturally limit the recognition of
your branch. Further, if your branch becomes eligible for merging to
trunk you'll need to find a core developer familiar with your DVCS of
choice who'll actually perform the merge.
-
+
If you do decided to start a distributed branch of Django and choose to make it
public, please add the branch to the `Django branches`_ wiki page.
-
+
2. Feature branches using SVN have a higher bar. If you want a branch in SVN
itself, you'll need a "mentor" among the :ref:`core committers
<internals-committers>`. This person is responsible for actually creating
the branch, monitoring your process (see below), and ultimately merging
the branch into trunk.
-
+
If you want a feature branch in SVN, you'll need to ask in
- `django-developers`_ for a mentor.
+ `django-developers`_ for a mentor.
.. _git: http://git.or.cz/
.. _mercurial: http://www.selenic.com/mercurial/
@@ -894,7 +901,7 @@ Branch rules
------------
We've got a few rules for branches born out of experience with what makes a
-successful Django branch.
+successful Django branch.
DVCS branches are obviously not under central control, so we have no way of
enforcing these rules. However, if you're using a DVCS, following these rules
@@ -908,19 +915,19 @@ rules are broken.
* Only branch entire copies of the Django tree, even if work is only
happening on part of that tree. This makes it painless to switch to a
branch.
-
+
* Merge changes from trunk no less than once a week, and preferably every
couple-three days.
-
+
In our experience, doing regular trunk merges is often the difference
between a successful branch and one that fizzles and dies.
-
+
If you're working on an SVN branch, you should be using `svnmerge.py`_
to track merges from trunk.
-
+
* Keep tests passing and documentation up-to-date. As with patches,
we'll only merge a branch that comes with tests and documentation.
-
+
.. _svnmerge.py: http://www.orcaware.com/svn/wiki/Svnmerge.py
Once the branch is stable and ready to be merged into the trunk, alert
View
29 docs/topics/cache.txt
@@ -162,7 +162,7 @@ cache is multi-process and thread-safe. To use it, set ``CACHE_BACKEND`` to
``"locmem:///"``. For example::
CACHE_BACKEND = 'locmem:///'
-
+
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
cache isn't particularly memory-efficient, so it's probably not a good choice
@@ -439,6 +439,33 @@ of clearing the cache for a particular object::
>>> cache.delete('a')
+.. versionadded:: 1.1
+
+You can also increment or decrement a key that already exists using the
+``incr()`` or ``decr()`` methods, respectively. By default, the existing cache
+value will incremented or decremented by 1. Other increment/decrement values
+can be specified by providing an argument to the increment/decrement call. A
+ValueError will be raised if you attempt to increment or decrement a
+nonexistent cache key.::
+
+ >>> cache.set('num', 1)
+ >>> cache.incr('num')
+ 2
+ >>> cache.incr('num', 10)
+ 12
+ >>> cache.decr('num')
+ 11
+ >>> cache.decr('num', 5)
+ 6
+
+.. note::
+
+ ``incr()``/``decr()`` methods are not guaranteed to be atomic. On those
+ backends that support atomic increment/decrement (most notably, the
+ memcached backend), increment and decrement operations will be atomic.
+ However, if the backend doesn't natively provide an increment/decrement
+ operation, it will be implemented using a 2 step retrieve/update.
+
That's it. The cache has very few restrictions: You can cache any object that
can be pickled safely, although keys must be strings.
View
184 tests/regressiontests/cache/tests.py
@@ -9,8 +9,10 @@
import time
import unittest
-from django.core.cache import cache, get_cache
-from django.core.cache.backends.filebased import CacheClass as FileCache
+from django.conf import settings
+from django.core import management
+from django.core.cache import get_cache
+from django.core.cache.backends.base import InvalidCacheBackendError
from django.http import HttpResponse
from django.utils.cache import patch_vary_headers
from django.utils.hashcompat import md5_constructor
@@ -22,39 +24,133 @@ class C:
def m(n):
return 24
-class Cache(unittest.TestCase):
+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):
- # Special-case the file cache so we can clean up after ourselves.
- if isinstance(cache, FileCache):
- self.cache_dir = tempfile.mkdtemp()
- self.cache = get_cache("file:///%s" % self.cache_dir)
- else:
- self.cache_dir = None
- self.cache = cache
-
- def tearDown(self):
- if self.cache_dir is not None:
- shutil.rmtree(self.cache_dir)
-
+ self.cache = get_cache('dummy://')
+
+ def test_simple(self):
+ "Dummy cache backend ignores cache set calls"
+ self.cache.set("key", "value")
+ self.assertEqual(self.cache.get("key"), None)
+
+ def test_add(self):
+ "Add doesn't do anything in dummy cache backend"
+ self.cache.add("addkey1", "value")
+ result = self.cache.add("addkey1", "newvalue")
+ self.assertEqual(result, True)
+ self.assertEqual(self.cache.get("addkey1"), None)
+
+ def test_non_existent(self):
+ "Non-existent keys aren't found in the dummy cache backend"
+ self.assertEqual(self.cache.get("does_not_exist"), None)
+ self.assertEqual(self.cache.get("does_not_exist", "bang!"), "bang!")
+
+ def test_get_many(self):
+ "get_many returns nothing for the dummy cache backend"
+ self.cache.set('a', 'a')
+ self.cache.set('b', 'b')
+ self.cache.set('c', 'c')
+ self.cache.set('d', 'd')
+ self.assertEqual(self.cache.get_many(['a', 'c', 'd']), {})
+ self.assertEqual(self.cache.get_many(['a', 'b', 'e']), {})
+
+ def test_delete(self):
+ "Cache deletion is transparently ignored on the dummy cache backend"
+ self.cache.set("key1", "spam")
+ self.cache.set("key2", "eggs")
+ self.assertEqual(self.cache.get("key1"), None)
+ self.cache.delete("key1")
+ self.assertEqual(self.cache.get("key1"), None)
+ self.assertEqual(self.cache.get("key2"), None)
+
+ def test_has_key(self):
+ "The has_key method doesn't ever return True for the dummy cache backend"
+ self.cache.set("hello1", "goodbye1")
+ self.assertEqual(self.cache.has_key("hello1"), False)
+ self.assertEqual(self.cache.has_key("goodbye1"), False)
+
+ def test_in(self):
+ "The in operator doesn't ever return True for the dummy cache backend"
+ self.cache.set("hello2", "goodbye2")
+ self.assertEqual("hello2" in self.cache, False)
+ self.assertEqual("goodbye2" in self.cache, False)
+
+ def test_incr(self):
+ "Dummy cache values can't be incremented"
+ self.cache.set('answer', 42)
+ self.assertRaises(ValueError, self.cache.incr, 'answer')
+ self.assertRaises(ValueError, self.cache.incr, 'does_not_exist')
+
+ def test_decr(self):
+ "Dummy cache values can't be decremented"
+ self.cache.set('answer', 42)
+ self.assertRaises(ValueError, self.cache.decr, 'answer')
+ self.assertRaises(ValueError, self.cache.decr, 'does_not_exist')
+
+ def test_data_types(self):
+ "All data types are ignored equally by the dummy cache"
+ stuff = {
+ 'string' : 'this is a string',
+ 'int' : 42,
+ 'list' : [1, 2, 3, 4],
+ 'tuple' : (1, 2, 3, 4),
+ 'dict' : {'A': 1, 'B' : 2},
+ 'function' : f,
+ 'class' : C,
+ }
+ self.cache.set("stuff", stuff)
+ self.assertEqual(self.cache.get("stuff"), None)
+
+ def test_expiration(self):
+ "Expiration has no effect on the dummy cache"
+ self.cache.set('expire1', 'very quickly', 1)
+ self.cache.set('expire2', 'very quickly', 1)
+ self.cache.set('expire3', 'very quickly', 1)
+
+ time.sleep(2)
+ self.assertEqual(self.cache.get("expire1"), None)
+
+ self.cache.add("expire2", "newvalue")
+ self.assertEqual(self.cache.get("expire2"), None)
+ self.assertEqual(self.cache.has_key("expire3"), False)
+
+ def test_unicode(self):
+ "Unicode values are ignored by the dummy cache"
+ stuff = {
+ u'ascii': u'ascii_value',
+ u'unicode_ascii': u'Iñtërnâtiônàlizætiøn1',
+ u'Iñtërnâtiônàlizætiøn': u'Iñtërnâtiônàlizætiøn2',
+ u'ascii': {u'x' : 1 }
+ }
+ for (key, value) in stuff.items():
+ self.cache.set(key, value)
+ self.assertEqual(self.cache.get(key), None)
+
+
+class BaseCacheTests(object):
+ # A common set of tests to apply to all cache backends
def test_simple(self):
- # simple set/get
+ # Simple cache set/get works
self.cache.set("key", "value")
self.assertEqual(self.cache.get("key"), "value")
def test_add(self):
- # test add (only add if key isn't already in cache)
+ # A key can be added to a cache
self.cache.add("addkey1", "value")
result = self.cache.add("addkey1", "newvalue")
self.assertEqual(result, False)
self.assertEqual(self.cache.get("addkey1"), "value")
def test_non_existent(self):
+ # Non-existent cache keys return as None/default
# get with non-existent keys
self.assertEqual(self.cache.get("does_not_exist"), None)
self.assertEqual(self.cache.get("does_not_exist", "bang!"), "bang!")
def test_get_many(self):
- # get_many
+ # Multiple cache keys can be returned using get_many
self.cache.set('a', 'a')
self.cache.set('b', 'b')
self.cache.set('c', 'c')
@@ -63,7 +159,7 @@ def test_get_many(self):
self.assertEqual(self.cache.get_many(['a', 'b', 'e']), {'a' : 'a', 'b' : 'b'})
def test_delete(self):
- # delete
+ # Cache keys can be deleted
self.cache.set("key1", "spam")
self.cache.set("key2", "eggs")
self.assertEqual(self.cache.get("key1"), "spam")
@@ -72,17 +168,37 @@ def test_delete(self):
self.assertEqual(self.cache.get("key2"), "eggs")
def test_has_key(self):
- # has_key
+ # The cache can be inspected for cache keys
self.cache.set("hello1", "goodbye1")
self.assertEqual(self.cache.has_key("hello1"), True)
self.assertEqual(self.cache.has_key("goodbye1"), False)
def test_in(self):
+ # The in operator can be used to inspet cache contents
self.cache.set("hello2", "goodbye2")
self.assertEqual("hello2" in self.cache, True)
self.assertEqual("goodbye2" in self.cache, False)
+ def test_incr(self):
+ # Cache values can be incremented
+ self.cache.set('answer', 41)
+ self.assertEqual(self.cache.incr('answer'), 42)
+ self.assertEqual(self.cache.get('answer'), 42)
+ self.assertEqual(self.cache.incr('answer', 10), 52)
+ self.assertEqual(self.cache.get('answer'), 52)
+ self.assertRaises(ValueError, self.cache.incr, 'does_not_exist')
+
+ def test_decr(self):
+ # Cache values can be decremented
+ self.cache.set('answer', 43)
+ self.assertEqual(self.cache.decr('answer'), 42)
+ self.assertEqual(self.cache.get('answer'), 42)
+ self.assertEqual(self.cache.decr('answer', 10), 32)
+ self.assertEqual(self.cache.get('answer'), 32)
+ self.assertRaises(ValueError, self.cache.decr, 'does_not_exist')
+
def test_data_types(self):
+ # Many different data types can be cached
stuff = {
'string' : 'this is a string',
'int' : 42,
@@ -96,6 +212,7 @@ def test_data_types(self):
self.assertEqual(self.cache.get("stuff"), stuff)
def test_expiration(self):
+ # Cache values can be set to expire
self.cache.set('expire1', 'very quickly', 1)
self.cache.set('expire2', 'very quickly', 1)
self.cache.set('expire3', 'very quickly', 1)
@@ -108,6 +225,7 @@ def test_expiration(self):
self.assertEqual(self.cache.has_key("expire3"), False)
def test_unicode(self):
+ # Unicode values can be cached
stuff = {
u'ascii': u'ascii_value',
u'unicode_ascii': u'Iñtërnâtiônàlizætiøn1',
@@ -118,14 +236,36 @@ def test_unicode(self):
self.cache.set(key, value)
self.assertEqual(self.cache.get(key), value)
+class DBCacheTests(unittest.TestCase, BaseCacheTests):
+ def setUp(self):
+ management.call_command('createcachetable', 'test_cache_table', verbosity=0, interactive=False)
+ self.cache = get_cache('db://test_cache_table')
+
+ def tearDown(self):
+ from django.db import connection
+ cursor = connection.cursor()
+ cursor.execute('DROP TABLE test_cache_table');
+
+class LocMemCacheTests(unittest.TestCase, BaseCacheTests):
+ def setUp(self):
+ self.cache = get_cache('locmem://')
+
+# 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
+# your memcache server.
+if settings.CACHE_BACKEND.startswith('memcached://'):
+ class MemcachedCacheTests(unittest.TestCase, BaseCacheTests):
+ def setUp(self):
+ self.cache = get_cache(settings.CACHE_BACKEND)
-class FileBasedCacheTests(unittest.TestCase):
+class FileBasedCacheTests(unittest.TestCase, BaseCacheTests):
"""
Specific test cases for the file-based cache.
"""
def setUp(self):
self.dirname = tempfile.mkdtemp()
- self.cache = FileCache(self.dirname, {})
+ self.cache = get_cache('file:///%s' % self.dirname)
def tearDown(self):
shutil.rmtree(self.dirname)
Please sign in to comment.
Something went wrong with that request. Please try again.