Cheetah/CacheRegion.py

   1 # $Id: CacheRegion.py,v 1.3 2006/01/28 04:19:30 tavis_rudd Exp $
   2 """Cache holder classes for Cheetah:
   3
   4 Cache regions are defined using the #cache Cheetah directive. Each
   5 cache region can be viewed as a dictionary (keyed by cacheRegionID)
   6 handling at least one cache item (the default one). It's possible to add
   7 cacheItems in a region by using the `varyBy` #cache directive parameter as
   8 in the following example::
   9    #def getArticle
  10       this is the article content.
  11    #end def
  12
  13    #cache varyBy=$getArticleID()
  14       $getArticle($getArticleID())
  15    #end cache
  16
  17 The code above will generate a CacheRegion and add new cacheItem for each value
  18 of $getArticleID().
  19
  20 Meta-Data
  21 ================================================================================
  22 Author: Tavis Rudd <tavis@damnsimple.com> and Philippe Normand <phil@base-art.net>
  23 Version: $Revision: 1.3 $
  24 Start Date: 2005/06/20
  25 Last Revision Date: $Date: 2006/01/28 04:19:30 $
  26 """
  27 __author__ = "Tavis Rudd <tavis@damnsimple.com> and Philippe Normand <phil@base-art.net>"
  28 __revision__ = "$Revision: 1.3 $"[11:-2]
  29
  30 try:
  31     import hashlib
  32 except:
  33     import md5 as hashlib
  34 from time import time as currentTime
  35 from Cheetah.CacheStore import MemoryCacheStore
  36
  37 class CacheItem:
  38     """A CacheItem is a container storing:
  39
  40         - cacheID (string)
  41         - refreshTime (timestamp or None) : last time the cache was refreshed
  42         - data (string) : the content of the cache
  43     """
  44
  45     def __init__(self, cacheItemID, cacheStore):
  46         self._cacheItemID = cacheItemID
  47         self._cacheStore = cacheStore
  48         self._refreshTime = None
  49         self._expiryTime = 0
  50
  51     def hasExpired(self):
  52         return (self._expiryTime and currentTime() > self._expiryTime)
  53
  54     def setExpiryTime(self, time):
  55         self._expiryTime = time
  56
  57     def getExpiryTime(self):
  58         return self._expiryTime
  59
  60     def setData(self, data):
  61         self._refreshTime = currentTime()
  62         self._cacheStore.set(self._cacheItemID, data, self._expiryTime)
  63
  64     def getRefreshTime(self):
  65         return self._refreshTime
  66
  67     def getData(self):
  68         assert self._refreshTime
  69         return self._cacheStore.get(self._cacheItemID)
  70
  71     def renderOutput(self):
  72         """Can be overridden to implement edge-caching"""
  73         return self.getData() or ""
  74
  75     def clear(self):
  76         self._cacheStore.delete(self._cacheItemID)
  77         self._refreshTime = None
  78
  79 class _CacheDataStoreWrapper:
  80     def __init__(self, dataStore, keyPrefix):
  81         self._dataStore = dataStore
  82         self._keyPrefix = keyPrefix
  83
  84     def get(self, key):
  85         return self._dataStore.get(self._keyPrefix+key)
  86
  87     def delete(self, key):
  88         self._dataStore.delete(self._keyPrefix+key)
  89
  90     def set(self, key, val, time=0):
  91         self._dataStore.set(self._keyPrefix+key, val, time=time)
  92
  93 class CacheRegion:
  94     """ A `CacheRegion` stores some `CacheItem` instances.
  95
  96     This implementation stores the data in the memory of the current process.
  97     If you need a more advanced data store, create a cacheStore class that works
  98     with Cheetah's CacheStore protocol and provide it as the cacheStore argument
  99     to __init__.  For example you could use
 100     Cheetah.CacheStore.MemcachedCacheStore, a wrapper around the Python
 101     memcached API (http://www.danga.com/memcached).
 102     """
 103     _cacheItemClass = CacheItem
 104
 105     def __init__(self, regionID, templateCacheIdPrefix='', cacheStore=None):
 106         self._isNew = True
 107         self._regionID = regionID
 108         self._templateCacheIdPrefix = templateCacheIdPrefix
 109         if not cacheStore:
 110             cacheStore = MemoryCacheStore()
 111         self._cacheStore = cacheStore
 112         self._wrappedCacheDataStore = _CacheDataStoreWrapper(
 113             cacheStore, keyPrefix=templateCacheIdPrefix+':'+regionID+':')
 114         self._cacheItems = {}
 115
 116     def isNew(self):
 117         return self._isNew
 118
 119     def clear(self):
 120         " drop all the caches stored in this cache region "
 121         for cacheItemId in self._cacheItems.keys():
 122             cacheItem = self._cacheItems[cacheItemId]
 123             cacheItem.clear()
 124             del self._cacheItems[cacheItemId]
 125
 126     def getCacheItem(self, cacheItemID):
 127         """ Lazy access to a cacheItem
 128
 129             Try to find a cache in the stored caches. If it doesn't
 130             exist, it's created.
 131
 132             Returns a `CacheItem` instance.
 133         """
 134         cacheItemID = hashlib.md5(str(cacheItemID)).hexdigest()
 135
 136         if not self._cacheItems.has_key(cacheItemID):
 137             cacheItem = self._cacheItemClass(
 138                 cacheItemID=cacheItemID, cacheStore=self._wrappedCacheDataStore)
 139             self._cacheItems[cacheItemID] = cacheItem
 140             self._isNew = False
 141         return self._cacheItems[cacheItemID]