/*
* 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.generation;
import org.apache.commons.collections.ArrayStack;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.component.ComponentManager;
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.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.ResourceNotFoundException;
import org.apache.cocoon.caching.CacheableProcessingComponent;
import org.apache.cocoon.components.language.generator.ProgramGenerator;
import org.apache.cocoon.components.source.SourceUtil;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.xml.AbstractXMLPipe;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceException;
import org.apache.excalibur.source.SourceValidity;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import java.io.IOException;
import java.io.Serializable;
import java.util.Map;
/**
* This class acts as a proxy to a dynamically loaded<code>Generator</code>
* delegating actual SAX event generation.
* <p>
* It has a single configuration item :
* <code><autocomplete-documents>true|false<autocomplete-documents></code>
* (default is <code>false</code>).
* <p>
* This tells the generator to automatically close all elements that weren't properly closed
* by the XSP, such as when a <code>return</code> statement is used to prematurely end
* processing. Activating this feature <em>sensibly increases CPU-usage</em> and should
* therefore be used only if really needed (it's better to have clean XSP pages that don't
* break abruptly generation flow).
*
* @author <a href="mailto:ricardo@apache.org">Ricardo Rocha</a>
* @author <a href="mailto:sylvain@apache.org">Sylvain Wallez</a>
* @version $Id$
*/
public class ServerPagesGenerator extends ServletGenerator
implements CacheableProcessingComponent, Configurable {
/**
* The sitemap-defined server pages program generator
*/
protected ProgramGenerator programGenerator = null;
protected AbstractServerPage generator = null;
/** The source */
private Source inputSource;
private CompletionPipe completionPipe;
/**
* Set the global component manager. This method sets the sitemap-defined
* program generator
*
* @param manager The global component manager
*/
public void compose(ComponentManager manager) throws ComponentException {
super.compose(manager);
if (programGenerator == null) {
this.programGenerator =
(ProgramGenerator) manager.lookup(ProgramGenerator.ROLE);
}
}
public void configure(Configuration config) throws ConfigurationException {
boolean autoComplete = config.getChild("autocomplete-documents").getValueAsBoolean(false);
if (autoComplete) {
this.completionPipe = new CompletionPipe();
this.completionPipe.enableLogging(getLogger());
}
this.markupLanguage = config.getChild("markup-language").getValue(DEFAULT_MARKUP_LANGUAGE);
this.programmingLanguage = config.getChild("programming-language").getValue(DEFAULT_PROGRAMMING_LANGUAGE);
}
/**
* Generate the unique key.
* This key must be unique inside the space of this component.
* This method must be invoked before the generateValidity() method.
*
* @return The generated key or <code>null</code> if the component
* is currently not cacheable.
*/
public Serializable getKey() {
Object key = generator.getKey();
if (key == null) {
return this.inputSource.getURI();
}
return this.inputSource.getURI() + '-' + key;
}
/**
* Generate the validity object.
* Before this method can be invoked the generateKey() method
* must be invoked.
*
* @return The generated validity object or <code>null</code> if the
* component is currently not cacheable.
*/
public SourceValidity getValidity() {
// VG: Input source's systemID is part of the key,
// and need not be included into the validity.
return generator.getValidity();
}
/**
* The loaded generator's <code>MarkupLanguage</code>
*/
protected String markupLanguage;
/**
* The loaded generator's <code>ProgrammingLanguage</code>
*/
protected String programmingLanguage;
/**
* The default <code>MarkupLanguage</code>
*/
public final static String DEFAULT_MARKUP_LANGUAGE = "xsp";
/**
* The default <code>ProgrammingLanguage</code>
*/
public final static String DEFAULT_PROGRAMMING_LANGUAGE = "java";
public void setup(SourceResolver resolver, Map objectModel, String src, Parameters par)
throws ProcessingException, SAXException, IOException {
super.setup(resolver, objectModel, src, par);
String markupLanguage = this.parameters.getParameter(
"markup-language", this.markupLanguage);
String programmingLanguage = this.parameters.getParameter(
"programming-language", this.programmingLanguage);
try {
this.inputSource = this.resolver.resolveURI(src);
} catch (SourceException se) {
throw SourceUtil.handle("Error during resolving of '" + src + "'.", se);
//throw SourceUtil.handle(se);
}
try {
this.generator = (AbstractServerPage) programGenerator.load(this.manager,
this.inputSource, markupLanguage, programmingLanguage, this.resolver);
} catch (ProcessingException e) {
throw e;
} catch (Exception e) {
getLogger().warn("setup()", e);
throw new ProcessingException(e.getMessage(), e);
} catch (NoClassDefFoundError e) {
// VG: Usually indicates that page invoked with the wrong case.
// I.e., it was compiled as "my.xsp" and inoked as "My.xsp",
// results in different class name and an error.
getLogger().warn("Failed to load class: " + e);
throw new ResourceNotFoundException(e.getMessage());
}
// Give our own logger to the generator so that logs go in the correct category
generator.enableLogging(getLogger());
generator.setup(super.resolver, super.objectModel, super.source, super.parameters);
}
/**
* Generate XML data. This method loads a server pages generator associated
* with its (file) input source and delegates SAX event generator to it
* taking care of "closing" any event left open by the loaded generator as a
* result of its possible "premature" return (a common situation in server
* pages)
*
* @exception IOException IO Error
* @exception SAXException SAX event generation error
* @exception ProcessingException Error during load/execution
*/
public void generate() throws IOException, SAXException, ProcessingException {
if (this.completionPipe != null) {
generator.setConsumer(this.completionPipe);
if (this.xmlConsumer != null) {
this.completionPipe.setConsumer(this.xmlConsumer);
} else {
this.completionPipe.setContentHandler(this.contentHandler);
this.completionPipe.setLexicalHandler(this.lexicalHandler);
}
} else {
if (this.xmlConsumer != null) {
generator.setConsumer(this.xmlConsumer);
} else {
generator.setContentHandler(this.contentHandler);
generator.setLexicalHandler(this.lexicalHandler);
}
}
// Fixes BUG#4062: Set document locator which is used by XIncludeTransformer
org.xml.sax.helpers.LocatorImpl locator = new org.xml.sax.helpers.LocatorImpl();
locator.setSystemId(this.inputSource.getURI());
this.contentHandler.setDocumentLocator(locator);
// Log exception and ensure that generator is released.
try {
generator.generate();
} catch (IOException e) {
getLogger().debug("IOException in generate()", e);
throw e;
} catch (SAXException e) {
getLogger().debug("SAXException in generate()", e);
throw e;
} catch (ProcessingException e) {
getLogger().debug("ProcessingException in generate()", e);
throw e;
} catch (Exception e) {
getLogger().debug("Exception in generate()", e);
throw new ProcessingException("Exception in ServerPagesGenerator.generate()", e);
} finally {
if (generator != null) {
programGenerator.release(generator);
}
generator = null;
}
if (this.completionPipe != null) {
this.completionPipe.flushEvents();
}
}
/**
* Recycle the generator by removing references
*/
public void recycle() {
if (this.generator != null) {
this.programGenerator.release(this.generator);
this.generator = null;
}
if (this.inputSource != null) {
this.resolver.release(this.inputSource);
this.inputSource = null;
}
if (this.completionPipe != null) {
this.completionPipe.recycle();
this.completionPipe = null;
}
super.recycle();
}
/**
* dispose
*/
public void dispose() {
this.manager.release(this.programGenerator);
this.programGenerator = null;
this.manager = null;
}
/* Completion pipe */
// int values for event types
private final static int DOCUMENT = 0;
private final static int ELEMENT = 1;
private final static int PREFIX_MAPPING = 2;
private final static int CDATA = 3;
private final static int DTD = 4;
private final static int ENTITY = 5;
// Integer equivalents to push on the stack
private final static Integer DOCUMENT_OBJ = new Integer(DOCUMENT);
private final static Integer ELEMENT_OBJ = new Integer(ELEMENT);
private final static Integer PREFIX_MAPPING_OBJ = new Integer(PREFIX_MAPPING);
private final static Integer CDATA_OBJ = new Integer(CDATA);
private final static Integer DTD_OBJ = new Integer(DTD);
private final static Integer ENTITY_OBJ = new Integer(ENTITY);
public class CompletionPipe extends AbstractXMLPipe {
/**
* The SAX event stack. Used for "completing" pendind SAX events left "open"
* by prematurely returning server pages generators
*/
protected ArrayStack eventStack = new ArrayStack();
/**
* Receive notification of the beginning of a document.
*/
public void startDocument() throws SAXException {
super.startDocument();
this.eventStack.push(DOCUMENT_OBJ);
}
/**
* Receive notification of the end of a document.
*/
public void endDocument() throws SAXException {
this.eventStack.pop();
super.endDocument();
}
/**
* Receive notification of the beginning of an element.
*/
public void startElement(String namespaceURI, String localName, String rawName, Attributes atts)
throws SAXException {
super.startElement(namespaceURI, localName, rawName, atts);
this.eventStack.push(rawName);
this.eventStack.push(localName);
this.eventStack.push(namespaceURI);
this.eventStack.push(ELEMENT_OBJ);
}
/**
* Receive notification of the end of an element.
*/
public void endElement(String namespaceURI, String localName, String rawName)
throws SAXException {
this.eventStack.pop(); // ELEMENT_OBJ
this.eventStack.pop(); // namespaceURI
this.eventStack.pop(); // localName
this.eventStack.pop(); // rawName
super.endElement(namespaceURI, localName, rawName);
}
/**
* Begin the scope of a prefix-URI Namespace mapping.
*/
public void startPrefixMapping(String prefix, String uri) throws SAXException {
super.startPrefixMapping(prefix, uri);
this.eventStack.push(prefix);
this.eventStack.push(PREFIX_MAPPING_OBJ);
}
/**
* End the scope of a prefix-URI mapping.
*/
public void endPrefixMapping(String prefix) throws SAXException {
this.eventStack.pop(); // PREFIX_MAPPING_OBJ
this.eventStack.pop(); // prefix
super.endPrefixMapping(prefix);
}
public void startCDATA() throws SAXException {
super.startCDATA();
this.eventStack.push(CDATA_OBJ);
}
public void endCDATA() throws SAXException {
this.eventStack.pop();
super.endCDATA();
}
public void startDTD(String name, String publicId, String systemId)
throws SAXException {
super.startDTD(name, publicId, systemId);
this.eventStack.push(DTD_OBJ);
}
public void endDTD() throws SAXException {
this.eventStack.pop();
super.endDTD();
}
public void startEntity(String name) throws SAXException {
super.startEntity(name);
this.eventStack.push(name);
this.eventStack.push(ENTITY_OBJ);
}
public void endEntity(String name) throws SAXException {
this.eventStack.pop(); // ENTITY_OBJ
this.eventStack.pop(); // name
super.endEntity(name);
}
public void flushEvents() throws SAXException {
if (this.getLogger().isWarnEnabled()) {
if (this.eventStack.size() > 0) {
this.getLogger().warn("Premature end of document generated by " + inputSource.getURI());
}
}
// End any started events in case of premature return
while (this.eventStack.size() != 0) {
int event = ((Integer) eventStack.pop()).intValue();
switch (event) {
case DOCUMENT:
super.endDocument();
break;
case ELEMENT:
String namespaceURI = (String) eventStack.pop();
String localName = (String) eventStack.pop();
String rawName = (String) eventStack.pop();
super.endElement(namespaceURI, localName, rawName);
break;
case PREFIX_MAPPING:
super.endPrefixMapping((String) eventStack.pop());
break;
case CDATA:
super.endCDATA();
break;
case DTD:
super.endDTD();
break;
case ENTITY:
super.endEntity((String) eventStack.pop());
break;
}
}
}
public void recycle() {
this.eventStack.clear();
super.recycle();
}
}
}