/*
* 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 java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.util.Map;
import java.util.Properties;
import javax.servlet.http.HttpServletRequest;
import org.apache.avalon.framework.activity.Disposable;
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.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.ResourceNotFoundException;
import org.apache.cocoon.caching.CacheableProcessingComponent;
import org.apache.cocoon.components.NekoHtmlSaxParser;
import org.apache.cocoon.components.source.SourceUtil;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.environment.http.HttpEnvironment;
import org.apache.cocoon.util.PostInputStream;
import org.apache.cocoon.xml.dom.DOMBuilder;
import org.apache.cocoon.xml.dom.DOMStreamer;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceException;
import org.apache.excalibur.source.SourceValidity;
import org.apache.excalibur.xml.xpath.XPathProcessor;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
/**
* @cocoon.sitemap.component.documentation
* The Neko HTML generator reads HTML from a source, converts it to XHTML
* and generates SAX Events. It uses the NekoHTML library to do this.
*
* @cocoon.sitemap.component.name nekohtml
* @cocoon.sitemap.component.label content
* @cocoon.sitemap.component.logger sitemap.generator.nekohtml
* @cocoon.sitemap.component.documentation.caching Yes.
* Uses the last modification date of the xml document for validation
*
* @cocoon.sitemap.component.pooling.max 32
*
* @author <a href="mailto:dims@yahoo.com">Davanum Srinivas</a>
* @author <a href="mailto:cziegeler@apache.org">Carsten Ziegeler</a>
* @author <a href="mailto:barozzi@nicolaken.com">Nicola Ken Barozzi</a>
* @author <a href="mailto:gianugo@apache.org">Gianugo Rabellino</a>
*
* @version CVS $Id$
*/
public class NekoHTMLGenerator extends ServiceableGenerator
implements Configurable, CacheableProcessingComponent, Disposable {
/** The parameter that specifies what request parameter to use, if any */
public static final String FORM_NAME = "form-name";
/** The request parameter value, if coming from a request parameter */
private String requestParameterValue;
/** The source, if coming from a file */
private Source inputSource;
/** The source, if coming from the request */
private InputStream requestStream;
/** XPATH expression */
private String xpath;
/** XPath Processor */
private XPathProcessor processor;
/** Neko properties */
private Properties properties;
public void service(ServiceManager manager)
throws ServiceException {
super.service(manager);
this.processor = (XPathProcessor) this.manager.lookup(XPathProcessor.ROLE);
}
public void configure(Configuration config) throws ConfigurationException {
String configUrl = config.getChild("neko-config").getValue(null);
if (configUrl != null) {
org.apache.excalibur.source.SourceResolver resolver = null;
Source configSource = null;
try {
resolver = (org.apache.excalibur.source.SourceResolver)this.manager.lookup(org.apache.excalibur.source.SourceResolver.ROLE);
configSource = resolver.resolveURI(configUrl);
if (getLogger().isDebugEnabled()) {
getLogger().debug("Loading configuration from " + configSource.getURI());
}
this.properties = new Properties();
this.properties.load(configSource.getInputStream());
} catch (Exception e) {
getLogger().warn("Cannot load configuration from " + configUrl);
throw new ConfigurationException("Cannot load configuration from " + configUrl, e);
} finally {
if ( null != resolver ) {
this.manager.release(resolver);
resolver.release(configSource);
}
}
}
}
/**
* Recycle this component.
* All instance variables are set to <code>null</code>.
*/
public void recycle() {
if (this.requestStream != null) {
try {
this.requestStream.close();
} catch (IOException e) {
// ignore
}
this.requestStream = null;
}
if (this.inputSource != null) {
this.resolver.release(this.inputSource);
this.inputSource = null;
}
this.requestParameterValue = null;
this.xpath = null;
super.recycle();
}
/**
* Setup the html generator.
* Try to get the last modification date of the source for caching.
*/
public void setup(SourceResolver resolver, Map objectModel, String src, Parameters par)
throws ProcessingException, SAXException, IOException {
super.setup(resolver, objectModel, src, par);
Request request = ObjectModelHelper.getRequest(objectModel);
if (this.source == null) {
// Handle this request as the StreamGenerator does (from the POST
// request or from a request parameter), but try to make sure
// that the output will be well-formed
String contentType = request.getContentType();
if (contentType == null ) {
throw new IOException("Content-type was not specified for this request");
} else if (contentType.startsWith("application/x-www-form-urlencoded")
|| contentType.startsWith("multipart/form-data")) {
String requested = parameters.getParameter(FORM_NAME, null);
if (requested == null) {
throw new ProcessingException(
"NekoHtmlGenerator with no \"src\" parameter expects a sitemap parameter called '" +
FORM_NAME + "' for handling form data"
);
}
requestParameterValue = request.getParameter(requested);
} else if (contentType.startsWith("text/plain")
|| contentType.startsWith("text/xml")
|| contentType.startsWith("application/xml")) {
HttpServletRequest httpRequest = (HttpServletRequest) objectModel.get(HttpEnvironment.HTTP_REQUEST_OBJECT);
if ( httpRequest == null ) {
throw new ProcessingException("This functionality only works in an http environment.");
}
int len = request.getContentLength();
if (len > 0) {
requestStream = new PostInputStream(httpRequest.getInputStream(), len);
} else {
throw new IOException("getContentLen() == 0");
}
} else {
throw new IOException("Unexpected getContentType(): " + request.getContentType());
}
} else {
// append the request parameter to the URL if necessary
if (parameters.getParameterAsBoolean("copy-parameters", false)
&& request.getQueryString() != null) {
StringBuffer query = new StringBuffer(this.source);
query.append(this.source.indexOf("?") == -1 ? '?' : '&');
query.append(request.getQueryString());
this.source = query.toString();
}
try {
this.inputSource = resolver.resolveURI(this.source);
} catch (SourceException se) {
throw SourceUtil.handle("Unable to resolve " + this.source, se);
}
}
xpath = request.getParameter("xpath");
if (xpath == null) {
xpath = par.getParameter("xpath",null);
}
}
/**
* 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>0</code> if the component
* is currently not cacheable.
*/
public java.io.Serializable getKey() {
if (this.inputSource == null)
return null;
if (this.xpath != null) {
StringBuffer buffer = new StringBuffer(this.inputSource.getURI());
buffer.append(':').append(this.xpath);
return buffer.toString();
} else {
return this.inputSource.getURI();
}
}
/**
* 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() {
if (this.inputSource == null)
return null;
return this.inputSource.getValidity();
}
/**
* Generate XML data.
*/
public void generate()
throws IOException, SAXException, ProcessingException {
try {
NekoHtmlSaxParser parser = new NekoHtmlSaxParser(this.properties);
InputSource saxSource;
if (this.requestParameterValue != null) {
saxSource = new InputSource(new StringReader(this.requestParameterValue));
}
else {
if (inputSource != null) {
requestStream = this.inputSource.getInputStream();
}
saxSource = new InputSource(requestStream);
}
if (xpath != null) {
DOMBuilder builder = new DOMBuilder();
parser.setContentHandler(builder);
parser.parse(saxSource);
Document doc = builder.getDocument();
DOMStreamer domStreamer = new DOMStreamer(this.contentHandler,
this.lexicalHandler);
this.contentHandler.startDocument();
NodeList nl = processor.selectNodeList(doc, xpath);
int length = nl.getLength();
for(int i=0; i < length; i++) {
domStreamer.stream(nl.item(i));
}
this.contentHandler.endDocument();
} else {
parser.setContentHandler(this.contentHandler);
parser.parse(saxSource);
}
} catch (IOException e){
throw new ResourceNotFoundException("Could not get resource "
+ this.inputSource.getURI(), e);
} catch (SAXException e){
throw e;
} catch (Exception e){
throw new ProcessingException("Exception in NekoHTMLGenerator.generate()",e);
}
}
public void dispose() {
if (this.manager != null) {
this.manager.release(this.processor);
this.manager = null;
}
this.processor = null;
super.dispose();
}
}