* @see org.jasig.portal.rendering.IPortalRenderingPipeline#renderState(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.jasig.portal.IUserInstance)
*/
public void renderState(HttpServletRequest req, HttpServletResponse res, IUserInstance userInstance) throws PortalException {
final IPerson person = userInstance.getPerson();
final LocaleManager localeManager = userInstance.getLocaleManager();
final IUserPreferencesManager uPreferencesManager = userInstance.getPreferencesManager();
final ChannelManager channelManager = userInstance.getChannelManager();
final Object renderingLock = userInstance.getRenderingLock();
UPFileSpec upfs = new UPFileSpec(req);
String rootNodeId = upfs.getMethodNodeId();
if (rootNodeId == null) {
rootNodeId = UPFileSpec.USER_LAYOUT_ROOT_NODE;
}
// see if a new root target has been specified
String newRootNodeId = req.getParameter("uP_detach_target");
// set optimistic uPElement value
UPFileSpec uPElement = new UPFileSpec(UPFileSpec.RENDER_METHOD, rootNodeId, null, null);
if (newRootNodeId != null) {
// set a new root
uPElement.setMethodNodeId(newRootNodeId);
}
channelManager.setUPElement(uPElement);
// proccess possible portlet action
final IPortletWindowId targetedPortletWindowId = this.portletRequestParameterManager.getTargetedPortletWindowId(req);
if (targetedPortletWindowId != null) {
final PortletUrl portletUrl = this.portletRequestParameterManager.getPortletRequestInfo(req, targetedPortletWindowId);
if (RequestType.ACTION.equals(portletUrl.getRequestType())) {
final IPortletEntity targetedPortletEntity = this.portletWindowRegistry.getParentPortletEntity(req, targetedPortletWindowId);
if (targetedPortletEntity != null) {
final String channelSubscribeId = targetedPortletEntity.getChannelSubscribeId();
final boolean actionExecuted = channelManager.doChannelAction(req, res, channelSubscribeId, false);
if (actionExecuted) {
// The action completed, return immediately
return;
}
// The action didn't execute, continue and try to render normally
}
}
}
// process possible worker dispatch
final boolean workerDispatched = this.processWorkerDispatchIfNecessary(req, res, uPreferencesManager, channelManager);
if (workerDispatched) {
//If a worker was dispatched to return immediately
return;
}
//Set a larger buffer to allow for explicit flushing
res.setBufferSize(16 * 1024);
final long startTime = System.currentTimeMillis();
synchronized (renderingLock) {
// This function does ALL the content gathering/presentation work.
// The following filter sequence is processed:
// userLayoutXML (in UserPreferencesManager)
// |
// incorporate StructureAttributes
// |
// Structure transformation
// + (buffering step)
// ChannelRendering Buffer
// |
// ThemeAttributesIncorporation Filter
// |
// Theme Transformatio
// |
// ChannelIncorporation filter
// |
// Serializer (XHTML/WML/HTML/etc.)
// |
// JspWriter
//
try {
// determine uPElement (optimistic prediction) --begin
// We need uPElement for ChannelManager.setReqNRes() call. That call will distribute uPElement
// to Privileged channels. We assume that Privileged channels are smart enough not to delete
// themselves in the detach mode !
// In general transformations will start at the userLayoutRoot node, unless
// we are rendering something in a detach mode.
IUserLayoutNodeDescription rElement = null;
// see if an old detach target exists in the servlet path
// give channels the current locale manager
channelManager.setLocaleManager(localeManager);
IUserLayoutManager ulm = uPreferencesManager.getUserLayoutManager();
// determine uPElement (optimistic prediction) --end
// set up the channel manager
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();
sst.setErrorListener(cErrListener);
Transformer tst = tsth.getTransformer();
tst.setErrorListener(cErrListener);
// pass resourcesDao into transformer
tst.setParameter(ResourcesXalanElements.SKIN_RESOURCESDAO_PARAMETER_NAME, resourcesElementsProvider);
tst.setParameter(ResourcesXalanElements.CURRENT_REQUEST, req);
// initialize ChannelRenderingBuffer and attach it downstream of the structure transformer
ChannelRenderingBuffer crb = new ChannelRenderingBuffer(channelManager, ccaching, req, res);
ssth.setResult(new SAXResult(crb));
// determine and set the stylesheet params
// prepare .uP element and detach flag to be passed to the stylesheets
// Including the context path in front of uPElement is necessary for phone.com browsers to work
sst.setParameter("baseActionURL", uPElement.getUPFile());
// construct idempotent version of the uPElement
UPFileSpec uPIdempotentElement = new UPFileSpec(uPElement);
sst.setParameter("baseIdempotentActionURL", uPElement.getUPFile());
Hashtable<String, String> supTable = userPreferences.getStructureStylesheetUserPreferences()
.getParameterValues();
for (Map.Entry<String, String> param : supTable.entrySet()) {
String pName = param.getKey();
String pValue = param.getValue();
if (log.isDebugEnabled())
log.debug("setting sparam \"" + pName + "\"=\"" + pValue
+ "\".");
sst.setParameter(pName, pValue);
}
// all the parameters are set up, fire up structure transformation
// filter to fill in channel/folder attributes for the "structure" transformation.
StructureAttributesIncorporationFilter saif = new StructureAttributesIncorporationFilter(ssth,
userPreferences.getStructureStylesheetUserPreferences());
// This is a debug statement that will print out XML incoming to the
// structure transformation to a log file serializer to a printstream
StringWriter dbwr1 = null;
OutputFormat outputFormat = null;
if (logXMLBeforeStructureTransformation && log.isDebugEnabled()) {
dbwr1 = new StringWriter();
outputFormat = new OutputFormat();
outputFormat.setIndenting(true);
XMLSerializer dbser1 = new XMLSerializer(dbwr1, outputFormat);
SAX2DuplicatingFilterImpl dupl1 = new SAX2DuplicatingFilterImpl(ssth, dbser1);
dupl1.setParent(saif);
}
// if operating in the detach mode, need wrap everything
// in a document node and a <layout_fragment> node
boolean detachMode = !rootNodeId.equals(UPFileSpec.USER_LAYOUT_ROOT_NODE);
if (detachMode) {
saif.startDocument();
saif.startElement("",
"layout_fragment",
"layout_fragment",
new org.xml.sax.helpers.AttributesImpl());
// emptyt.transform(new DOMSource(rElement),new SAXResult(new ChannelSAXStreamFilter((ContentHandler)saif)));
if (rElement == null) {
ulm.getUserLayout(new ChannelSAXStreamFilter((ContentHandler) saif));
}
else {
ulm.getUserLayout(rElement.getId(), new ChannelSAXStreamFilter((ContentHandler) saif));
}
saif.endElement("", "layout_fragment", "layout_fragment");
saif.endDocument();
}
else {
if (rElement == null) {
ulm.getUserLayout(saif);
}
else {
ulm.getUserLayout(rElement.getId(), saif);
}
// emptyt.transform(new DOMSource(rElement),new SAXResult((ContentHandler)saif));
}
// all channels should be rendering now
// Debug piece to print out the recorded pre-structure transformation XML
if (logXMLBeforeStructureTransformation && log.isDebugEnabled()) {
log.debug("XML incoming to the structure transformation :\n\n"
+ dbwr1.toString() + "\n\n");
}
// prepare for the theme transformation
// set up of the parameters
tst.setParameter("baseActionURL", uPElement.getUPFile());
tst.setParameter("baseIdempotentActionURL", uPIdempotentElement.getUPFile());
if (externalLoginUrl != null) {
tst.setParameter("EXTERNAL_LOGIN_URL", externalLoginUrl);
}
Hashtable<String, String> tupTable = userPreferences.getThemeStylesheetUserPreferences()
.getParameterValues();
for (Map.Entry<String, String> param : tupTable.entrySet()) {
String pName = param.getKey();
String pValue = param.getValue();
if (log.isDebugEnabled())
log.debug("setting tparam \"" + pName + "\"=\"" + pValue
+ "\".");
tst.setParameter(pName, pValue);
}
VersionsManager versionsManager = VersionsManager.getInstance();
Version[] versions = versionsManager.getVersions();
for (Version version : versions) {
String paramName = "version-" + version.getFname();
tst.setParameter(paramName, version.dottedTriple());
}
// the uP_productAndVersion stylesheet parameter is deprecated
// instead use the more generic "version-UP_VERSION" generated from the
// framework's functional name when all versions are pulled immediately
// above.
Version uPortalVersion = versionsManager.getVersion(IPermission.PORTAL_FRAMEWORK);
tst.setParameter("uP_productAndVersion", "uPortal " + uPortalVersion.dottedTriple());
final Locale[] locales = localeManager.getLocales();
if (locales != null && locales.length > 0 && locales[0] != null) {
tst.setParameter("USER_LANG", locales[0].toString().replace('_', '-'));
}
// initialize a filter to fill in channel attributes for the "theme" (second) transformation.
// attach it downstream of the channel rendering buffer
ThemeAttributesIncorporationFilter taif = new ThemeAttributesIncorporationFilter(
(XMLReader) crb, userPreferences.getThemeStylesheetUserPreferences());
// attach theme transformation downstream of the theme attribute incorporation filter
taif.setAllHandlers(tsth);
// This is a debug statement that will print out XML incoming to the
// theme transformation to a log file serializer to a printstream
StringWriter dbwr2 = null;
if (logXMLBeforeThemeTransformation && log.isDebugEnabled()) {
dbwr2 = new StringWriter();
XMLSerializer dbser2 = new XMLSerializer(dbwr2, outputFormat);
SAX2DuplicatingFilterImpl dupl2 = new SAX2DuplicatingFilterImpl(tsth, dbser2);
dupl2.setParent(taif);
}
if (CACHE_ENABLED && !ccaching) {
// record cache
// attach caching buffer downstream of the theme transformer
SAX2BufferImpl newCache = new SAX2BufferImpl();
tsth.setResult(new SAXResult(newCache));
// attach channel incorporation filter downstream of the caching buffer
cif.setParent(newCache);
systemCache.put(cacheKey, newCache);
newCache.setOutputAtDocumentEnd(true);
if (log.isDebugEnabled())
log.debug("recorded transformation cache with key \""
+ cacheKey + "\"");
}
else {
// attach channel incorporation filter downstream of the theme transformer
tsth.setResult(new SAXResult(cif));
}
// fire up theme transformation
crb.stopBuffering();
crb.outputBuffer();
crb.clearBuffer();
// Debug piece to print out the recorded pre-theme transformation XML
if (logXMLBeforeThemeTransformation && log.isDebugEnabled()) {
log.debug("XML incoming to the theme transformation :\n\n"
+ dbwr2.toString() + "\n\n");
}
if (CACHE_ENABLED && ccaching) {
// save character block cache
List<CacheEntry> cacheBlocks = cif.getCacheBlocks();
if(cacheBlocks == null) {
log
.error("CharacterCachingChannelIncorporationFilter returned invalid cache entries!");
}
else {
// record cache
systemCharacterCache.put(cacheKey, cacheBlocks);
if (log.isDebugEnabled()) {
log
.debug("recorded transformation character block cache with key \""
+ cacheKey + "\"");
log.debug("Printing transformation cache blocks:");
for (int i=0; i<cacheBlocks.size(); i++) {
CacheEntry ce = cacheBlocks.get(i);
if (ce.getCacheType().equals(CacheType.CHARACTERS)) {
log.debug("----------piece "+Integer.toString(i));
} else if (ce.getCacheType().equals(CacheType.CHANNEL_CONTENT)) {
log.debug("----------channel content entry "+Integer.toString(i));
}
DebugCachingSerializer dcs = new DebugCachingSerializer();
ce.replayCache(dcs, channelManager, req, res);
log.debug(dcs.getCache());
}
}
}
}
}
// signal the end of the rendering round
channelManager.finishedRenderingCycle();
}
catch (PortalException pe) {
throw pe;
}
catch (Exception e) {
throw new PortalException(e);
}
finally {
final long pageRenderTime = System.currentTimeMillis() - startTime;
lastRender = renderTimes.add(pageRenderTime);
//Get the user's profile
final UserProfile userProfile = uPreferencesManager.getCurrentProfile();
//Find the activeTab index
final UserPreferences userPreferences = uPreferencesManager.getUserPreferences();
final StructureStylesheetUserPreferences structureStylesheetUserPreferences = userPreferences.getStructureStylesheetUserPreferences();
final String activeTab = structureStylesheetUserPreferences.getParameterValue("activeTab");
final int activeTabIndex = org.apache.commons.lang.math.NumberUtils.toInt(activeTab, 1);
//Get the user's layout and find the targeted folder (tab)
final IUserLayoutManager userLayoutManager = uPreferencesManager.getUserLayoutManager();
final IUserLayoutFolderDescription targetedNode = this.getActiveTab(userLayoutManager, activeTabIndex);
//Create and publish the event.
final PageRenderTimePortalEvent pageRenderTimePortalEvent = new PageRenderTimePortalEvent(this, person, userProfile, targetedNode, pageRenderTime);
this.applicationEventPublisher.publishEvent(pageRenderTimePortalEvent);