cocoon-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From brian moseley ...@maz.org>
Subject Re: Content-length
Date Sun, 23 Jan 2000 22:06:24 GMT
On Sun, 23 Jan 2000, Nicolás Lichtmaier wrote:

>  I'm no expert on XML, but I've always have this idea...
> wouldn't it be posible to have an abstraction of the
> issue? And that abstraction would be some kind of
> partial DOM. The application would process the DOM tree.
> If it touches something it hasn't arrived yet, it blocks
> until the data is ready. Normal applications would be
> able to ignore this, thus forcing the whole data to be
> ready from the very first DOM manipulations. But an
> application expecting huge amount of data would be
> designed with some care, in order to use the tree
> sequentially.

in fact this is almost exactly the approach we've taken at
cp.

our templating system is html based. we have defined special
tags that identify 'smart nodes'. each smartnode is
associated with its own template that can contain smartnode
tags. thus, when we process the template for the requested
uri, we build a dom document for it, and a dom fragment for
each of the referenced smartnodes' templates, and for each
of those templates' smartnodes' templates, etc. at the end
of course these pieces are all composed into a single dom
document.

furthermore, when each smartnode is constructed, it creates
a set of 'backend service requests' and adds them to a
'backend service request queue'. once the entire dom
document is constructed, we begin asynchronously executing
each backend service request, and then we tell the dom
document to begin outputting itself. as each smartnode is
reached, we pause until all of that smartnode's pending
requests have completed and the results have been
processed. at this point the smartnode can output its html
representation and we continue through the dom document to
the next smartnode.

the dom document outputs to a stream that can be buffered or
not according to policies attached to the request uri and to
other dimensions of the request. so for certain uris we dont
buffer at all, but for most we do. so i cant say the
application is totally unaware of the blocking behavior, but
the behavior is managed with a policy abstraction.


Mime
View raw message