/*
* 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.pipeline.impl;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.parameters.ParameterException;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.caching.CachedResponse;
import org.apache.cocoon.caching.CachingOutputStream;
import org.apache.cocoon.caching.ComponentCacheKey;
import org.apache.cocoon.components.sax.XMLDeserializer;
import org.apache.cocoon.components.sax.XMLSerializer;
import org.apache.cocoon.components.sax.XMLTeePipe;
import org.apache.cocoon.environment.Environment;
import org.apache.cocoon.xml.XMLConsumer;
import org.apache.cocoon.xml.XMLProducer;
import org.apache.commons.lang.BooleanUtils;
import org.apache.excalibur.source.SourceValidity;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
/**
* The caching-point pipeline implements an extended caching algorithm which is
* of particular benefit for use with those pipelines that utilise cocoon-views
* and/or provide drill-down functionality.
*
* @since 2.1
* @author <a href="mailto:Michael.Melhem@managesoft.com">Michael Melhem</a>
* @version CVS $Id$
*/
public class CachingPointProcessingPipeline
extends AbstractCachingProcessingPipeline {
protected ArrayList isCachePoint = new ArrayList();
protected ArrayList xmlSerializerArray = new ArrayList();
protected boolean nextIsCachePoint = false;
protected String autoCachingPointSwitch;
protected boolean autoCachingPoint = true;
/**
* The <code>CachingPointProcessingPipeline</code> is configurable.
*
* <p>The autoCachingPoint algorithm (if enabled) will automatically cache
* common elements of the pipeline currently being processed - as well as the
* entire cacheable pipeline according to the "longest cacheable key"
* algorithm. This feature is especially useful for pipelines that branch at
* some point (this is the case with <tt><map:select></tt> or
* <tt><map:act></tt>).
*
* <p>The option <tt>autoCachingPoint</tt> can be switched on/off in the
* sitemap.xmap (on by default). For linear pipelines, one can switch "Off"
* <tt>autoCachingPoint</tt> and use attribute
* <tt>pipeline-hints="caching-point"</tt> to manually indicate that certain
* pipeline components (eg on <tt><map:generator></tt>) should be
* considered as cache points. Both options (automatic at branch points and
* manual with pipeline hints) can coexist in the same pipeline.</p>
*
* <p>Works by requesting the pipeline processor to try shorter keys when
* looking for a cached content for the pipeline.</p>
*/
public void parameterize(Parameters config) throws ParameterException {
super.parameterize(config);
this.autoCachingPointSwitch = config.getParameter("autoCachingPoint", null);
if (this.getLogger().isDebugEnabled()) {
getLogger().debug("Auto caching-point is set to = '" + this.autoCachingPointSwitch + "'");
}
// Default is that auto caching-point is on
if (this.autoCachingPointSwitch == null) {
this.autoCachingPoint=true;
} else {
this.autoCachingPoint = BooleanUtils.toBoolean(this.autoCachingPointSwitch);
}
}
/**
* Set the generator.
*/
public void setGenerator (String role, String source, Parameters param, Parameters hintParam)
throws ProcessingException {
super.setGenerator(role, source, param, hintParam);
// check the hint param for a "caching-point" hint
String pipelinehint = null;
try {
pipelinehint = hintParam.getParameter("caching-point", null);
if (this.getLogger().isDebugEnabled()) {
getLogger().debug("generator caching-point pipeline-hint is set to: " + pipelinehint);
}
} catch (Exception ex) {
if (this.getLogger().isWarnEnabled()) {
getLogger().warn("caching-point hint Exception, pipeline-hint ignored: " + ex);
}
}
// if this generator is manually set to "caching-point" (via pipeline-hint)
// then ensure the next component is caching.
this.nextIsCachePoint = BooleanUtils.toBoolean(pipelinehint);
}
/**
* Add a transformer.
*/
public void addTransformer (String role, String source, Parameters param, Parameters hintParam)
throws ProcessingException {
super.addTransformer(role, source, param, hintParam);
// check the hint param for a "caching-point" hint
String pipelinehint = null;
try {
pipelinehint = hintParam.getParameter("caching-point", null);
if (this.getLogger().isDebugEnabled()) {
getLogger().debug("transformer caching-point pipeline-hint is set to: " + pipelinehint);
}
} catch (Exception ex) {
if (this.getLogger().isWarnEnabled()) {
getLogger().warn("caching-point hint Exception, pipeline-hint ignored: " + ex);
}
}
// add caching point flag
// default value is false
this.isCachePoint.add(BooleanUtils.toBooleanObject(this.nextIsCachePoint));
// if this transformer is manually set to "caching-point" (via pipeline-hint)
// then ensure the next component is caching.
this.nextIsCachePoint = BooleanUtils.toBoolean(pipelinehint);
}
/**
* Determine if the given branch-point is a caching-point. This is called
* by sitemap components when using cocoon views; it is also called by
* parent nodes (mainly selectors and actions).
*
* Please Note: this method is used by auto caching-point
* and is of no consequence when auto caching-point is switched off
*
* @see org.apache.cocoon.components.treeprocessor.SimpleParentProcessingNode
*/
public void informBranchPoint() {
if (this.autoCachingPoint && this.generator != null) {
this.nextIsCachePoint = true;
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Informed Pipeline of branch point");
}
}
}
/**
* Cache longest cacheable path plus cache points.
*/
protected void cacheResults(Environment environment, OutputStream os) throws Exception {
if (this.toCacheKey != null) {
if (this.cacheCompleteResponse) {
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Cached: caching complete response; pSisze"
+ this.toCacheKey.size() + " Key " + this.toCacheKey);
}
CachedResponse response = new CachedResponse(this.toCacheSourceValidities,
((CachingOutputStream)os).getContent());
response.setContentType(environment.getContentType());
this.cache.store(this.toCacheKey.copy(), response);
//
// Scan back along the pipelineCacheKey for
// for any cachepoint(s)
//
this.toCacheKey.removeUntilCachePoint();
//
// adjust the validities object
// to reflect the new length of the pipeline cache key.
//
// REVISIT: Is it enough to simply reduce the length of the validities array?
//
if (this.toCacheKey.size() > 0) {
SourceValidity[] copy = new SourceValidity[this.toCacheKey.size()];
System.arraycopy(this.toCacheSourceValidities, 0, copy, 0, copy.length);
this.toCacheSourceValidities = copy;
}
}
if (this.toCacheKey.size() > 0) {
ListIterator itt = this.xmlSerializerArray.listIterator(this.xmlSerializerArray.size());
while (itt.hasPrevious()) {
XMLSerializer serializer = (XMLSerializer) itt.previous();
CachedResponse response = new CachedResponse(this.toCacheSourceValidities,
(byte[])serializer.getSAXFragment());
this.cache.store(this.toCacheKey.copy(), response);
if (this.getLogger().isDebugEnabled()) {
this.getLogger().debug("Caching results for the following key: "
+ this.toCacheKey);
}
//
// Check for further cachepoints
//
toCacheKey.removeUntilCachePoint();
if (this.toCacheKey.size()==0)
// no cachePoint found in key
break;
//
// re-calculate validities array
//
SourceValidity[] copy = new SourceValidity[this.toCacheKey.size()];
System.arraycopy(this.toCacheSourceValidities, 0, copy, 0, copy.length);
this.toCacheSourceValidities = copy;
} //end serializer loop
}
}
}
/**
* Create a new ComponentCachekey
* ComponentCacheKeys can be flagged as cachepoints
*/
protected ComponentCacheKey newComponentCacheKey(int type, String role,Serializable key) {
boolean cachePoint = false;
if (type == ComponentCacheKey.ComponentType_Transformer) {
cachePoint =
((Boolean)this.isCachePoint.get(this.firstNotCacheableTransformerIndex)).booleanValue();
} else if (type == ComponentCacheKey.ComponentType_Serializer) {
cachePoint = this.nextIsCachePoint;
}
return new ComponentCacheKey(type, role, key, cachePoint);
}
/**
* Connect the caching point pipeline.
*/
protected void connectCachingPipeline(Environment environment)
throws ProcessingException {
try {
XMLSerializer localXMLSerializer = null;
XMLSerializer cachePointXMLSerializer = null;
if (!this.cacheCompleteResponse) {
this.xmlSerializer = (XMLSerializer)this.manager.lookup( XMLSerializer.ROLE );
localXMLSerializer = this.xmlSerializer;
}
if (this.cachedResponse == null) {
XMLProducer prev = super.generator;
XMLConsumer next;
int cacheableTransformerCount = this.firstNotCacheableTransformerIndex;
int currentTransformerIndex = 0; //start with the first transformer
Iterator itt = this.transformers.iterator();
while (itt.hasNext()) {
next = (XMLConsumer) itt.next();
// if we have cacheable transformers,
// check the tranformers for cachepoints
if (cacheableTransformerCount > 0) {
if ((this.isCachePoint.get(currentTransformerIndex) != null) &&
((Boolean)this.isCachePoint.get(currentTransformerIndex)).booleanValue()) {
cachePointXMLSerializer = ((XMLSerializer)
this.manager.lookup( XMLSerializer.ROLE ));
next = new XMLTeePipe(next, cachePointXMLSerializer);
this.xmlSerializerArray.add(cachePointXMLSerializer);
}
}
// Serializer is not cacheable,
// but we have the longest cacheable key. Do default longest key caching
if (localXMLSerializer != null) {
if (cacheableTransformerCount == 0) {
next = new XMLTeePipe(next, localXMLSerializer);
this.xmlSerializerArray.add(localXMLSerializer);
localXMLSerializer = null;
} else {
cacheableTransformerCount--;
}
}
this.connect(environment, prev, next);
prev = (XMLProducer) next;
currentTransformerIndex++;
}
next = super.lastConsumer;
// if the serializer is not cacheable, but all the transformers are:
// (this is default longest key caching)
if (localXMLSerializer != null) {
next = new XMLTeePipe(next, localXMLSerializer);
this.xmlSerializerArray.add(localXMLSerializer);
localXMLSerializer = null;
}
// else if the serializer is cacheable and has cocoon views
else if ((currentTransformerIndex == this.firstNotCacheableTransformerIndex) &&
this.nextIsCachePoint) {
cachePointXMLSerializer = ((XMLSerializer)this.manager.lookup( XMLSerializer.ROLE ));
next = new XMLTeePipe(next, cachePointXMLSerializer);
this.xmlSerializerArray.add(cachePointXMLSerializer);
}
this.connect(environment, prev, next);
} else {
// Here the first part of the pipeline has been retrived from cache
// we now check if any part of the rest of the pipeline can be cached
this.xmlDeserializer = (XMLDeserializer)this.manager.lookup(XMLDeserializer.ROLE);
// connect the pipeline:
XMLProducer prev = xmlDeserializer;
XMLConsumer next;
int cacheableTransformerCount = 0;
Iterator itt = this.transformers.iterator();
while (itt.hasNext()) {
next = (XMLConsumer) itt.next();
if (cacheableTransformerCount >= this.firstProcessedTransformerIndex) {
// if we have cacheable transformers left,
// then check the tranformers for cachepoints
if (cacheableTransformerCount < this.firstNotCacheableTransformerIndex) {
if (!(prev instanceof XMLDeserializer) &&
(this.isCachePoint.get(cacheableTransformerCount) != null) &&
((Boolean)this.isCachePoint.get(cacheableTransformerCount)).booleanValue()) {
cachePointXMLSerializer = ((XMLSerializer)this.manager.lookup( XMLSerializer.ROLE ));
next = new XMLTeePipe(next, cachePointXMLSerializer);
this.xmlSerializerArray.add(cachePointXMLSerializer);
}
}
// Serializer is not cacheable,
// but we have the longest cacheable key. Do default longest key caching
if (localXMLSerializer != null && !(prev instanceof XMLDeserializer)
&& cacheableTransformerCount == this.firstNotCacheableTransformerIndex) {
next = new XMLTeePipe(next, localXMLSerializer);
this.xmlSerializerArray.add(localXMLSerializer);
localXMLSerializer = null;
}
this.connect(environment, prev, next);
prev = (XMLProducer)next;
}
cacheableTransformerCount++;
}
next = super.lastConsumer;
//*all* the transformers are cacheable, but the serializer is not!! this is longest key
if (localXMLSerializer != null && !(prev instanceof XMLDeserializer)) {
next = new XMLTeePipe(next, localXMLSerializer);
this.xmlSerializerArray.add(localXMLSerializer);
localXMLSerializer = null;
}
// else the serializer is cacheable but has views
else if (this.nextIsCachePoint && !(prev instanceof XMLDeserializer) &&
cacheableTransformerCount == this.firstNotCacheableTransformerIndex) {
cachePointXMLSerializer = ((XMLSerializer)this.manager.lookup( XMLSerializer.ROLE ));
next = new XMLTeePipe(next, cachePointXMLSerializer);
this.xmlSerializerArray.add(cachePointXMLSerializer);
}
this.connect(environment, prev, next);
}
} catch (ComponentException e) {
throw new ProcessingException("Could not connect pipeline.", e);
}
}
/**
* Recyclable Interface
*/
public void recycle() {
super.recycle();
Iterator itt = this.xmlSerializerArray.iterator();
while (itt.hasNext()) {
this.manager.release((XMLSerializer) itt.next());
}
this.isCachePoint.clear();
this.xmlSerializerArray.clear();
this.nextIsCachePoint = false;
this.autoCachingPointSwitch=null;
}
boolean setupFromCacheKey() {
// try a shorter key
if (this.fromCacheKey.size() > 1) {
this.fromCacheKey.removeLastKey();
if (!this.completeResponseIsCached) {
this.firstProcessedTransformerIndex--;
}
return false;
} else {
this.fromCacheKey = null;
return true;
}
}
}