+"""
+Memcached cache backend with group O(1) invalidation ability, dog-pile
+effect prevention using MintCache algorythm and project version support to allow
+gracefull updates and multiple django projects on same memcached instance.
+Long keys (>250) are truncated and appended with md5 hash.
+"""
+
+import uuid
+import logging
+import sys
+import time
+from django.core.cache.backends.memcached import CacheClass as MemcachedCacheClass
+from django.conf import settings
+from cache_utils.utils import sanitize_memcached_key
+
+# This prefix is appended to the group name to prevent cache key clashes.
+_VERSION_PREFIX = getattr(settings, 'VERSION', "")
+_KEY_PREFIX = "_group::"
+
+# MINT_DELAY is an upper bound on how long any value should take to
+# be generated (in seconds)
+MINT_DELAY = 30
+
+class CacheClass(MemcachedCacheClass):
+
+ def add(self, key, value, timeout=0, group=None):
+ key = self._make_key(group, key)
+
+ refresh_time = timeout + time.time()
+ real_timeout = timeout + MINT_DELAY
+ packed_value = (value, refresh_time, False)
+
+ return super(CacheClass, self).add(key, packed_value, real_timeout)
+
+ def get(self, key, default=None, group=None):
+ key = self._make_key(group, key)
+ packed_value = super(CacheClass, self).get(key, default)
+ if packed_value is None:
+ return default
+ value, refresh_time, refreshed = packed_value
+ if (time.time() > refresh_time) and not refreshed:
+ # Store the stale value while the cache revalidates for another
+ # MINT_DELAY seconds.
+ self.set(key, value, timeout=MINT_DELAY, group=group, refreshed=True)
+ return default
+ return value
+
+ def set(self, key, value, timeout=0, group=None, refreshed=False):
+ key = self._make_key(group, key)
+ refresh_time = timeout + time.time()
+ real_timeout = timeout + MINT_DELAY
+ packed_value = (value, refresh_time, refreshed)
+ return super(CacheClass, self).set(key, packed_value, real_timeout)
+
+ def delete(self, key, group=None):
+ key = self._make_key(group, key)
+ return super(CacheClass, self).delete(key)
+
+ def invalidate_group(self, group):
+ """ Invalidates all cache keys belonging to group """
+ key = "%s%s%s" % (_VERSION_PREFIX, _KEY_PREFIX, group)
+ super(CacheClass, self).delete(key)
+
+ def _make_key(self, group, key, hashkey=None):
+ """ Generates a new cache key which belongs to a group, has
+ _VERSION_PREFIX prepended and is shorter than memcached key length
+ limit.
+ """
+ key = _VERSION_PREFIX + key
+ if group:
+ if not hashkey:
+ hashkey = self._get_hashkey(group)
+ key = "%s:%s-%s" % (group, key, hashkey)
+ return sanitize_memcached_key(key)
+
+ def _get_hashkey(self, group):
+ """ This can be useful sometimes if you're doing a very large number
+ of operations and you want to avoid all of the extra cache hits.
+ """
+ key = "%s%s%s" % (_VERSION_PREFIX, _KEY_PREFIX, group)
+ hashkey = super(CacheClass, self).get(key)
+ if hashkey is None:
+ hashkey = str(uuid.uuid4())
+ super(CacheClass, self).set(key, hashkey)
+ return hashkey
+
+ def clear(self):
+ self._cache.flush_all()
+
+# ======================================
+# I didn't implement methods below to work with MintCache so raise
+# NotImplementedError for them.
+
+ def incr(self, key, delta=1, group=None):
+# if group:
+# key = self._make_key(group, key)
+# return super(CacheClass, self).incr(key, delta)
+ raise NotImplementedError
+
+ def decr(self, key, delta=1, group=None):
+# if group:
+# key = self._make_key(group, key)
+# return super(CacheClass, self).decr(key, delta)
+ raise NotImplementedError
+
+ def get_many(self, keys, group=None):
+# hashkey = self._get_hashkey(group)
+# keys = [self._make_key(group, k, hashkey) for k in keys]
+# return super(CacheClass, self).get_many(keys)
+ raise NotImplementedError