XSLTProcessor.java

/* 
 * 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.felix.mosgi.jmx.httpconnector.mx4j.tools.adaptor.http;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;

import javax.management.MBeanException;
import javax.management.ReflectionException;
import javax.management.RuntimeMBeanException;
import javax.xml.transform.Source;
import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.URIResolver;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.w3c.dom.Document;

import org.osgi.framework.ServiceReference;

import org.osgi.service.log.LogService;

import org.apache.felix.mosgi.jmx.httpconnector.HttpConnectorActivator;


/**
 * XSLTPostProcessor pass the document through an XSLT transformation
 *
 * @author <a href="mailto:tibu@users.sourceforge.net">Carlos Quiroz</a>
 * @version $Revision: 1.1.1.1 $
 * the HttpAdaptor through a XSL transformation" extends="mx4j.tools.adaptor.http.ProcessorMBean"
 */
public class XSLTProcessor
	implements ProcessorMBean, XSLTProcessorMBean, URIResolver
{
	TransformerFactory factory = null;

	private Map templatesCache = new HashMap();

	private String path = "mx4j/tools/adaptor/http/xsl";

	private File root = null;

	private Map mimeTypes = new HashMap();

	/** Indicated whether the file are read from a file */
	private boolean useJar = true;

	private boolean useCache = true;

	private ClassLoader targetClassLoader = ClassLoader.getSystemClassLoader();

	private String defaultPage = "serverbydomain";

	/**
	 * The locale is set with the default as en_US since it is the
	 * one bundled
	 */
	private Locale locale = new Locale("en", "");

	public XSLTProcessor()
	{
		factory = TransformerFactory.newInstance();
		factory.setURIResolver(this);
		mimeTypes.put(".gif", "image/gif");
		mimeTypes.put(".jpg", "image/jpg");
		mimeTypes.put(".png", "image/png");
		mimeTypes.put(".tif", "image/tiff");
		mimeTypes.put(".tiff", "image/tiff");
		mimeTypes.put(".ico", "image/ico");
		mimeTypes.put(".html", "text/html");
		mimeTypes.put(".htm", "text/html");
		mimeTypes.put(".txt", "text/plain");
		mimeTypes.put(".xml", "text/xml");
		mimeTypes.put(".xsl", "text/xsl");
		mimeTypes.put(".css", "text/css");
		mimeTypes.put(".js", "text/x-javascript");
		mimeTypes.put(".jar", "application/java-archive");
	}

	public void writeResponse(HttpOutputStream out, HttpInputStream in, Document document) throws IOException
	{
		out.setCode(HttpConstants.STATUS_OKAY);
		out.setHeader("Content-Type", "text/html");
		// added some caching attributes to fornce not to cache
		out.setHeader("Cache-Control", "no-cache");
		out.setHeader("expires", "now");
		out.setHeader("pragma", "no-cache");
		out.sendHeaders();
		Transformer transformer = null;
		String path = preProcess(in.getPath());

		if (in.getVariable("template") != null)
		{
			transformer = createTransformer(in.getVariable("template") + ".xsl");
		}
		else
		{
			transformer = createTransformer(path + ".xsl");
		}

		if (transformer != null)
		{
			// added so that the document() function works
			transformer.setURIResolver(this);
			// The variables are passed to the XSLT as (param.name, value)
			Map variables = in.getVariables();
			Iterator j = variables.keySet().iterator();
			while (j.hasNext())
			{
				String key = (String)j.next();
				Object value = variables.get(key);
				if (value instanceof String) {
					transformer.setParameter("request." + key, value);
				}
				if (value instanceof String[]) {
					String[] allvalues = (String[])value;
					// not a good solution, only the first one is presented
					transformer.setParameter("request." + key, allvalues[0]);
				}

			}
			if (!variables.containsKey("locale"))
			{
				transformer.setParameter("request.locale", locale.toString());
			}
			try
			{
				ByteArrayOutputStream output = new ByteArrayOutputStream();
				XSLTProcessor.log(LogService.LOG_DEBUG,"transforming " + path,null);
				transformer.transform(new DOMSource(document), new StreamResult(output));
				output.writeTo(out);
			}
			catch (TransformerException e)
			{
				XSLTProcessor.log(LogService.LOG_ERROR,"Transformation exception ", e);
			}
		}
		else
		{
			XSLTProcessor.log(LogService.LOG_WARNING,"Transformer for path " + path + " not found",null);
		}
	}

	protected Transformer createTransformer(String path)
	{
		Transformer transformer = null;
		try
		{
			if (useCache && templatesCache.containsKey(path))
			{
				transformer = ((Templates)templatesCache.get(path)).newTransformer();
			}
			else
			{
				InputStream file = getInputStream(path);
				if (file != null)
				{
					XSLTProcessor.log(LogService.LOG_INFO,"Creating template for path "+path, null);
					Templates template = factory.newTemplates(new StreamSource(file));
					transformer = template.newTransformer();
					if (useCache)
					{
						templatesCache.put(path, template);
					}
				}
				else
				{
					XSLTProcessor.log(LogService.LOG_WARNING,"template for path "+path+" not found", null);
				}
			}
		}
		catch (TransformerConfigurationException e)
		{
			XSLTProcessor.log(LogService.LOG_ERROR,"Exception during template construction", e);
		}
		return transformer;
	}

	protected void processHttpException(HttpInputStream in, HttpOutputStream out, HttpException e) throws IOException
	{
		out.setCode(e.getCode());
		out.setHeader("Content-Type", "text/html");
		out.sendHeaders();
		// hardcoded dir :-P
		Transformer transformer = createTransformer("error.xsl");
		transformer.setURIResolver(this);
		Document doc = e.getResponseDoc();
		if (doc != null)
		{
			try
			{
				if (!in.getVariables().containsKey("locale"))
				{
					transformer.setParameter("request.locale", locale.toString());
				}
				ByteArrayOutputStream output = new ByteArrayOutputStream();
				transformer.transform(new DOMSource(doc), new StreamResult(output));
				output.writeTo(out);
			}
			catch (TransformerException ex)
			{
				XSLTProcessor.log(LogService.LOG_ERROR,"Exception during error output", ex);
			}
		}
	}

	public void writeError(HttpOutputStream out, HttpInputStream in, Exception e) throws IOException
	{
		Exception t = e;
		if (e instanceof RuntimeMBeanException)
		{
			t = ((RuntimeMBeanException)e).getTargetException();
		}
		XSLTProcessor.log(LogService.LOG_INFO,"Processing error " + t.getMessage(),null);
		if (t instanceof HttpException)
		{
			processHttpException(in, out, (HttpException)e);
		}
		else if ((t instanceof MBeanException) && (((MBeanException)t).getTargetException() instanceof HttpException))
		{
			processHttpException(in, out, (HttpException)((MBeanException)t).getTargetException());
		}
		else if ((t instanceof ReflectionException) && (((ReflectionException)t).getTargetException() instanceof HttpException))
		{
			processHttpException(in, out, (HttpException)((ReflectionException)t).getTargetException());
		}
		else
		{
			out.setCode(HttpConstants.STATUS_INTERNAL_ERROR);
			out.setHeader("Content-Type", "text/html");
			out.sendHeaders();
		}
	}

	public String preProcess(String path) {
		if (path.equals("/"))
		{
			path = "/" + defaultPage;
		}
		return path;
	}

	public String notFoundElement(String path, HttpOutputStream out, HttpInputStream in) throws IOException, HttpException
	{
		File file = new File(this.path, path);
		XSLTProcessor.log(LogService.LOG_INFO,"Processing file request " + file,null);
		String name = file.getName();
		int extensionIndex = name.lastIndexOf('.');
		String mime = null;
		if (extensionIndex < 0)
		{
			XSLTProcessor.log(LogService.LOG_WARNING,"Filename has no extensions " + file.toString(),null);
			mime = "text/plain";
		}
		else
		{
			String extension = name.substring(extensionIndex, name.length());
			if (mimeTypes.containsKey(extension))
			{
				mime = (String)mimeTypes.get(extension);
			} else {
				XSLTProcessor.log(LogService.LOG_WARNING,"MIME type not found " + extension,null);
				mime = "text/plain";
			}
		}
		try
		{
			XSLTProcessor.log(LogService.LOG_DEBUG,"Trying to read file " + file,null);
			BufferedInputStream fileIn = new BufferedInputStream(getInputStream(path));
			ByteArrayOutputStream outArray = new ByteArrayOutputStream();
			BufferedOutputStream outBuffer = new BufferedOutputStream(outArray);
			int piece = 0;
			while ((piece = fileIn.read()) >= 0)
			{
				outBuffer.write(piece);
			}
			outBuffer.flush();
			out.setCode(HttpConstants.STATUS_OKAY);
			out.setHeader("Content-type", mime);
			out.sendHeaders();
			XSLTProcessor.log(LogService.LOG_DEBUG,"File output " + mime,null);
			outArray.writeTo(out);
			fileIn.close();
		}
		catch (Exception e)
		{
			XSLTProcessor.log(LogService.LOG_WARNING,"Exception loading file " + file, e);
			throw new HttpException(HttpConstants.STATUS_NOT_FOUND, "file " + file + " not found");
		}
		return null;
	}

	protected InputStream getInputStream(String path)
	{
		InputStream file = null;
		if (!useJar)
		{
			try
			{
				// load from a dir
				file = new FileInputStream(new File(this.root, path));
			}
			catch (FileNotFoundException e)
			{
				XSLTProcessor.log(LogService.LOG_ERROR,"File not found", e);
			}
		}
		else
		{
			// load from a jar
			String targetFile = this.path;
			// workaround, should tought of somehting better
			if (path.startsWith("/"))
			{
				targetFile += path;
			} else {
				targetFile += "/" + path;
			}
			if (root != null)
			{
				file = targetClassLoader.getResourceAsStream(targetFile);
			}
			if (file == null)
			{
				ClassLoader cl=getClass().getClassLoader();
				if (cl == null)
				{
					file = ClassLoader.getSystemClassLoader().getResourceAsStream(targetFile);
				}
				else
				{
					file = getClass().getClassLoader().getResourceAsStream(targetFile);
				}
				file = getClass().getClassLoader().getResourceAsStream(targetFile);
			}
		}

		return file;
	}

	public Source resolve(String href, String base)
	{
		StreamSource source = new StreamSource(getInputStream(href));
		// this works with saxon7/saxon6.5.2/xalan
		source.setSystemId(href);
		return source;
	}

	public void setFile(String file)
	{
		if (file != null)
		{

			File target = new File(file);
			if (!target.exists())
			{
				XSLTProcessor.log(LogService.LOG_WARNING,"Target file " + file + " does not exist, defaulting to previous",null);
				return;
			}
			if (target.isDirectory())
			{
				useJar = false;
				XSLTProcessor.log(LogService.LOG_INFO, "Using " + file + " as the root dir", null);
				this.root = target;
				return;
			}
			if (target.isFile() && (target.getName().endsWith(".jar") ||
				(target.getName().endsWith(".zip"))))
			{
				try {
					URL url = target.toURL();
					targetClassLoader = new URLClassLoader(new URL[] {url});
					XSLTProcessor.log(LogService.LOG_INFO,"Using compressed file " + url + " as the root file",null);
					this.root = target;
					useJar = true;
				} catch (MalformedURLException e) {
					XSLTProcessor.log(LogService.LOG_WARNING,"Unable to create class loader", e);
				}
			}
			else
			{
				XSLTProcessor.log(LogService.LOG_WARNING,"Target file " + file + " does not exist, defaulting to previous",null);
			}
		}
	}

	public String getFile()
	{
		return (root != null)?root.getName():null;
	}

	public String getPathInJar()
	{
		return path;
	}

	public void setPathInJar(String path)
	{
		this.path = path;
	}

	public String getDefaultPage()
	{
		return defaultPage;
	}

	public void setDefaultPage(String defaultPage)
	{
		this.defaultPage = defaultPage;
	}

	public boolean isUseJar()
	{
		return useJar;
	}

	public boolean isUsePath()
	{
		return !useJar;
	}

	public void addMimeType(String extension, String type)
	{
		if (extension != null && type != null)
		{
			XSLTProcessor.log(LogService.LOG_INFO,"Added MIME type " + type + " for extension " + extension,null);
			mimeTypes.put(extension, type);
		}
	}

	public void setUseCache(boolean useCache)
	{
		this.useCache = useCache;
	}

	public boolean isUseCache()
	{
		return useCache;
	}

	public String getName()
	{
		return "XSLT Processor";
	}

	public Locale getLocale() {
		return locale;
	}

	public void setLocale(Locale locale) {
		this.locale = locale;
	}

	public void setLocaleString(String locale) {
		if (locale == null || locale.length()==0) {
		  this.locale = new Locale("en", "");
		}
		else
		{
		  // split locale based on underbar
		  StringTokenizer tknzr = new StringTokenizer(locale,"_");
		  String language = tknzr.nextToken();
		  String country = "";
		  String variant = "";
		  if (tknzr.hasMoreTokens())
		    country = tknzr.nextToken();
		  if (tknzr.hasMoreTokens())
		    variant = tknzr.nextToken();
		  this.locale = new Locale(language,country,variant);
		}
	}

    private static void log(int prio, String message, Throwable t){
    if (HttpConnectorActivator.bc!=null){
    ServiceReference logSR=HttpConnectorActivator.bc.getServiceReference(LogService.class.getName());
    if (logSR!=null){
      ((LogService)HttpConnectorActivator.bc.getService(logSR)).log(prio, message, t);
    }else{
      System.out.println("No Log Service");
    }
    }else{
      System.out.println("mx4j.tools.adapatoir.http.XSLTProcessor.log: No bundleContext");
    }
  }

}