/*
* 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.transformation;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.Serializable;
import java.net.MalformedURLException;
import java.util.Map;
import org.apache.avalon.framework.CascadingException;
import org.apache.avalon.framework.CascadingRuntimeException;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.ResourceNotFoundException;
import org.apache.cocoon.caching.CacheableProcessingComponent;
import org.apache.cocoon.components.source.SourceUtil;
import org.apache.cocoon.components.source.impl.MultiSourceValidity;
import org.apache.cocoon.components.xpointer.XPointer;
import org.apache.cocoon.components.xpointer.XPointerContext;
import org.apache.cocoon.components.xpointer.parser.ParseException;
import org.apache.cocoon.components.xpointer.parser.XPointerFrameworkParser;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.util.NetUtils;
import org.apache.cocoon.xml.AbstractXMLPipe;
import org.apache.cocoon.xml.IncludeXMLConsumer;
import org.apache.cocoon.xml.XMLBaseSupport;
import org.apache.cocoon.xml.XMLConsumer;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceException;
import org.apache.excalibur.source.SourceNotFoundException;
import org.apache.excalibur.source.SourceValidity;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.AttributesImpl;
/**
* @cocoon.sitemap.component.documentation
* Implementation of an XInclude transformer.
*
* @cocoon.sitemap.component.name xinclude
* @cocoon.sitemap.component.logger sitemap.transformer.xinclude
*
* @cocoon.sitemap.component.pooling.max 16
*
* Implementation of an XInclude transformer. It supports xml:base attributes,
* XPointer fragment identifiers (see the xpointer package to see what exactly is
* supported), fallback elements, and does xinclude processing on the included content
* and on the content of fallback elements (with loop inclusion detection).
*
* @author <a href="mailto:balld@webslingerZ.com">Donald Ball</a> (wrote the original version)
* @version SVN $Id$
*/
public class XIncludeTransformer extends AbstractTransformer implements Serviceable, CacheableProcessingComponent {
protected SourceResolver resolver;
protected ServiceManager manager;
private XIncludePipe xIncludePipe;
/**
* @deprecated Should be removed in cocoon 2.2. Use javax.xml.XMLConstants.XML_NS_URI instead.
*/
public static final String XMLBASE_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
public static final String XMLBASE_NAMESPACE_PREFIX = "xml";
public static final String XMLBASE_ATTRIBUTE = "base";
public static final String XMLBASE_ATTRIBUTE_TYPE = "CDATA";
public static final String XINCLUDE_NAMESPACE_URI = "http://www.w3.org/2001/XInclude";
public static final String XINCLUDE_INCLUDE_ELEMENT = "include";
public static final String XINCLUDE_FALLBACK_ELEMENT = "fallback";
public static final String XINCLUDE_INCLUDE_ELEMENT_HREF_ATTRIBUTE = "href";
public static final String XINCLUDE_INCLUDE_ELEMENT_XPOINTER_ATTRIBUTE = "xpointer";
public static final String XINCLUDE_INCLUDE_ELEMENT_PARSE_ATTRIBUTE = "parse";
private static final String XINCLUDE_CACHE_KEY = "XInclude";
/** The {@link SourceValidity} instance associated with this request. */
protected MultiSourceValidity validity;
public void setup(SourceResolver resolver, Map objectModel, String source, Parameters parameters)
throws ProcessingException, SAXException, IOException {
this.resolver = resolver;
this.validity = new MultiSourceValidity(resolver, MultiSourceValidity.CHECK_ALWAYS);
this.xIncludePipe = new XIncludePipe();
this.xIncludePipe.enableLogging(getLogger());
this.xIncludePipe.init(null, null);
super.setContentHandler(xIncludePipe);
super.setLexicalHandler(xIncludePipe);
}
public void setConsumer(XMLConsumer consumer) {
xIncludePipe.setConsumer(consumer);
}
public void setContentHandler(ContentHandler handler) {
xIncludePipe.setContentHandler(handler);
}
public void setLexicalHandler(LexicalHandler handler) {
xIncludePipe.setLexicalHandler(handler);
}
public void service(ServiceManager manager) {
this.manager = manager;
}
/** Key to be used for caching */
public Serializable getKey() {
return XINCLUDE_CACHE_KEY;
}
/** Get the validity for this transform */
public SourceValidity getValidity() {
return this.validity;
}
public void recycle()
{
// Reset all variables to initial state.
this.resolver = null;
this.validity = null;
this.xIncludePipe = null;
super.recycle();
}
/**
* XMLPipe that processes XInclude elements. To perform XInclude processing on included content,
* this class is instantiated recursively.
*/
private class XIncludePipe extends AbstractXMLPipe {
/** Helper class to keep track of xml:base attributes */
private XMLBaseSupport xmlBaseSupport;
/** The nesting level of xi:include elements that have been encountered. */
private int xIncludeElementLevel = 0;
/** The nesting level of fallback that should be used */
private int useFallbackLevel = 0;
/** The nesting level of xi:fallback elements that have been encountered. */
private int fallbackElementLevel;
/**
* In case {@link #useFallbackLevel} > 0, then this should contain the
* exception that caused fallback to be needed. In the case of nested
* include elements it will contain only the deepest exception.
*/
private Exception fallBackException;
/**
* Locator of the current stream, stored here so that it can be restored after
* another document send its content to the consumer.
*/
private Locator locator;
/**
* Value of the href attribute of the xi:include element that caused the creation of the this
* XIncludePipe. Used to detect loop inclusions.
*/
private String href;
/**
* Value of the xpointer attribute of the xi:include element that caused the creation of this
* XIncludePipe. Used to detect loop inclusions.
*/
private String xpointer;
/**
* Value of the current element level. Used to determine when to insert
* xml:base attributes for base URI fixup.
*/
private int level = 0;
/**
* Base URI of the parent of the current element. Used to determine
* if base URI fixup is necessary.
*/
private String parentBaseURI = null;
private XIncludePipe parent;
public void init(String uri, String xpointer) {
this.href = uri;
this.xpointer = xpointer;
this.xmlBaseSupport = new XMLBaseSupport(resolver, getLogger());
}
public void setParent(XIncludePipe parent) {
this.parent = parent;
}
public XIncludePipe getParent() {
return parent;
}
public String getHref() {
return href;
}
public String getXpointer() {
return xpointer;
}
/**
* Determine whether the pipe is currently in a state where contents
* should be evaluated, i.e. xi:include elements should be resolved
* and elements in other namespaces should be copied through. Will
* return false for fallback contents within a successful xi:include,
* and true for contents outside any xi:include or within an xi:fallback
* for an unsuccessful xi:include.
*/
private boolean isEvaluatingContent() {
return xIncludeElementLevel == 0 || (fallbackElementLevel > 0 && fallbackElementLevel == useFallbackLevel);
}
public void endDocument() throws SAXException {
// We won't be getting any more sources so mark the MultiSourceValidity as finished.
validity.close();
super.endDocument();
}
public void startElement(String uri, String name, String raw, Attributes attr) throws SAXException {
// Track xml:base context:
parentBaseURI = xmlBaseSupport.getCurrentBase();
xmlBaseSupport.startElement(uri, name, raw, attr);
this.level++;
// Handle elements in xinclude namespace:
if (XINCLUDE_NAMESPACE_URI.equals(uri)) {
// Handle xi:include:
if (XINCLUDE_INCLUDE_ELEMENT.equals(name)) {
// Process the include, unless in an ignored fallback:
if (isEvaluatingContent()) {
String href = attr.getValue("", XINCLUDE_INCLUDE_ELEMENT_HREF_ATTRIBUTE);
String parse = attr.getValue("", XINCLUDE_INCLUDE_ELEMENT_PARSE_ATTRIBUTE);
String xpointer = attr.getValue("", XINCLUDE_INCLUDE_ELEMENT_XPOINTER_ATTRIBUTE);
try {
processXIncludeElement(href, parse, xpointer);
} catch (ProcessingException e) {
getLogger().debug("Rethrowing exception", e);
throw new SAXException(e);
} catch (IOException e) {
getLogger().debug("Rethrowing exception", e);
throw new SAXException(e);
}
}
xIncludeElementLevel++;
} else if (XINCLUDE_FALLBACK_ELEMENT.equals(name)) {
// Handle xi:fallback
fallbackElementLevel++;
} else {
// Unknown element:
throw new SAXException("Unknown XInclude element " + raw + " at " + getLocation());
}
} else if (isEvaluatingContent()) {
// Copy other elements through when appropriate,
// performing base URI fixup when necessary.
if(mustAddBaseAttr())
super.startElement(uri, name, raw, addBaseURI(attr));
else
super.startElement(uri, name, raw, attr);
}
}
private boolean mustAddBaseAttr(){
if(level != 1)
return false;
if(this.parent == null)
return false;
String parentBase = this.parent.parentBaseURI;
String currentBase = xmlBaseSupport.getCurrentBase();
if(currentBase == null)
return false;
if(parentBase == null || !parentBase.equals(currentBase))
return true;
return false;
}
/**
* Adds xml:base attribute as per the XInclude spec.
*/
private Attributes addBaseURI(Attributes oldAttr) throws SAXException {
String currentBaseURI = xmlBaseSupport.getCurrentBase();
AttributesImpl fixedAttr = new AttributesImpl(oldAttr);
// Old xml:base attributes are removed.
int xmlBaseAttrIdx = fixedAttr.getIndex(XMLBASE_NAMESPACE_URI, XMLBASE_ATTRIBUTE);
if(xmlBaseAttrIdx != -1)
fixedAttr.removeAttribute(xmlBaseAttrIdx);
fixedAttr.addAttribute(
XMLBASE_NAMESPACE_URI, XMLBASE_ATTRIBUTE,
XMLBASE_NAMESPACE_PREFIX + ":" + XMLBASE_ATTRIBUTE,
XMLBASE_ATTRIBUTE_TYPE,
currentBaseURI
);
return fixedAttr;
}
public void endElement(String uri, String name, String raw) throws SAXException {
// Track xml:base context:
xmlBaseSupport.endElement(uri, name, raw);
this.level--;
// Handle elements in xinclude namespace:
if (XINCLUDE_NAMESPACE_URI.equals(uri)) {
// Handle xi:include:
if (XINCLUDE_INCLUDE_ELEMENT.equals(name)) {
xIncludeElementLevel--;
if (useFallbackLevel > xIncludeElementLevel) {
useFallbackLevel = xIncludeElementLevel;
}
} else if (XINCLUDE_FALLBACK_ELEMENT.equals(name)) {
// Handle xi:fallback:
fallbackElementLevel--;
}
} else if (isEvaluatingContent()) {
// Copy other elements through when appropriate:
super.endElement(uri, name, raw);
}
}
public void startPrefixMapping(String prefix, String uri) throws SAXException {
if (isEvaluatingContent()) {
super.startPrefixMapping(prefix, uri);
}
}
public void endPrefixMapping(String prefix) throws SAXException {
if (isEvaluatingContent()) {
super.endPrefixMapping(prefix);
}
}
public void characters(char c[], int start, int len) throws SAXException {
if (isEvaluatingContent()) {
super.characters(c, start, len);
}
}
public void ignorableWhitespace(char c[], int start, int len) throws SAXException {
if (isEvaluatingContent()) {
super.ignorableWhitespace(c, start, len);
}
}
public void processingInstruction(String target, String data) throws SAXException {
if (isEvaluatingContent()) {
super.processingInstruction(target, data);
}
}
public void skippedEntity(String name) throws SAXException {
if (isEvaluatingContent()) {
super.skippedEntity(name);
}
}
public void startEntity(String name) throws SAXException {
if (isEvaluatingContent()) {
super.startEntity(name);
}
}
public void endEntity(String name) throws SAXException {
if (isEvaluatingContent()) {
super.endEntity(name);
}
}
public void startCDATA() throws SAXException {
if (isEvaluatingContent()) {
super.startCDATA();
}
}
public void endCDATA() throws SAXException {
if (isEvaluatingContent()) {
super.endCDATA();
}
}
public void comment(char ch[], int start, int len) throws SAXException {
if (isEvaluatingContent()) {
super.comment(ch, start, len);
}
}
public void setDocumentLocator(Locator locator) {
try {
if (getLogger().isDebugEnabled()) {
getLogger().debug("setDocumentLocator called " + locator.getSystemId());
}
// When using SAXON to serialize a DOM tree to SAX, a locator is passed with a "null" system id
if (locator.getSystemId() != null) {
Source source = resolver.resolveURI(locator.getSystemId());
try {
xmlBaseSupport.setDocumentLocation(source.getURI());
// only for the "root" XIncludePipe, we'll have to set the href here, in the other cases
// the href is taken from the xi:include href attribute
if (href == null)
href = source.getURI();
} finally {
resolver.release(source);
}
}
} catch (Exception e) {
throw new CascadingRuntimeException("Error in XIncludeTransformer while trying to resolve base URL for document", e);
}
this.locator = locator;
super.setDocumentLocator(locator);
}
protected void processXIncludeElement(String href, String parse, String xpointer)
throws SAXException,ProcessingException,IOException {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Processing XInclude element: href="+href+", parse="+parse+", xpointer="+xpointer);
}
// Default for @parse is "xml"
if (parse == null) {
parse = "xml";
}
Source url = null;
try {
int fragmentIdentifierPos = href.indexOf('#');
if (fragmentIdentifierPos != -1) {
getLogger().warn("Fragment identifer found in 'href' attribute: " + href +
"\nFragment identifiers are forbidden by the XInclude specification. " +
"They are still handled by XIncludeTransformer for backward " +
"compatibility, but their use is deprecated and will be prohibited " +
"in a future release. Use the 'xpointer' attribute instead.");
if (xpointer == null) {
xpointer = href.substring(fragmentIdentifierPos + 1);
}
href = href.substring(0, fragmentIdentifierPos);
}
// An empty or absent href is a reference to the current document -- this can be different than the current base
if (href == null || href.length() == 0) {
if (this.href == null) {
throw new SAXException("XIncludeTransformer: encountered empty href (= href pointing to the current document) but the location of the current document is unknown.");
}
// The following can be simplified once fragment identifiers are prohibited
int fragmentIdentifierPos2 = this.href.indexOf('#');
if (fragmentIdentifierPos2 != -1)
href = this.href.substring(0, fragmentIdentifierPos2);
else
href = this.href;
}
url = xmlBaseSupport.makeAbsolute(href);
if (getLogger().isDebugEnabled()) {
getLogger().debug("URL: " + url.getURI() + "\nXPointer: " + xpointer);
}
// add the source to the SourceValidity
validity.addSource(url);
if (parse.equals("text")) {
getLogger().debug("Parse type is text");
if (xpointer != null) {
throw new SAXException("xpointer attribute must not be present when parse='text': " + getLocation());
}
InputStream is = null;
InputStreamReader isr = null;
Reader reader = null;
try {
is = url.getInputStream();
isr = new InputStreamReader(is);
reader = new BufferedReader(isr);
int read;
char ary[] = new char[1024 * 4];
while ((read = reader.read(ary)) != -1) {
super.characters(ary,0,read);
}
} catch (SourceNotFoundException e) {
useFallbackLevel++;
fallBackException = new CascadingException("Resource not found: " + url.getURI());
getLogger().error("xIncluded resource not found: " + url.getURI(), e);
} finally {
if (reader != null) reader.close();
if (isr != null) isr.close();
if (is != null) is.close();
}
} else if (parse.equals("xml")) {
getLogger().debug("Parse type is XML");
// Check loop inclusion
if (isLoopInclusion(url.getURI(), xpointer)) {
throw new ProcessingException("Detected loop inclusion of href=" + url.getURI() + ", xpointer=" + xpointer);
}
XIncludePipe subPipe = new XIncludePipe();
subPipe.enableLogging(getLogger());
subPipe.init(url.getURI(), xpointer);
subPipe.setConsumer(xmlConsumer);
subPipe.setParent(this);
try {
if (xpointer != null && xpointer.length() > 0) {
XPointer xptr;
xptr = XPointerFrameworkParser.parse(NetUtils.decodePath(xpointer));
XPointerContext context = new XPointerContext(xpointer, url, subPipe, getLogger(), manager);
xptr.process(context);
} else {
SourceUtil.toSAX(url, new IncludeXMLConsumer(subPipe));
}
// restore locator on the consumer
if (locator != null)
xmlConsumer.setDocumentLocator(locator);
} catch (ResourceNotFoundException e) {
useFallbackLevel++;
fallBackException = new CascadingException("Resource not found: " + url.getURI());
getLogger().error("xIncluded resource not found: " + url.getURI(), e);
} catch (ParseException e) {
// this exception is thrown in case of an invalid xpointer expression
useFallbackLevel++;
fallBackException = new CascadingException("Error parsing xPointer expression", e);
fallBackException.fillInStackTrace();
getLogger().error("Error parsing XPointer expression, will try to use fallback.", e);
} catch(SAXException e) {
getLogger().error("Error in processXIncludeElement", e);
throw e;
} catch(ProcessingException e) {
getLogger().error("Error in processXIncludeElement", e);
throw e;
} catch(MalformedURLException e) {
useFallbackLevel++;
fallBackException = e;
getLogger().error("Error processing an xInclude, will try to use fallback.", e);
} catch(IOException e) {
useFallbackLevel++;
fallBackException = e;
getLogger().error("Error processing an xInclude, will try to use fallback.", e);
}
} else {
throw new SAXException("Found 'parse' attribute with unknown value " + parse + " at " + getLocation());
}
} catch (SourceException se) {
throw SourceUtil.handle(se);
} finally {
if (url != null) {
resolver.release(url);
}
}
}
public boolean isLoopInclusion(String uri, String xpointer) {
if (xpointer == null) {
xpointer = "";
}
if (uri.equals(this.href) && xpointer.equals(this.xpointer == null ? "" : this.xpointer)) {
return true;
}
XIncludePipe parent = getParent();
while (parent != null) {
if (uri.equals(parent.getHref()) && xpointer.equals(parent.getXpointer() == null ? "" : parent.getXpointer())) {
return true;
}
parent = parent.getParent();
}
return false;
}
private String getLocation() {
if (this.locator == null) {
return "unknown location";
} else {
return this.locator.getSystemId() + ":" + this.locator.getColumnNumber() + ":" + this.locator.getLineNumber();
}
}
}
}