channelManager.startRenderingCycle(req, res, uPElement);
// after this point the layout is determined
UserPreferences userPreferences = uPreferencesManager.getUserPreferences();
StructureStylesheetDescription ssd = uPreferencesManager.getStructureStylesheetDescription();
ThemeStylesheetDescription tsd = uPreferencesManager.getThemeStylesheetDescription();
// verify upElement and determine rendering root --begin
if (newRootNodeId != null && (!newRootNodeId.equals(rootNodeId))) {
// see if the new detach traget is valid
try {
rElement = ulm.getNode(newRootNodeId);
}
catch (PortalException e) {
rElement = null;
}
if (rElement != null) {
// valid new root id was specified. need to redirect
// peterk: should we worry about forwarding
// parameters here ? or those passed with detach
// always get sacked ?
// Andreas: Forwarding parameters with detach
// are not lost anymore with the URLUtil class.
// Skip the uP_detach_target parameter since
// it has already been processed
String[] skipParams = new String[] { "uP_detach_target" };
try {
URLUtil.redirect(req, res, newRootNodeId, true, skipParams, CHARACTER_SET);
}
catch (PortalException pe) {
log.error("PortalException occurred while redirecting",
pe);
}
return;
}
}
// LogService.log(LogService.DEBUG,"uP_detach_target=\""+rootNodeId+"\".");
try {
rElement = ulm.getNode(rootNodeId);
}
catch (PortalException e) {
rElement = null;
}
// if we haven't found root node so far, set it to the userLayoutRoot
if (rElement == null) {
rootNodeId = UPFileSpec.USER_LAYOUT_ROOT_NODE;
}
// update the render target
uPElement.setMethodNodeId(rootNodeId);
// inform channel manager about the new uPElement value
channelManager.setUPElement(uPElement);
// verify upElement and determine rendering root --begin
// Increase output buffer size, buffer will be flushed before and after every <channel>
res.setBufferSize(16 * 1024);
// Disable page caching
res.setHeader("pragma", "no-cache");
res.setHeader("Cache-Control", "no-cache, max-age=0, must-revalidate");
res.setDateHeader("Expires", 0);
// set the response mime type
res.setContentType(tsd.getMimeType() + "; charset=" + CHARACTER_SET);
// obtain the writer - res.getWriter() must occur after res.setContentType()
Writer out = new BufferedWriter(res.getWriter(), 1024);
// get a serializer appropriate for the target media
BaseMarkupSerializer markupSerializer =
MEDIA_MANAGER.getSerializerByName(tsd.getSerializerName(),
new ChannelTitleIncorporationWiterFilter(out, channelManager, ulm));
// set up the serializer
markupSerializer.asContentHandler();
// see if we can use character caching
boolean ccaching = (CHARACTER_CACHE_ENABLED && (markupSerializer instanceof CachingSerializer));
channelManager.setCharacterCaching(ccaching);
// pass along the serializer name
channelManager.setSerializerName(tsd.getSerializerName());
// initialize ChannelIncorporationFilter
CharacterCachingChannelIncorporationFilter cif = new CharacterCachingChannelIncorporationFilter(markupSerializer, channelManager, CACHE_ENABLED && CHARACTER_CACHE_ENABLED, req, res);
String cacheKey = null;
boolean output_produced = false;
if (CACHE_ENABLED) {
boolean ccache_exists = false;
// obtain the cache key
cacheKey = constructCacheKey(uPreferencesManager, rootNodeId);
if (ccaching) {
// obtain character cache
List<CacheEntry> cacheEntries = systemCharacterCache.get(cacheKey);
if(cacheEntries!=null && cacheEntries.size()>0) {
ccache_exists = true;
if (log.isDebugEnabled())
log
.debug("retreived transformation character block cache for a key \""
+ cacheKey + "\"");
// start channel threads
for(int i=0;i<cacheEntries.size();i++) {
CacheEntry ce = cacheEntries.get(i);
if (ce.getCacheType().equals(CacheType.CHANNEL_CONTENT)) {
String channelSubscribeId = ((ChannelContentCacheEntry)ce).getChannelId();
if(channelSubscribeId!=null) {
try {
channelManager.startChannelRendering(req, res, channelSubscribeId);
} catch (PortalException e) {
log.error("UserInstance::renderState() : unable to start rendering channel (subscribeId=\""+channelSubscribeId+"\", user="+person.getID()+" layoutId="+uPreferencesManager.getCurrentProfile().getLayoutId(),e);
}
} else {
log.error("channel entry " + Integer.toString(i)
+ " in character cache is invalid (user=" + person.getID() + ")!");
}
}
}
channelManager.commitToRenderingChannelSet();
// go through the output loop
CachingSerializer cSerializer = (CachingSerializer) markupSerializer;
cSerializer.setDocumentStarted(true);
for(int sb=0; sb<cacheEntries.size();sb++) {
CacheEntry ce = cacheEntries.get(sb);
if (log.isDebugEnabled()) {
DebugCachingSerializer dcs = new DebugCachingSerializer();
log.debug("----------printing " + ce.getCacheType() + " cache block "+Integer.toString(sb));
ce.replayCache(dcs, channelManager, req, res);
log.debug(dcs.getCache());
}
// get cache block output
ce.replayCache(cSerializer, channelManager, req, res);
}
cSerializer.flush();
output_produced = true;
}
}
// if this failed, try XSLT cache
if ((!ccaching) || (!ccache_exists)) {
// obtain XSLT cache
SAX2BufferImpl cachedBuffer = systemCache.get(cacheKey);
if (cachedBuffer != null) {
// replay the buffer to channel incorporation filter
if (log.isDebugEnabled()) {
log.debug("retreived XSLT transformation cache for a key '" + cacheKey + "'");
}
// attach rendering buffer downstream of the cached buffer
ChannelRenderingBuffer crb = new ChannelRenderingBuffer(cachedBuffer, channelManager, ccaching, req, res);
// attach channel incorporation filter downstream of the channel rendering buffer
cif.setParent(crb);
crb.setOutputAtDocumentEnd(true);
cachedBuffer.outputBuffer(crb);
output_produced = true;
}
}
}
// fallback on the regular rendering procedure
if (!output_produced) {
// obtain transformer handlers for both structure and theme stylesheets
TransformerHandler ssth = XSLT.getTransformerHandler(ResourceLoader.getResourceAsURL(this.getClass(), ssd.getStylesheetURI()).toString());
TransformerHandler tsth = XSLT.getTransformerHandler(tsd.getStylesheetURI(), localeManager
.getLocales(), this);
// obtain transformer references from the handlers
Transformer sst = ssth.getTransformer();