/*
* 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.serialization;
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.configuration.SAXConfigurationHandler;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.caching.CacheableProcessingComponent;
import org.apache.cocoon.components.source.SourceUtil;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceException;
import org.apache.excalibur.source.SourceResolver;
import org.apache.excalibur.source.SourceValidity;
import org.apache.excalibur.source.impl.validity.NOPValidity;
import org.apache.fop.apps.FOPException;
import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.Fop;
import org.apache.fop.apps.FopFactory;
import javax.xml.transform.TransformerException;
import javax.xml.transform.URIResolver;
import javax.xml.transform.stream.StreamSource;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
/**
* FOP 0.93 (and newer) based serializer.
*
* @version $Id$
*/
public class FOPSerializer extends AbstractSerializer
implements Configurable, CacheableProcessingComponent,
Serviceable, URIResolver, Disposable {
protected SourceResolver resolver;
/**
* Factory to create fop objects
*/
protected FopFactory fopfactory = FopFactory.newInstance();
/**
* The FOP instance.
*/
protected Fop fop;
/**
* The current <code>mime-type</code>.
*/
protected String mimetype;
/**
* Should we set the content length ?
*/
protected boolean setContentLength = true;
/**
* Manager to get URLFactory from.
*/
protected ServiceManager manager;
private Map rendererOptions;
/**
* Set the component manager for this serializer.
*/
public void service(ServiceManager manager) throws ServiceException {
this.manager = manager;
this.resolver = (SourceResolver) this.manager.lookup(SourceResolver.ROLE);
}
/**
* Set the configurations for this serializer.
*/
public void configure(Configuration conf) throws ConfigurationException {
//should the content length be set
this.setContentLength = conf.getChild("set-content-length").getValueAsBoolean(true);
String configUrl = conf.getChild("user-config").getValue(null);
if (configUrl != null) {
Source configSource = null;
SourceResolver resolver = null;
try {
resolver = (SourceResolver)this.manager.lookup(SourceResolver.ROLE);
configSource = resolver.resolveURI(configUrl);
if (getLogger().isDebugEnabled()) {
getLogger().debug("Loading configuration from " + configSource.getURI());
}
SAXConfigurationHandler configHandler = new SAXConfigurationHandler();
SourceUtil.toSAX(configSource, configHandler);
fopfactory.setUserConfig(configHandler.getConfiguration());
} catch (Exception e) {
getLogger().warn("Cannot load configuration from " + configUrl);
throw new ConfigurationException("Cannot load configuration from " + configUrl, e);
} finally {
if (resolver != null) {
resolver.release(configSource);
manager.release(resolver);
}
}
}
fopfactory.setURIResolver(this);
// Get the mime type.
this.mimetype = conf.getAttribute("mime-type");
Configuration confRenderer = conf.getChild("renderer-config");
if (confRenderer != null) {
Configuration[] parameters = confRenderer.getChildren("parameter");
if (parameters.length > 0) {
rendererOptions = new HashMap();
for (int i = 0; i < parameters.length; i++) {
String name = parameters[i].getAttribute("name");
String value = parameters[i].getAttribute("value");
if (getLogger().isDebugEnabled()) {
getLogger().debug("renderer " + String.valueOf(name) + " = " + String.valueOf(value));
}
}
}
}
}
/**
* Recycle serializer by removing references
*/
public void recycle() {
super.recycle();
this.fop = null;
}
public void dispose() {
if (this.resolver != null) {
this.manager.release(this.resolver);
this.resolver = null;
}
this.manager = null;
}
// -----------------------------------------------------------------
/**
* Return the MIME type.
*/
public String getMimeType() {
return mimetype;
}
/**
* Create the FOP driver
* Set the <code>OutputStream</code> where the XML should be serialized.
* @throws IOException
*/
public void setOutputStream(OutputStream out) throws IOException {
// Give the source resolver to Batik which is used by FOP
//SourceProtocolHandler.setup(this.resolver);
FOUserAgent userAgent = fopfactory.newFOUserAgent();
if (this.rendererOptions != null) {
userAgent.getRendererOptions().putAll(this.rendererOptions);
}
try {
this.fop = fopfactory.newFop(getMimeType(), userAgent, out);
setContentHandler(this.fop.getDefaultHandler());
} catch (FOPException e) {
getLogger().error("FOP setup failed", e);
throw new IOException("Unable to setup fop: " + e.getLocalizedMessage());
}
}
/**
* 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 Serializable getKey() {
return "1";
}
/**
* 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() {
return NOPValidity.SHARED_INSTANCE;
}
/**
* Test if the component wants to set the content length
*/
public boolean shouldSetContentLength() {
return this.setContentLength;
}
//From URIResolver, copied from TraxProcessor
public javax.xml.transform.Source resolve(String href, String base) throws TransformerException {
if (getLogger().isDebugEnabled()) {
getLogger().debug("resolve(href = " + href + ", base = " + base + "); resolver = " + resolver);
}
StreamSource streamSource = null;
Source source = null;
try {
if (base == null || href.indexOf(":") > 1) {
// Null base - href must be an absolute URL
source = resolver.resolveURI(href);
} else if (href.length() == 0) {
// Empty href resolves to base
source = resolver.resolveURI(base);
} else {
// is the base a file or a real m_url
if (!base.startsWith("file:")) {
int lastPathElementPos = base.lastIndexOf('/');
if (lastPathElementPos == -1) {
// this should never occur as the base should
// always be protocol:/....
return null; // we can't resolve this
} else {
source = resolver.resolveURI(base.substring(0, lastPathElementPos) + "/" + href);
}
} else {
File parent = new File(base.substring(5));
File parent2 = new File(parent.getParentFile(), href);
source = resolver.resolveURI(parent2.toURI().toURL().toExternalForm());
}
}
if (getLogger().isDebugEnabled()) {
getLogger().debug("source = " + source + ", system id = " + source.getURI());
}
streamSource = new StreamSource(new ReleaseSourceInputStream(source.getInputStream(), source, resolver), source.getURI());
} catch (SourceException e) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Failed to resolve " + href + "(base = " + base + "), return null", e);
}
// CZ: To obtain the same behaviour as when the resource is
// transformed by the XSLT Transformer we should return null here.
return null;
} catch (java.net.MalformedURLException mue) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Failed to resolve " + href + "(base = " + base + "), return null", mue);
}
return null;
} catch (IOException ioe) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Failed to resolve " + href + "(base = " + base + "), return null", ioe);
}
return null;
} finally {
// If streamSource is not null, the source should only be released when the input stream
// is not needed anymore.
if (streamSource == null)
resolver.release(source);
}
return streamSource;
}
/**
* An InputStream which releases the Cocoon/Avalon source from which the InputStream
* has been retrieved when the stream is closed.
*/
public static class ReleaseSourceInputStream extends InputStream {
private InputStream delegate;
private Source source;
private SourceResolver sourceResolver;
private ReleaseSourceInputStream(InputStream delegate, Source source, SourceResolver sourceResolver) {
this.delegate = delegate;
this.source = source;
this.sourceResolver = sourceResolver;
}
public void close() throws IOException {
delegate.close();
sourceResolver.release(source);
}
public int read() throws IOException {
return delegate.read();
}
public int read(byte b[]) throws IOException {
return delegate.read(b);
}
public int read(byte b[], int off, int len) throws IOException {
return delegate.read(b, off, len);
}
public long skip(long n) throws IOException {
return delegate.skip(n);
}
public int available() throws IOException {
return delegate.available();
}
public synchronized void mark(int readlimit) {
delegate.mark(readlimit);
}
public synchronized void reset() throws IOException {
delegate.reset();
}
public boolean markSupported() {
return delegate.markSupported();
}
}
}