/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.cocoon;
import org.apache.avalon.excalibur.component.ComponentProxyGenerator;
import org.apache.avalon.excalibur.component.DefaultRoleManager;
import org.apache.avalon.excalibur.component.ExcaliburComponentManager;
import org.apache.avalon.excalibur.logger.LoggerManager;
import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.component.ComponentManager;
import org.apache.avalon.framework.component.Composable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.configuration.SAXConfigurationHandler;
import org.apache.avalon.framework.container.ContainerUtil;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.context.DefaultContext;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.components.CocoonComponentManager;
import org.apache.cocoon.components.ComponentContext;
import org.apache.cocoon.components.PropertyAwareSAXConfigurationHandler;
import org.apache.cocoon.components.pipeline.ProcessingPipeline;
import org.apache.cocoon.components.source.SourceUtil;
import org.apache.cocoon.components.source.impl.DelayedRefreshSourceWrapper;
import org.apache.cocoon.environment.Environment;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.Session;
import org.apache.cocoon.util.ClassUtils;
import org.apache.cocoon.util.Deprecation;
import org.apache.cocoon.util.SimpleSourceResolver;
import org.apache.cocoon.util.Settings;
import org.apache.cocoon.util.SettingsHelper;
import org.apache.cocoon.util.location.Location;
import org.apache.cocoon.util.location.LocationImpl;
import org.apache.cocoon.util.location.LocationUtils;
import org.apache.commons.lang.SystemUtils;
import org.apache.excalibur.instrument.InstrumentManageable;
import org.apache.excalibur.instrument.InstrumentManager;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.apache.excalibur.source.impl.URLSource;
import org.apache.excalibur.xml.impl.XercesParser;
import org.apache.excalibur.xml.sax.SAXParser;
import org.xml.sax.InputSource;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Map;
import java.util.ConcurrentModificationException;
/**
* The Cocoon Object is the main Kernel for the entire Cocoon system.
*
* @author <a href="mailto:pier@apache.org">Pierpaolo Fumagalli</a> (Apache Software Foundation)
* @author <a href="mailto:stefano@apache.org">Stefano Mazzocchi</a>
* @author <a href="mailto:leo.sutic@inspireinfrastructure.com">Leo Sutic</a>
* @version CVS $Id$
*/
public class Cocoon
extends AbstractLogEnabled
implements ThreadSafe,
Component,
Initializable,
Disposable,
Modifiable,
Processor,
Contextualizable,
Composable,
InstrumentManageable {
// Register the location finder for Avalon configuration objects and exceptions
// and keep a strong reference to it.
private static final LocationUtils.LocationFinder LOCATION_FINDER = new LocationUtils.LocationFinder() {
public Location getLocation(Object obj, String description) {
if (obj instanceof Configuration) {
Configuration config = (Configuration) obj;
String locString = config.getLocation();
Location result = LocationUtils.parse(locString);
if (LocationUtils.isKnown(result)) {
// Add description
StringBuffer desc = new StringBuffer().append('<');
// Unfortunately Configuration.getPrefix() is not public
try {
if (config.getNamespace().startsWith("http://apache.org/cocoon/sitemap/")) {
desc.append("map:");
}
} catch (ConfigurationException e) {
// no namespace: ignore
}
desc.append(config.getName()).append('>');
return new LocationImpl(desc.toString(), result);
} else {
return result;
}
}
if (obj instanceof Exception) {
// Many exceptions in Cocoon have a message like "blah blah at file://foo/bar.xml:12:1"
String msg = ((Exception)obj).getMessage();
if (msg == null) {
return null;
}
int pos = msg.lastIndexOf(" at ");
if (pos != -1) {
return LocationUtils.parse(msg.substring(pos + 4));
} else {
// Will try other finders
return null;
}
}
// Try next finders.
return null;
}
};
static {
LocationUtils.addFinder(LOCATION_FINDER);
}
static Cocoon instance;
/** The root Cocoon logger */
private Logger rootLogger;
/** The application context */
private Context context;
/** The configuration file */
private Source configurationFile;
/** The configuration tree */
private Configuration configuration;
/** The logger manager */
private LoggerManager loggerManager;
/** The instrument manager */
private InstrumentManager instrumentManager;
/** The classpath (null if not available) */
private String classpath;
/** The working directory (null if not available) */
private File workDir;
/** The component manager. */
private ExcaliburComponentManager componentManager;
/** The parent component manager. */
private ComponentManager parentComponentManager;
/** Flag for disposed or not */
private boolean disposed;
/** Active request count */
private volatile int activeRequestCount;
/** The Processor if it is ThreadSafe */
private Processor threadSafeProcessor;
/** The source resolver */
protected SourceResolver sourceResolver;
/** An optional Avalon Component that is called before and after processing all requests. */
protected RequestListener requestListener;
/**
* Creates a new <code>Cocoon</code> instance.
*
* @exception ConfigurationException if an error occurs
*/
public Cocoon() throws ConfigurationException {
// Set the system properties needed by Xalan2.
this.setSystemProperties();
// HACK: Provide a way to share an instance of Cocoon object between
// several servlets/portlets.
Cocoon.instance = this;
}
public void enableLogging(Logger logger) {
this.rootLogger = logger;
super.enableLogging(logger.getChildLogger("cocoon"));
}
/**
* Get the parent component manager. For purposes of
* avoiding extra method calls, the manager parameter may be null.
*
* @param manager the parent component manager. May be <code>null</code>
*/
public void compose(ComponentManager manager)
throws ComponentException {
this.parentComponentManager = manager;
}
/**
* Describe <code>contextualize</code> method here.
*
* @param context a <code>Context</code> value
* @exception ContextException if an error occurs
*/
public void contextualize(Context context) throws ContextException {
if (this.context == null) {
this.context = new ComponentContext(context);
SettingsHelper.createSettings((DefaultContext)this.context, this.getLogger());
((DefaultContext) this.context).makeReadOnly();
this.classpath = (String)context.get(Constants.CONTEXT_CLASSPATH);
this.workDir = (File)context.get(Constants.CONTEXT_WORK_DIR);
try {
// FIXME: add a configuration option for the refresh delay.
// for now, hard-coded to 1 second.
URLSource urlSource = new URLSource();
urlSource.init((URL) context.get(Constants.CONTEXT_CONFIG_URL), null);
this.configurationFile = new DelayedRefreshSourceWrapper(urlSource,
1000L);
} catch (IOException e) {
throw new ContextException("Could not open configuration file.", e);
} catch (Exception e) {
throw new ContextException("contextualize(..) Exception", e);
}
}
}
/**
* The <code>setLoggerManager</code> method will get a <code>LoggerManager</code>
* for further use.
*
* @param loggerManager a <code>LoggerManager</code> value
*/
public void setLoggerManager(LoggerManager loggerManager) {
this.loggerManager = loggerManager;
Deprecation.setLogger(this.loggerManager.getLoggerForCategory("deprecation"));
}
/**
* Set the <code>InstrumentManager</code> for this Cocoon instance.
*
* @param manager an <code>InstrumentManager</code> instance
*/
public void setInstrumentManager(final InstrumentManager manager) {
this.instrumentManager = manager;
}
/**
* The <code>initialize</code> method
*
* @exception Exception if an error occurs
*/
public void initialize() throws Exception {
if (this.parentComponentManager != null) {
this.componentManager = new CocoonComponentManager(this.parentComponentManager,
(ClassLoader) this.context.get(Constants.CONTEXT_CLASS_LOADER));
} else {
this.componentManager = new CocoonComponentManager((ClassLoader) this.context.get(Constants.CONTEXT_CLASS_LOADER));
}
ContainerUtil.enableLogging(this.componentManager, this.rootLogger.getChildLogger("manager"));
ContainerUtil.contextualize(this.componentManager, this.context);
this.componentManager.setInstrumentManager(this.instrumentManager);
this.getLogger().debug("New Cocoon object.");
// Log the System Properties.
this.dumpSystemProperties();
// Setup the default parser, for parsing configuration.
// If one need to use a different parser, set the given system property
// first check for deprecated property to be compatible:
String parser = getSystemProperty(Constants.DEPRECATED_PARSER_PROPERTY, Constants.DEFAULT_PARSER);
if (!Constants.DEFAULT_PARSER.equals(parser)) {
this.getLogger().warn("Deprecated property " +
Constants.DEPRECATED_PARSER_PROPERTY + " is used. Please use " +
Constants.PARSER_PROPERTY + " instead.");
if ("org.apache.cocoon.components.parser.XercesParser".equals(parser)) {
parser = XercesParser.class.getName();
} else {
this.getLogger().warn("Unknown value for deprecated property: " +
Constants.DEPRECATED_PARSER_PROPERTY + ", value: " + parser +
". If you experience problems during startup, check the parser configuration section of the documentation.");
}
} else {
parser = getSystemProperty(Constants.PARSER_PROPERTY, Constants.DEFAULT_PARSER);
}
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Parser: " + parser);
this.getLogger().debug("Classpath: " + this.classpath);
this.getLogger().debug("Work directory: " + this.workDir.getCanonicalPath());
}
ExcaliburComponentManager startupManager = new ExcaliburComponentManager((ClassLoader) this.context.get(Constants.CONTEXT_CLASS_LOADER));
ContainerUtil.enableLogging(startupManager, this.rootLogger.getChildLogger("startup"));
ContainerUtil.contextualize(startupManager, this.context);
startupManager.setLoggerManager(this.loggerManager);
try {
startupManager.addComponent(SAXParser.ROLE,
ClassUtils.loadClass(parser),
new DefaultConfiguration("", "empty"));
} catch (Exception e) {
throw new ConfigurationException("Could not load parser " + parser, e);
}
ContainerUtil.initialize(startupManager);
this.configure(startupManager);
ContainerUtil.dispose(startupManager);
startupManager = null;
// add the logger manager to the component locator
final ComponentProxyGenerator proxyGenerator = new ComponentProxyGenerator();
final Component loggerManagerProxy = proxyGenerator.getProxy(LoggerManager.class.getName(),this.loggerManager);
this.componentManager.addComponentInstance(LoggerManager.ROLE,loggerManagerProxy);
ContainerUtil.initialize(this.componentManager);
// Get the Processor and keep it if it's ThreadSafe
Processor processor = (Processor)this.componentManager.lookup(Processor.ROLE);
if (processor instanceof ThreadSafe) {
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Processor of class " + processor.getClass().getName() +
" is ThreadSafe");
}
this.threadSafeProcessor = processor;
} else {
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Processor of class " + processor.getClass().getName() +
" is NOT ThreadSafe -- will be looked up at each request");
}
this.componentManager.release(processor);
}
this.sourceResolver = (SourceResolver)this.componentManager.lookup(SourceResolver.ROLE);
if (this.componentManager.hasComponent(RequestListener.ROLE)){
this.requestListener = (RequestListener) this.componentManager.lookup(RequestListener.ROLE);
}
}
/** Dump System Properties */
private void dumpSystemProperties() {
if (this.getLogger().isDebugEnabled()) {
try {
Enumeration e = System.getProperties().propertyNames();
this.getLogger().debug("===== System Properties Start =====");
for (; e.hasMoreElements();) {
String key = (String) e.nextElement();
this.getLogger().debug(key + "=" + System.getProperty(key));
}
this.getLogger().debug("===== System Properties End =====");
} catch (SecurityException se) {
// Ignore Exceptions.
}
}
}
/**
* Configure this <code>Cocoon</code> instance.
*
* @param startupManager an <code>ExcaliburComponentManager</code> value
* @exception ConfigurationException if an error occurs
* @exception ContextException if an error occurs
*/
public void configure(ExcaliburComponentManager startupManager) throws ConfigurationException, ContextException {
SAXParser p = null;
Settings settings = SettingsHelper.getSettings(this.context);
Configuration roles = null;
try {
p = (SAXParser) startupManager.lookup(SAXParser.ROLE);
SAXConfigurationHandler b = new PropertyAwareSAXConfigurationHandler(settings, this.getLogger());
URL url = ClassUtils.getResource("org/apache/cocoon/cocoon.roles");
InputSource is = new InputSource(url.openStream());
is.setSystemId(url.toString());
p.parse(is, b);
roles = b.getConfiguration();
} catch (Exception e) {
throw new ConfigurationException("Error trying to load configurations", e);
} finally {
if (p != null) startupManager.release((Component) p);
}
DefaultRoleManager drm = new DefaultRoleManager();
ContainerUtil.enableLogging(drm, this.rootLogger.getChildLogger("roles"));
ContainerUtil.configure(drm, roles);
roles = null;
try {
this.configurationFile.refresh();
p = (SAXParser)startupManager.lookup(SAXParser.ROLE);
SAXConfigurationHandler b = new PropertyAwareSAXConfigurationHandler(settings, this.getLogger());
InputSource is = SourceUtil.getInputSource(this.configurationFile);
p.parse(is, b);
this.configuration = b.getConfiguration();
} catch (Exception e) {
throw new ConfigurationException("Error trying to load configurations",e);
} finally {
if (p != null) startupManager.release((Component)p);
}
Configuration conf = this.configuration;
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Root configuration: " + conf.getName());
}
if (!"cocoon".equals(conf.getName())) {
throw new ConfigurationException("Invalid configuration file\n" + conf.toString());
}
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Configuration version: " + conf.getAttribute("version"));
}
if (!Constants.CONF_VERSION.equals(conf.getAttribute("version"))) {
throw new ConfigurationException("Invalid configuration schema version. Must be '" + Constants.CONF_VERSION + "'.");
}
String userRoles = conf.getAttribute("user-roles", "");
if (!"".equals(userRoles)) {
try {
p = (SAXParser)startupManager.lookup(SAXParser.ROLE);
SAXConfigurationHandler b = new PropertyAwareSAXConfigurationHandler(settings, this.getLogger());
org.apache.cocoon.environment.Context context =
(org.apache.cocoon.environment.Context) this.context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
URL url = context.getResource(userRoles);
if (url == null) {
throw new ConfigurationException("User-roles configuration '"+userRoles+"' cannot be found.");
}
InputSource is = new InputSource(new BufferedInputStream(url.openStream()));
is.setSystemId(url.toString());
p.parse(is, b);
roles = b.getConfiguration();
} catch (Exception e) {
throw new ConfigurationException("Error trying to load user-roles configuration", e);
} finally {
startupManager.release((Component)p);
}
DefaultRoleManager urm = new DefaultRoleManager(drm);
ContainerUtil.enableLogging(urm, this.rootLogger.getChildLogger("roles").getChildLogger("user"));
ContainerUtil.configure(urm, roles);
roles = null;
drm = urm;
}
this.componentManager.setRoleManager(drm);
this.componentManager.setLoggerManager(this.loggerManager);
this.getLogger().debug("Setting up components...");
ContainerUtil.configure(this.componentManager, conf);
}
/**
* Queries the class to estimate its ergodic period termination.
*
* @param date a <code>long</code> value
* @return a <code>boolean</code> value
*/
public boolean modifiedSince(long date) {
return date < this.configurationFile.getLastModified();
}
/**
* Helper method to retrieve system property.
* Returns default value if SecurityException is caught.
*/
public static String getSystemProperty(String property, String value) {
try {
return System.getProperty(property, value);
} catch (SecurityException e) {
System.err.println("Caught a SecurityException reading the system property '" + property + "';" +
" Cocoon will default to '" + value + "' value.");
return value;
}
}
/**
* Sets required system properties.
*/
protected void setSystemProperties() {
try {
// FIXME We shouldn't have to specify the SAXParser...
// This is needed by Xalan2, it is used by org.xml.sax.helpers.XMLReaderFactory
// to locate the SAX2 driver.
if (getSystemProperty("org.xml.sax.driver", null) == null) {
System.setProperty("org.xml.sax.driver", "org.apache.xerces.parsers.SAXParser");
}
} catch (SecurityException e) {
// Ignore security exceptions
System.out.println("Caught a SecurityException writing the system property: " + e);
}
try {
// FIXME We shouldn't have to specify these. Needed to override jaxp implementation of weblogic.
if (getSystemProperty("javax.xml.parsers.DocumentBuilderFactory", "").startsWith("weblogic")) {
System.setProperty("javax.xml.parsers.DocumentBuilderFactory", "org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");
System.setProperty("javax.xml.parsers.SAXParserFactory","org.apache.xerces.jaxp.SAXParserFactoryImpl");
}
} catch (SecurityException e) {
// Ignore security exceptions
System.out.println("Caught a SecurityException writing the system property: " + e);
}
}
/**
* Dispose this instance
*/
public void dispose() {
if (this.componentManager != null) {
if (this.requestListener != null) {
this.componentManager.release(this.requestListener);
}
this.componentManager.release(this.threadSafeProcessor);
this.threadSafeProcessor = null;
this.componentManager.release((Component)this.sourceResolver);
this.sourceResolver = null;
ContainerUtil.dispose(this.componentManager);
this.componentManager = null;
}
this.context = null;
if (Cocoon.instance == this) {
Cocoon.instance = null;
}
this.disposed = true;
}
/**
* Log debug information about the current environment.
*
* @param environment an <code>Environment</code> value
*/
protected void debug(Environment environment, boolean internal) {
String lineSeparator = SystemUtils.LINE_SEPARATOR;
Map objectModel = environment.getObjectModel();
Request request = ObjectModelHelper.getRequest(objectModel);
Session session = request.getSession(false);
StringBuffer msg = new StringBuffer(2048);
msg.append("DEBUGGING INFORMATION:").append(lineSeparator);
if (internal) {
msg.append("INTERNAL ");
}
msg.append("REQUEST: ").append(request.getRequestURI()).append(lineSeparator).append(lineSeparator);
msg.append("CONTEXT PATH: ").append(request.getContextPath()).append(lineSeparator);
msg.append("SERVLET PATH: ").append(request.getServletPath()).append(lineSeparator);
msg.append("PATH INFO: ").append(request.getPathInfo()).append(lineSeparator).append(lineSeparator);
msg.append("REMOTE HOST: ").append(request.getRemoteHost()).append(lineSeparator);
msg.append("REMOTE ADDRESS: ").append(request.getRemoteAddr()).append(lineSeparator);
msg.append("REMOTE USER: ").append(request.getRemoteUser()).append(lineSeparator);
msg.append("REQUEST SESSION ID: ").append(request.getRequestedSessionId()).append(lineSeparator);
msg.append("REQUEST PREFERRED LOCALE: ").append(request.getLocale().toString()).append(lineSeparator);
msg.append("SERVER HOST: ").append(request.getServerName()).append(lineSeparator);
msg.append("SERVER PORT: ").append(request.getServerPort()).append(lineSeparator).append(lineSeparator);
msg.append("METHOD: ").append(request.getMethod()).append(lineSeparator);
msg.append("CONTENT LENGTH: ").append(request.getContentLength()).append(lineSeparator);
msg.append("PROTOCOL: ").append(request.getProtocol()).append(lineSeparator);
msg.append("SCHEME: ").append(request.getScheme()).append(lineSeparator);
msg.append("AUTH TYPE: ").append(request.getAuthType()).append(lineSeparator).append(lineSeparator);
msg.append("CURRENT ACTIVE REQUESTS: ").append(this.activeRequestCount).append(lineSeparator);
// log all of the request parameters
Enumeration e = request.getParameterNames();
msg.append("REQUEST PARAMETERS:").append(lineSeparator).append(lineSeparator);
while (e.hasMoreElements()) {
String p = (String) e.nextElement();
msg.append("PARAM: '").append(p).append("' ")
.append("VALUES: '");
String[] params = request.getParameterValues(p);
for (int i = 0; i < params.length; i++) {
msg.append("[" + params[i] + "]");
if (i != (params.length - 1)) {
msg.append(", ");
}
}
msg.append("'").append(lineSeparator);
}
// log all of the header parameters
Enumeration e2 = request.getHeaderNames();
msg.append("HEADER PARAMETERS:").append(lineSeparator).append(lineSeparator);
while (e2.hasMoreElements()) {
String p = (String) e2.nextElement();
msg.append("PARAM: '").append(p).append("' ")
.append("VALUES: '");
Enumeration e3 = request.getHeaders(p);
while (e3.hasMoreElements()) {
msg.append("[" + e3.nextElement() + "]");
if (e3.hasMoreElements()) {
msg.append(", ");
}
}
msg.append("'").append(lineSeparator);
}
msg.append(lineSeparator).append("SESSION ATTRIBUTES:").append(lineSeparator).append(lineSeparator);
// log all of the session attributes
if (session != null) {
StringBuffer buffer = new StringBuffer("");
int count = -1;
while (count <= 0) {
// Fix bug #12139: Session can be modified while still
// being enumerated here
try {
e = session.getAttributeNames();
while (e.hasMoreElements()) {
String p = (String) e.nextElement();
buffer.append("PARAM: '").append(p).append("' ")
.append("VALUE: '").append(session.getAttribute(p)).append("'")
.append(lineSeparator);
}
break;
} catch (ConcurrentModificationException ex) {
buffer = new StringBuffer("");
++count;
}
}
msg.append(buffer.toString());
}
this.getLogger().debug(msg.toString());
}
/**
* Process the given <code>Environment</code> to produce the output.
*
* @param environment an <code>Environment</code> value
* @return a <code>boolean</code> value
* @exception Exception if an error occurs
*/
public boolean process(Environment environment)
throws Exception {
if (this.disposed) {
throw new IllegalStateException("You cannot process a Disposed Cocoon engine.");
}
Object key = CocoonComponentManager.startProcessing(environment);
final int environmentDepth = CocoonComponentManager.markEnvironment();
CocoonComponentManager.enterEnvironment(environment,
this.componentManager,
this);
try {
boolean result;
if (this.getLogger().isDebugEnabled()) {
++this.activeRequestCount;
this.debug(environment, false);
}
if (this.requestListener != null) {
try {
this.requestListener.onRequestStart(environment);
} catch (Exception e) {
this.getLogger().error("Error encountered monitoring request start: " + e.getMessage());
}
}
if (this.threadSafeProcessor != null) {
result = this.threadSafeProcessor.process(environment);
if (this.requestListener != null) {
try {
this.requestListener.onRequestEnd(environment);
} catch (Exception e) {
this.getLogger().error("Error encountered monitoring request start: " + e.getMessage());
}
}
} else {
Processor processor = (Processor)this.componentManager.lookup(Processor.ROLE);
try {
result = processor.process(environment);
if (this.requestListener != null) {
try {
this.requestListener.onRequestEnd(environment);
} catch (Exception e) {
this.getLogger().error("Error encountered monitoring request start: " + e.getMessage());
}
}
} finally {
this.componentManager.release(processor);
}
}
// commit response on success
environment.commitResponse();
return result;
} catch (Exception any) {
if (this.requestListener != null) {
try {
this.requestListener.onRequestException(environment, any);
} catch (Exception e) {
this.getLogger().error("Error encountered monitoring request start: " + e.getMessage());
}
}
// reset response on error
environment.tryResetResponse();
throw any;
} finally {
CocoonComponentManager.leaveEnvironment();
CocoonComponentManager.endProcessing(environment, key);
if (this.getLogger().isDebugEnabled()) {
--this.activeRequestCount;
}
// TODO (CZ): This is only for testing - remove it later on
CocoonComponentManager.checkEnvironment(environmentDepth, this.getLogger());
}
}
/**
* Process the given <code>Environment</code> to assemble
* a <code>ProcessingPipeline</code>.
* @since 2.1
*/
public ProcessingPipeline buildPipeline(Environment environment)
throws Exception {
if (this.disposed) {
throw new IllegalStateException("You cannot process a Disposed Cocoon engine.");
}
try {
if (this.getLogger().isDebugEnabled()) {
++this.activeRequestCount;
this.debug(environment, true);
}
if (this.threadSafeProcessor != null) {
return this.threadSafeProcessor.buildPipeline(environment);
} else {
Processor processor = (Processor)this.componentManager.lookup(Processor.ROLE);
try {
return processor.buildPipeline(environment);
} finally {
this.componentManager.release(processor);
}
}
} finally {
if (this.getLogger().isDebugEnabled()) {
--this.activeRequestCount;
}
}
}
/**
* Get the sitemap component configurations
* @since 2.1
*/
public Map getComponentConfigurations() {
return Collections.EMPTY_MAP;
}
/**
* Return this (Cocoon is always at the root of the processing chain).
* @since 2.1.1
*/
public Processor getRootProcessor() {
return this;
}
/**
* Accessor for active request count
*/
public int getActiveRequestCount() {
return this.activeRequestCount;
}
public ExcaliburComponentManager getComponentManager() {
return this.componentManager;
}
/**
* Create a simple source resolver.
*/
protected SourceResolver createSourceResolver(Logger logger) throws ContextException {
// Create our own resolver
final SimpleSourceResolver resolver = new SimpleSourceResolver();
resolver.enableLogging(logger);
try {
resolver.contextualize(this.context);
} catch (ContextException ce) {
throw new ContextException(
"Cannot setup source resolver.", ce);
}
return resolver;
}
}