/* InterpreterServlet.java
Purpose:
Description:
History:
Mon Sep 5 17:06:34 2005, Created by tomyeh
Copyright (C) 2005 Potix Corporation. All Rights Reserved.
{{IS_RIGHT
This program is distributed under LGPL Version 2.1 in the hope that
it will be useful, but WITHOUT ANY WARRANTY.
}}IS_RIGHT
*/
package org.zkoss.web.servlet.dsp;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.StringWriter;
import java.net.URL;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.zkoss.io.Files;
import org.zkoss.lang.Exceptions;
import org.zkoss.util.resource.Locator;
import org.zkoss.web.servlet.Charsets;
import org.zkoss.web.servlet.Servlets;
import org.zkoss.web.servlet.http.Https;
import org.zkoss.web.util.resource.ClassWebResource;
import org.zkoss.web.util.resource.ResourceCache;
import org.zkoss.web.util.resource.ResourceCaches;
import org.zkoss.web.util.resource.ResourceLoader;
import org.zkoss.xel.taglib.Taglibs;
import org.zkoss.xml.XMLs;
/**
* The servlet used to interpret the DSP file (Potix Dynamic Script Page).
*
* <p>Initial parameters:
* <dl>
* <dt>charset</dt>
* <dd>The default character set if not specified in the DSP page.<br/>
* Default: UTF-8.</dd>
* <dt>class-resource</dt>
* <dd>Whether to search the class loader if a resource is not found
* in the Web application (i.e., ServletContext).</dd>
* Default: false.</dd>
* </dl>
*
* @author tomyeh
*/
public class InterpreterServlet extends HttpServlet {
private static final Logger log = LoggerFactory.getLogger(InterpreterServlet.class);
private String _charset = "UTF-8";
private Locator _locator;
private boolean _compress = true;
public void init() throws ServletException {
final ServletContext ctx = getServletContext();
final ServletConfig config = getServletConfig();
String param = config.getInitParameter("compress");
if (param != null)
_compress = "true".equals(param);
param = config.getInitParameter("class-resource");
final boolean bClsRes = "true".equals(param);
_locator = new Locator() {
public String getDirectory() {
return null; //FUTURE: support relative path
}
public URL getResource(String name) {
URL url = null;
if (name.indexOf("://") < 0) {
try {
url = ctx.getResource(name);
if (bClsRes && url == null)
url = ClassWebResource.getClassResource(name);
} catch (java.net.MalformedURLException ex) { //eat it
}
}
return url != null ? url : Taglibs.getDefaultURL(name);
}
public InputStream getResourceAsStream(String name) {
InputStream is = ctx.getResourceAsStream(name);
return !bClsRes || is != null ? is : ClassWebResource.getClassResourceAsStream(name);
}
};
param = config.getInitParameter("charset");
if (param != null)
_charset = param.length() > 0 ? param : null;
}
//-- super --//
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Servlets.getBrowser(request); //update request info
final String path = Https.getThisServletPath(request);
if (log.isDebugEnabled())
log.debug("Get " + path);
final Object old = Charsets.setup(request, response, _charset);
final ServletContext ctx = getServletContext();
try {
final Interpretation cnt = (Interpretation) ResourceCaches.get(getCache(), ctx, path, null);
if (cnt == null) {
if (Https.isIncluded(request))
log.error("Not found: " + path);
//It might be eaten, so log the error
response.sendError(HttpServletResponse.SC_NOT_FOUND, XMLs.escapeXML(path));
return;
}
final boolean compress = _compress && !Servlets.isIncluded(request);
final StringWriter out = compress ? new StringWriter() : null;
cnt.interpret(new ServletDspContext(ctx, request, response, out, null));
if (compress) {
final String result = out.toString();
try {
final OutputStream os = response.getOutputStream();
//Call it first to ensure getWrite() is not called yet
byte[] data = result.getBytes("UTF-8");
if (data.length > 200) {
byte[] bs = Https.gzip(request, response, null, data);
if (bs != null)
data = bs; //yes, browser support compress
}
response.setContentLength(data.length);
os.write(data);
response.flushBuffer();
} catch (IllegalStateException ex) { //getWriter is called
response.getWriter().write(result);
}
}
} finally {
Charsets.cleanup(request, old);
}
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
private static final String ATTR_PAGE_CACHE = "org.zkoss.web.servlet.dsp.PageCache";
@SuppressWarnings("unchecked")
private final ResourceCache<Interpretation> getCache() {
final ServletContext ctx = getServletContext();
ResourceCache cache = (ResourceCache) ctx.getAttribute(ATTR_PAGE_CACHE);
if (cache == null) {
synchronized (InterpreterServlet.class) {
cache = (ResourceCache) ctx.getAttribute(ATTR_PAGE_CACHE);
if (cache == null) {
cache = new ResourceCache(new MyLoader(), 29);
cache.setMaxSize(1024);
cache.setLifetime(60 * 60 * 1000); //1hr
ctx.setAttribute(ATTR_PAGE_CACHE, cache);
}
}
}
return cache;
}
private class MyLoader extends ResourceLoader<Interpretation> {
private MyLoader() {
}
//-- super --//
protected Interpretation parse(String path, File file, Object extra) throws Exception {
final InputStream is = new BufferedInputStream(new FileInputStream(file));
try {
return parse0(is, Interpreter.getContentType(file.getName()));
} catch (Exception ex) {
if (log.isDebugEnabled())
log.error("Failed to parse " + file, ex);
else
log.error("Failed to parse " + file + "\nCause: " + Exceptions.getMessage(ex) + "\n"
+ Exceptions.getBriefStackTrace(ex));
return null; //as non-existent
} finally {
Files.close(is);
}
}
protected Interpretation parse(String path, URL url, Object extra) throws Exception {
InputStream is = url.openStream();
if (is != null)
is = new BufferedInputStream(is);
try {
return parse0(is, Interpreter.getContentType(url.getPath()));
} catch (Exception ex) {
if (log.isDebugEnabled())
log.error("Failed to parse " + url, ex);
else
log.error("Failed to parse " + url + "\nCause: " + Exceptions.getMessage(ex));
return null; //as non-existent
} finally {
Files.close(is);
}
}
private Interpretation parse0(InputStream is, String ctype) throws Exception {
if (is == null)
return null;
final String content = Files.readAll(new InputStreamReader(is, "UTF-8")).toString();
return new Interpreter().parse(content, ctype, null, _locator);
}
}
}