/*
* 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.components.treeprocessor;
import java.util.Map;
import org.apache.avalon.excalibur.component.RoleManageable;
import org.apache.avalon.excalibur.component.RoleManager;
import org.apache.avalon.framework.activity.Disposable;
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.component.Recomposable;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
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.logger.AbstractLogEnabled;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.Processor;
import org.apache.cocoon.util.Settings;
import org.apache.cocoon.util.SettingsHelper;
import org.apache.cocoon.components.CocoonComponentManager;
import org.apache.cocoon.components.ExtendedComponentSelector;
import org.apache.cocoon.components.LifecycleHelper;
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.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
/**
* Interpreted tree-traversal implementation of a pipeline assembly language.
*
* @author <a href="mailto:sylvain@apache.org">Sylvain Wallez</a>
* @version CVS $Id$
*/
public class TreeProcessor
extends AbstractLogEnabled
implements ThreadSafe,
Processor,
Composable,
Configurable,
RoleManageable,
Contextualizable,
Disposable {
public static final String COCOON_REDIRECT_ATTR = "sitemap:cocoon-redirect";
private static final String XCONF_URL =
"resource://org/apache/cocoon/components/treeprocessor/treeprocessor-builtins.xml";
/** The parent TreeProcessor, if any */
protected TreeProcessor parent;
/** The context */
protected Context context;
/** The component manager */
protected ComponentManager manager;
/** The role manager */
protected RoleManager roleManager;
/** Selector of TreeBuilders, the hint is the language name */
protected ExtendedComponentSelector builderSelector;
/** Last modification time */
protected long lastModified = 0;
/** The source of the tree definition */
protected DelayedRefreshSourceWrapper source;
/** Delay for <code>sourceLastModified</code>. */
protected long lastModifiedDelay;
/** The current language configuration */
protected Configuration currentLanguage;
/** Check for reload? */
protected boolean checkReload;
/** The source resolver */
protected SourceResolver resolver;
/** The actual processor (package-private as needs to be accessed by ConcreteTreeProcessor) */
ConcreteTreeProcessor concreteProcessor;
/**
* Create a TreeProcessor.
*/
public TreeProcessor() {
this.checkReload = true;
this.lastModifiedDelay = 1000;
}
/**
* Create a child processor for a given language
*/
protected TreeProcessor(TreeProcessor parent, ComponentManager manager) {
this.parent = parent;
// Copy all that can be copied from the parent
this.enableLogging(parent.getLogger());
this.context = parent.context;
this.roleManager = parent.roleManager;
this.builderSelector = parent.builderSelector;
this.checkReload = parent.checkReload;
this.lastModifiedDelay = parent.lastModifiedDelay;
// We have our own CM
this.manager = manager;
}
/**
* Create a new child of this processor (used for mounting submaps).
*
* @param manager the component manager to be used by the child processor.
* @return a new child processor.
*/
public TreeProcessor createChildProcessor(ComponentManager manager,
String actualSource,
boolean checkReload)
throws Exception {
// Note: lifecycle methods aren't called, since this constructors copies all
// that can be copied from the parent (see above)
TreeProcessor child = new TreeProcessor(this, manager);
child.checkReload = checkReload;
child.resolver = (SourceResolver)manager.lookup(SourceResolver.ROLE);
child.source = new DelayedRefreshSourceWrapper(child.resolver.resolveURI(actualSource), this.lastModifiedDelay);
return child;
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.context.Contextualizable#contextualize(org.apache.avalon.framework.context.Context)
*/
public void contextualize(Context context) throws ContextException {
this.context = context;
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.component.Composable#compose(org.apache.avalon.framework.component.ComponentManager)
*/
public void compose(ComponentManager manager) throws ComponentException {
this.manager = manager;
this.resolver = (SourceResolver)this.manager.lookup(SourceResolver.ROLE);
}
/* (non-Javadoc)
* @see org.apache.avalon.excalibur.component.RoleManageable#setRoleManager(org.apache.avalon.excalibur.component.RoleManager)
*/
public void setRoleManager(RoleManager rm) {
this.roleManager = rm;
}
/*
<processor>
<reload delay="10"/>
<language>...</language>
</processor>
*/
public void configure(Configuration config)
throws ConfigurationException {
this.checkReload = config.getAttributeAsBoolean("check-reload", true);
// Obtain the configuration file, or use the XCONF_URL if none
// is defined
String xconfURL = config.getAttribute("config", XCONF_URL);
// Reload check delay. Default is 1 second.
this.lastModifiedDelay = config.getChild("reload").getAttributeAsLong("delay", 1000L);
String fileName = config.getAttribute("file", "sitemap.xmap");
try {
this.source = new DelayedRefreshSourceWrapper(this.resolver.resolveURI(fileName), this.lastModifiedDelay);
} catch (Exception e) {
throw new ConfigurationException("Cannot resolve " + fileName, e);
}
// Read the builtin languages definition file
Configuration builtin;
try {
Source source = this.resolver.resolveURI(xconfURL);
try {
Settings settings = SettingsHelper.getSettings(this.context);
SAXConfigurationHandler handler = new PropertyAwareSAXConfigurationHandler(settings, this.getLogger());
SourceUtil.toSAX( this.manager, source, null, handler);
builtin = handler.getConfiguration();
} finally {
this.resolver.release(source);
}
} catch(Exception e) {
String msg = "Error while reading " + xconfURL + ": " + e.getMessage();
throw new ConfigurationException(msg, e);
}
// Create a selector for tree builders of all languages
this.builderSelector = new ExtendedComponentSelector(Thread.currentThread().getContextClassLoader());
try {
LifecycleHelper.setupComponent(this.builderSelector,
this.getLogger(),
this.context,
this.manager,
this.roleManager,
builtin);
} catch (ConfigurationException e) {
throw e;
} catch (Exception e) {
throw new ConfigurationException("Could not setup builder selector", e);
}
}
/**
* Process the given <code>Environment</code> producing the output.
* @return If the processing is successfull <code>true</code> is returned.
* If not match is found in the sitemap <code>false</code>
* is returned.
* @throws org.apache.cocoon.ResourceNotFoundException If a sitemap component tries
* to access a resource which can not
* be found, e.g. the generator
* ConnectionResetException If the connection was reset
*/
public boolean process(Environment environment) throws Exception {
this.setupConcreteProcessor(environment);
return this.concreteProcessor.process(environment);
}
/**
* Process the given <code>Environment</code> to assemble
* a <code>ProcessingPipeline</code>.
* @since 2.1
*/
public ProcessingPipeline buildPipeline(Environment environment)
throws Exception {
this.setupConcreteProcessor(environment);
return this.concreteProcessor.buildPipeline(environment);
}
/* (non-Javadoc)
* @see org.apache.cocoon.Processor#getRootProcessor()
*/
public Processor getRootProcessor() {
TreeProcessor result = this;
while(result.parent != null) {
result = result.parent;
}
return result;
}
/**
* Set the sitemap component configurations
*/
public void setComponentConfigurations(Configuration componentConfigurations) {
this.concreteProcessor.setComponentConfigurations(componentConfigurations);
}
/* (non-Javadoc)
* @see org.apache.cocoon.Processor#getComponentConfigurations()
*/
public Map getComponentConfigurations() {
return this.concreteProcessor.getComponentConfigurations();
}
private void setupConcreteProcessor(Environment env) throws Exception {
if (this.parent == null) {
// Ensure root sitemap uses the correct context, even if not located in the webapp context
env.changeContext("", this.source.getURI());
}
// check for sitemap changes
if (this.concreteProcessor == null ||
(this.checkReload && this.source.getLastModified() != this.lastModified)) {
this.buildConcreteProcessor(env);
}
}
private synchronized void buildConcreteProcessor(Environment env) throws Exception {
// Now that we entered the synchronized area, recheck what's already
// been checked in process().
if (this.concreteProcessor != null && this.source.getLastModified() == this.lastModified) {
// Nothing changed
return;
}
long startTime = System.currentTimeMillis();
// Dispose the old processor, if any
if (this.concreteProcessor != null) {
this.concreteProcessor.markForDisposal();
}
// Get a builder
TreeBuilder builder = (TreeBuilder)this.builderSelector.select("sitemap");
ConcreteTreeProcessor newProcessor = new ConcreteTreeProcessor(this);
long newLastModified;
this.setupLogger(newProcessor);
//FIXME (SW): why do we need to enterProcessor here?
CocoonComponentManager.enterEnvironment(env, this.manager, this);
try {
if (builder instanceof Recomposable) {
((Recomposable)builder).recompose(this.manager);
}
builder.setProcessor(newProcessor);
newLastModified = this.source.getLastModified();
ProcessingNode root = builder.build(this.source);
newProcessor.setProcessorData(builder.getSitemapComponentManager(), root, builder.getDisposableNodes());
} finally {
CocoonComponentManager.leaveEnvironment();
this.builderSelector.release(builder);
}
if (this.getLogger().isDebugEnabled()) {
double time = (this.lastModified - startTime) / 1000.0;
this.getLogger().debug("TreeProcessor built in " + time + " secs from " + this.source.getURI());
}
// Switch to the new processor (ensure it's never temporarily null)
this.concreteProcessor = newProcessor;
this.lastModified = newLastModified;
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.activity.Disposable#dispose()
*/
public void dispose() {
// Dispose the concrete processor. No need to check for existing requests, as there
// are none when a TreeProcessor is disposed.
ContainerUtil.dispose(this.concreteProcessor);
this.concreteProcessor = null;
if (this.manager != null) {
if (this.source != null) {
this.resolver.release(this.source.getSource());
this.source = null;
}
if (this.parent == null) {
// root processor : dispose the builder selector
this.builderSelector.dispose();
this.builderSelector = null;
}
// Release resolver looked up in compose()
this.manager.release((Component)this.resolver);
this.resolver = null;
this.manager = null;
}
}
public String toString() {
return "TreeProcessor - " + (this.source == null ? "[unknown location]" : this.source.getURI());
}
}