Hello everyone,
This is an updated version of the caching patch against current SVN.
This is mostly code from the Nevow-caching branch from dialtone with the
addition of a cacheTimeout logic on the whole rendering that I use for
the whole non-user dependent dynamic pages of my site. I also use
dialtone's stan cache for some fragment (not all unfortunately) and that
was a significant speedup but I still need the other more aggressive
caching in the Page class.
Please let me know if you see any bug in this code, thanks! To me it
looks useful enough to be merged in trunk but that's just my humble
opinion.
This code allows >200req per second to be served for dynamic but mostly
static data. It doesn't max out a 100mbit yet with <5k pages, but it
greatly exceeds the bandwidth of a 10mbit.
Index: Nevow/nevow/tags.py
===================================================================
--- Nevow/nevow/tags.py (revision 1185)
+++ Nevow/nevow/tags.py (working copy)
@@ -25,7 +25,7 @@
"""
-from nevow.stan import Proto, Tag, directive, raw, xml, CommentProto, invisible, slot, cdata
+from nevow.stan import Proto, Tag, directive, raw, xml, CommentProto, invisible, slot, cdata, cached
comment = CommentProto()
@@ -62,7 +62,9 @@
def inlineJS(s):
return script(type="text/javascript", language="JavaScript")[xml('\n//<![CDATA[\n%s\n//]]>\n' % s)]
-__all__ = tags + ['invisible', 'comment', '_dir', '_del', '_object', '_map', 'drange', 'Tag', 'directive', 'xml', 'raw', 'slot', 'cdata', 'inlineJS'] + ['_%s' % x for x in range(100)]
+__all__ = tags + ['invisible', 'comment', '_dir', '_del', '_object',
+ '_map', 'drange', 'Tag', 'directive', 'xml', 'raw',
+ 'slot', 'cached', 'cdata', 'inlineJS'] + ['_%s' % x for x in range(100)]
########################
Index: Nevow/nevow/__init__.py
===================================================================
--- Nevow/nevow/__init__.py (revision 1185)
+++ Nevow/nevow/__init__.py (working copy)
@@ -183,6 +183,7 @@
nevow.flat.flatstan.RendererSerializer nevow.inevow.IRenderer
nevow.flat.flatstan.DirectiveSerializer nevow.stan.directive
nevow.flat.flatstan.SlotSerializer nevow.stan.slot
+nevow.flat.flatstan.CachedSerializer nevow.stan.cached
nevow.flat.flatstan.ContextSerializer nevow.context.WovenContext
nevow.flat.flatstan.DeferredSerializer twisted.internet.defer.Deferred
nevow.flat.flatstan.DeferredSerializer twisted.internet.defer.DeferredList
Index: Nevow/nevow/flat/flatstan.py
===================================================================
--- Nevow/nevow/flat/flatstan.py (revision 1185)
+++ Nevow/nevow/flat/flatstan.py (working copy)
@@ -9,10 +9,14 @@
from nevow import util
from nevow.stan import Proto, Tag, xml, directive, Unset, invisible
from nevow.inevow import IRenderer, IRendererFactory, IGettable, IData
-from nevow.flat import precompile, serialize
+from nevow.flat import precompile, serialize, iterflatten
from nevow.accessors import convertToData
from nevow.context import WovenContext
+from time import time as now
+from cStringIO import StringIO
+from twisted.internet import defer
+
allowSingleton = ('img', 'br', 'hr', 'base', 'meta', 'link', 'param', 'area',
'input', 'col', 'basefont', 'isindex', 'frame')
@@ -226,6 +230,45 @@
return serialize(original.default, context)
return serialize(data, context)
+_CACHE = {}
+def CachedSerializer(original, context):
+ cached = _CACHE.get(original.name, None)
+ _now = now()
+ life = _now-original.lifetime
+ if cached and (cached[0] > life or not original.lifetime):
+ yield cached[1]
+ return
+ io = StringIO()
+ for child in iterflatten(original.children, context, io.write,
+ lambda item: True):
+ if isinstance(child, tuple):
+ childDeferred, childReturner = child
+
+ d = defer.Deferred() ## A new deferred for the outer loop, whose result
+ ## we don't care about, because we don't want the outer loop to write
+ ## anything when this deferred fires -- only when the entire for loop
+ ## has completed and we have all the "children" flattened
+
+ def innerDeferredResultAvailable(result):
+ childReturner(result) ## Cause the inner iterflatten to continue
+ d.callback('') ## Cause the outer iterflatten to continue
+ return ''
+
+ childDeferred.addCallback(innerDeferredResultAvailable)
+
+ ## Make the outer loop wait on our new deferred.
+ ## We call the new deferred back with ''
+ ## Which will cause the outer loop to write '' to the request,
+ ## which doesn't matter. It will then call our "returner",
+ ## which is just the noop lambda below, because we don't care
+ ## about the return result of the new deferred, which is just
+ ## ''
+
+ yield d, lambda result: ''
+ result = io.getvalue()
+ _CACHE[original.name] = (_now, result)
+ yield result
+
def ContextSerializer(original, context):
originalContext = original.clone(deep=False)
originalContext.precompile = context and context.precompile or False
Index: Nevow/nevow/stan.py
===================================================================
--- Nevow/nevow/stan.py (revision 1185)
+++ Nevow/nevow/stan.py (working copy)
@@ -119,8 +119,33 @@
"""
raise NotImplementedError, "Stan slot instances are not iterable."
+class cached(object):
+ """Marker for cached content
+ """
+ __slots__ = ['name', 'children', 'lifetime']
+ def __init__(self, name, lifetime=0):
+ self.name = name
+ self.children = []
+ self.lifetime = lifetime
+ def __repr__(self):
+ return "cached('%s','%s')" % self.name, self.lifetime
+
+ def __getitem__(self, children):
+ """cached content is what is being cached
+ """
+ if not isinstance(children, (list, tuple)):
+ children = [children]
+ self.children.extend(children)
+ return self
+
+ def __iter__(self):
+ """Prevent an infinite loop if someone tries to do
+ for x in cached('foo'):
+ """
+ raise NotImplementedError, "Stan slot instances are not iterable."
+
class Tag(object):
"""Tag instances represent XML tags with a tag name, attributes,
and children. Tag instances can be constructed using the Prototype
Index: Nevow/nevow/rend.py
===================================================================
--- Nevow/nevow/rend.py (revision 1185)
+++ Nevow/nevow/rend.py (working copy)
@@ -30,6 +30,7 @@
from nevow import flat
from nevow.util import log
from nevow import util
+from nevow import url
import formless
from formless import iformless
@@ -374,6 +375,7 @@
self.children = {}
self.children[name] = child
+_CACHE = {}
class Page(Fragment, ConfigurableFactory, ChildLookupMixin):
"""A page is the main Nevow resource and renders a document loaded
@@ -384,12 +386,48 @@
buffered = False
+ cacheTimeout = None # 0 means cache forever, >0 sets the seconds of caching
+ __lastCacheRendering = 0 # this should not be touched by the parent class
+
beforeRender = None
afterRender = None
addSlash = None
flattenFactory = flat.flattenFactory
+ def hasCache(self, ctx):
+ if self.cacheTimeout is None:
+ return None
+
+ _now = now() # run gettimeofday only once
+ timeout = _now > self.__lastCacheRendering + self.cacheTimeout and \
+ self.cacheTimeout > 0
+ c = self.lookupCache(ctx)
+ if timeout or c is None:
+ self.__lastCacheRendering = _now # stop other renders
+ from twisted.internet.defer import Deferred
+ d = Deferred()
+ self.storeCache(ctx, d)
+ # force only this rendering, others will wait the deferred
+ c = None
+ return c
+ def chainDeferredCache(self, ctx, d):
+ if self.cacheTimeout is None:
+ return d
+
+ from twisted.internet.defer import Deferred
+ c = self.lookupCache(ctx)
+ if isinstance(c, Deferred):
+ # we're the thread that went ahead to refresh the cache
+ d.chainDeferred(c)
+ return d
+ def cacheIDX(self, ctx):
+ return str(url.URL.fromContext(ctx))
+ def storeCache(self, ctx, c):
+ _CACHE[self.cacheIDX(ctx)] = c
+ def lookupCache(self, ctx):
+ return _CACHE.get(self.cacheIDX(ctx))
+
def renderHTTP(self, ctx, doBefore=True):
## XXX request is really ctx now, change the name here
request = inevow.IRequest(ctx)
@@ -412,11 +450,17 @@
if self.afterRender is not None:
return util.maybeDeferred(self.afterRender,ctx)
- if self.buffered:
+ c = self.hasCache(ctx)
+ if c:
+ return util.maybeDeferred(finishRequest).addCallback(lambda r: c)
+
+ if self.buffered or self.cacheTimeout is not None:
io = StringIO()
writer = io.write
def finisher(result):
- request.write(io.getvalue())
+ c = io.getvalue()
+ self.storeCache(ctx, c)
+ request.write(c)
return util.maybeDeferred(finishRequest).addCallback(lambda r: result)
else:
writer = request.write
@@ -426,7 +470,7 @@
doc = self.docFactory.load()
ctx = WovenContext(ctx, tags.invisible[doc])
- return self.flattenFactory(doc, ctx, writer, finisher)
+ return self.chainDeferredCache(ctx, self.flattenFactory(doc, ctx, writer, finisher))
def rememberStuff(self, ctx):
Fragment.rememberStuff(self, ctx)
This last bit avoids an error at runtime, clearly getStyleSheet should
be overriden then (not stylesheet).
Index: Nevow/nevow/vhost.py
===================================================================
--- Nevow/nevow/vhost.py (revision 1185)
+++ Nevow/nevow/vhost.py (working copy)
@@ -19,7 +19,7 @@
"""
def getStyleSheet(self):
- return self.stylesheet
+ return VirtualHostList.stylesheet
def data_hostlist(self, context, data):
return self.nvh.hosts.keys()
