Changeset 108

Timestamp:

11/07/09 18:23:31 (10 months ago)

Author:

max

Message:

Added new automated template fragment cache invalidation.

Location:

trunk/courant/core/caching

Files:

• __init__.py (modified) (1 diff)
• actions.py (added)
• management (added)
• management/__init__.py (added)
• management/commands (added)
• management/commands/__init__.py (added)
• management/commands/prune_cachedobjects.py (added)
• migrations (added)
• migrations/0001_initial.py (added)
• migrations/__init__.py (added)
• models.py (modified) (1 diff)
• templatetags/smart_cache.py (modified) (8 diffs)

trunk/courant/core/caching/__init__.py

@@ +1 @@
+from actions import *

trunk/courant/core/caching/models.py

@@ -1 @@
-# filler so courant.core.caching gets recognized as installable app
+from django.db import models
+from django.db.models.signals import post_save
+from django.core.cache import cache
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.contenttypes import generic
+from django_extensions.db.fields import ModificationDateTimeField
+from django.conf import settings
+
+class CachedObject(models.Model):
+        cache_key = models.CharField(max_length=255)
+        url = models.CharField(max_length=255)
+        content_type = models.ForeignKey(ContentType)
+        object_id = models.PositiveIntegerField()
+        content_object = generic.GenericForeignKey('content_type', 'object_id')
+        modified_at = ModificationDateTimeField()
+
+def clear_obj_cache(obj):
+        try:
+                obj_caches = CachedObject.objects.filter(content_type=ContentType.objects.get_for_model(obj),
+                                                                                                 object_id=obj.pk)
+                urls = []
+                for obj_cache in obj_caches:
+                        # mark object's cache as stale so it will be safely regenerated
+                        cache.delete("%s.stale" % obj_cache.cache_key)
+
+                        # mark URL as needing cache clearing
+                        urls.append(obj_cache.url)
+
+                # delete caches for all marked URLs
+                # since full-page caches don't use anti-dogpiling, we delete the caches themselves
+                for url in set(urls):
+                        key = "%s-%s" % (settings.CACHE_KEY_PREFIX, url)
+                        print "Deleting cache: %s" % key
+                        cache.delete(key)
+        except:
+                pass
+
+def clear_obj_cache_signal(sender, instance, **kwargs):
+        clear_obj_cache(instance)
+post_save.connect(clear_obj_cache_signal)

trunk/courant/core/caching/templatetags/smart_cache.py

@@ -3 +3 @@
 from django.core.cache import cache
 from django.utils.encoding import force_unicode
+from django.contrib.contenttypes.models import ContentType
+
+from courant.core.caching.models import CachedObject
 
 register = Library()
@@ -13 +16 @@
     STALE_CREATED = 2
 
-    def __init__(self, nodelist, expire_time, fragment_name, vary_on):
+    def __init__(self, nodelist, expire_time, fragment_name, vary_on, cache_obj=None):
         self.nodelist = nodelist
         self.stale_time = expire_time
@@ -19 +22 @@
         self.fragment_name = fragment_name
         self.vary_on = vary_on
+        self.cache_obj = cache_obj
 
     def render(self, context):
@@ -31 +35 @@
             value = None # force refresh
         if value is None:
+            context.push()
+            context['cache_key'] = cache_key
             value = self.nodelist.render(context)
+            context.pop()
             cache.set(cache_key, value, self.expire_time)
             cache.set(cache_key_stale, self.STALE_CREATED, self.stale_time)
+            if self.cache_obj:
+                obj = resolve_variable(self.cache_obj, context)
+                co, created = CachedObject.objects.get_or_create(url=context['request'].get_full_path(),
+                                                                 content_type=ContentType.objects.get_for_model(obj),
+                                                                 object_id=obj.pk,
+                                                                 cache_key=cache_key)
+                co.save() # update modified timestamp
         return value
 
@@ -43 +57 @@
     effect.
 
-    You can easily replace the default template cache, just change the load
-    statement from ``{% load cache %}`` to ``{% load cache_smart %}``.
-
     Usage::
 
-        {% load cache_smart %}
         {% cache [expire_time] [fragment_name] %}
             .. some expensive processing ..
@@ -55 +65 @@
     This tag also supports varying by a list of arguments::
 
-        {% load cache_smart %}
         {% cache [expire_time] [fragment_name] [var1] [var2] .. %}
             .. some expensive processing ..
@@ -61 +70 @@
 
     Each unique set of arguments will result in a unique cache entry.
+    
+    To enable automatic cache invalidation, a model object can be passed as
+    a final optional parameter. Whenever the object is saved, this template
+    fragment will be regenerated::
+        
+        {% cache [expire_time] [fragment_name] [var1] for [obj] %}
+            .. some expensive processing ..
+        {% endcache %}
+        
+    See the 'cache_dup' template tag to enable automatic cache invalidation
+    based on more than a single object.
     """
     nodelist = parser.parse(('endcache', ))
@@ -74 +94 @@
             u"First argument to '%r' must be an integer (got '%s')." %
             (tokens[0], tokens[1]))
+    if (tokens[-2] == 'for'):
+        return SmartCacheNode(nodelist, expire_time, tokens[2], tokens[3:-2], tokens[-1])
     return SmartCacheNode(nodelist, expire_time, tokens[2], tokens[3:])
 
 register.tag('cache', do_smart_cache)
+
+class CacheDependencyNode(Node):
+    def __init__(self, deps):
+        self.deps = deps
+
+    def render(self, context):
+        if 'cache_key' in context:
+            for dep in self.deps:
+                obj = resolve_variable(dep, context)
+                co, created = CachedObject.objects.get_or_create(url=context['request'].get_full_path(),
+                                                                 content_type=ContentType.objects.get_for_model(obj),
+                                                                 object_id=obj.pk,
+                                                                 cache_key=context['cache_key'])
+                co.save() # update modified timestamp
+        return ''
+
+def do_cache_dependency(parser, token):
+    """
+    When used inside a {% cache %} template tag block, this template tag will
+    cause the entire cache block to be regenerated whenever any of the passed
+    parameters change::
+        
+        {% cache_dup [var1] %}
+        {% cache_dup [var1] [var2] %}
+        
+    Example usage::
+        
+        {% cache .. for object_a %}
+            .. expensive processing ..
+            {% cache_dup object_b %}
+            .. more processing ..
+            {% cache_dup object_c object _d %}
+        {% endcache %}
+        
+    In this example, when the model objects referred to by 'object_a', 
+    'object_b', 'object_c', or 'object_d' are saved, this template fragment
+    will be automatically invalidated and regenerated. 
+    
+    There is no limit to the number of times 'cache_dup' can be called within
+    a single 'cache' block.
+    """
+    bits = token.split_contents()
+    if len(bits) > 1:
+        return CacheDependencyNode(bits[1:])
+    return ''
+register.tag('cache_dep', do_cache_dependency)