org.apache.myfaces.renderkit.html.util.NonBufferingAddResource Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of tomahawk12 Show documentation
Show all versions of tomahawk12 Show documentation
JSF components and utilities that can be used with any JSF implementation.
This library is based on the JSF1.1 version of Tomahawk, but with minor source code and build
changes to take advantage of JSF1.2 features. A JSF1.2 implementation is required to use this
version of the Tomahawk library.
The newest version!
/*
* 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.myfaces.renderkit.html.util;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.myfaces.shared_tomahawk.config.MyfacesConfig;
import org.apache.myfaces.shared_tomahawk.renderkit.html.HTML;
import org.apache.myfaces.shared_tomahawk.renderkit.html.HtmlRendererUtils;
import org.apache.myfaces.shared_tomahawk.renderkit.html.HtmlResponseWriterImpl;
import org.apache.myfaces.shared_tomahawk.util.ClassUtils;
import javax.faces.FacesException;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Map;
/**
* @since 1.1.7
* @author Martin Marinschek
*/
public class NonBufferingAddResource implements AddResource {
protected static final String PATH_SEPARATOR = "/";
protected String _contextPath;
private static final String RESOURCES_CACHE_KEY = AddResource.class.getName() + ".CACHE_KEY";
private String resourceVirtualPath;
protected Log log = LogFactory.getLog(NonBufferingAddResource.class);
/**
* the context path for the web-app.
* You can set the context path only once, every subsequent set will throw an SecurityException
*/
public void setContextPath(String contextPath)
{
if (_contextPath != null)
{
throw new SecurityException("context path already set");
}
_contextPath = contextPath;
}
// Methods to add resources
/**
* Insert a [script src="url"] entry at the current location in the response.
* The resource is expected to be in the classpath, at the same location as the
* specified component + "/resource".
*
* Example: when customComponent is class example.Widget, and
* resourceName is script.js, the resource will be retrieved from
* "example/Widget/resource/script.js" in the classpath.
*/
public void addJavaScriptHere(FacesContext context, Class myfacesCustomComponent,
String resourceName) throws IOException
{
addJavaScriptHere(context, new MyFacesResourceHandler(myfacesCustomComponent, resourceName));
}
/**
* Insert a [script src="url"] entry at the current location in the response.
*
* @param uri is the location of the desired resource, relative to the base
* directory of the webapp (ie its contextPath).
*/
public void addJavaScriptHere(FacesContext context, String uri) throws IOException
{
writeJavaScriptReference(context, getResourceUri(context, uri), true, false);
}
protected static void writeJavaScriptReference(FacesContext context, String resourceUri, boolean encoding, boolean defer) throws IOException{
ResponseWriter writer = context.getResponseWriter();
String src = null;
if(encoding) {
src=context.getExternalContext().encodeResourceURL(resourceUri);
}
else {
src = resourceUri;
}
writeJavaScriptReference(defer, writer, src);
}
protected static void writeJavaScriptReference(HttpServletResponse response, ResponseWriter writer, String resourceUri, boolean encoding, boolean defer) throws IOException {
String src = null;
if(encoding) {
src=response.encodeURL(resourceUri);
}
else {
src = resourceUri;
}
writeJavaScriptReference(defer, writer, src);
}
private static void writeJavaScriptReference(boolean defer, ResponseWriter writer, String src) throws IOException {
writer.startElement(org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.SCRIPT_ELEM, null);
writer.writeAttribute(org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.SCRIPT_TYPE_ATTR, org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.SCRIPT_TYPE_TEXT_JAVASCRIPT, null);
if(defer) {
writer.writeAttribute(org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.SCRIPT_ELEM_DEFER_ATTR, "true", null);
}
writer.writeURIAttribute(org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.SRC_ATTR, src, null);
writer.endElement(HTML.SCRIPT_ELEM);
}
protected static void writeStyleReference(FacesContext context, String resourceUri) throws IOException {
ResponseWriter writer = context.getResponseWriter();
writer.startElement(HTML.LINK_ELEM, null);
writer.writeAttribute(org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.REL_ATTR, org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.STYLESHEET_VALUE, null);
writer.writeAttribute(HTML.HREF_ATTR, context.getExternalContext().encodeResourceURL(resourceUri), null);
writer.writeAttribute(HTML.TYPE_ATTR, HTML.STYLE_TYPE_TEXT_CSS, null);
writer.endElement(org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.LINK_ELEM);
}
protected static void writeStyleReference(HttpServletResponse response, ResponseWriter writer, String resourceUri) throws IOException {
writer.startElement(HTML.LINK_ELEM, null);
writer.writeAttribute(org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.REL_ATTR, org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.STYLESHEET_VALUE, null);
writer.writeAttribute(HTML.HREF_ATTR, response.encodeURL(resourceUri), null);
writer.writeAttribute(HTML.TYPE_ATTR, HTML.STYLE_TYPE_TEXT_CSS, null);
writer.endElement(org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.LINK_ELEM);
}
protected static void writeInlineScript(ResponseWriter writer, String inlineScript) throws IOException {
writer.startElement(HTML.SCRIPT_ELEM, null);
writer.writeAttribute(HTML.SCRIPT_TYPE_ATTR, org.apache.myfaces.shared_tomahawk.renderkit.html.HTML.SCRIPT_TYPE_TEXT_JAVASCRIPT, null);
writer.writeText(inlineScript, null);
writer.endElement(HTML.SCRIPT_ELEM);
}
protected static void writeInlineStylesheet(ResponseWriter writer, String inlineStyle) throws IOException {
writer.startElement(HTML.STYLE_ELEM, null);
writer.writeAttribute(HTML.REL_ATTR, HTML.STYLESHEET_VALUE, null);
writer.writeAttribute(HTML.TYPE_ATTR, HTML.STYLE_TYPE_TEXT_CSS, null);
writer.writeText(inlineStyle, null);
writer.endElement(HTML.STYLE_ELEM);
}
public void addJavaScriptHerePlain(FacesContext context, String uri) throws IOException
{
writeJavaScriptReference(context, getResourceUri(context, uri), false, false);
}
/**
* Insert a [script src="url"] entry at the current location in the response.
*
* @param context The current faces-context
* @param resourceHandler is an object which specifies exactly how to build the url
* that is emitted into the script tag. Code which needs to generate URLs in ways
* that this class does not support by default can implement a custom ResourceHandler.
* @throws IOException
*/
public void addJavaScriptHere(FacesContext context, ResourceHandler resourceHandler)
throws IOException
{
validateResourceHandler(resourceHandler);
writeJavaScriptReference(context, getResourceUri(context, resourceHandler), true, false);
}
public void addResourceHere(FacesContext context, ResourceHandler resourceHandler)
throws IOException
{
validateResourceHandler(resourceHandler);
String path = getResourceUri(context, resourceHandler);
ResponseWriter writer = context.getResponseWriter();
writer.write(context.getExternalContext().encodeResourceURL(path));
}
/**
* Verify that the resource handler is acceptable. Null is not
* valid, and the getResourceLoaderClass method must return a
* Class object whose instances implements the ResourceLoader
* interface.
*
* @param resourceHandler handler to check
*/
protected void validateResourceHandler(ResourceHandler resourceHandler)
{
if (resourceHandler == null)
{
throw new IllegalArgumentException("ResourceHandler is null");
}
validateResourceLoader(resourceHandler.getResourceLoaderClass());
}
/**
* Given a Class object, verify that the instances of that class
* implement the ResourceLoader interface.
*
* @param resourceloader loader to check
*/
protected void validateResourceLoader(Class resourceloader)
{
if (!ResourceLoader.class.isAssignableFrom(resourceloader))
{
throw new FacesException("Class " + resourceloader.getName() + " must implement "
+ ResourceLoader.class.getName());
}
}
public void addJavaScriptAtPosition(FacesContext context, ResourcePosition position, ResourceHandler resourceHandler) {
try {
writeJavaScriptReference(context,getResourceUri(context,resourceHandler),true,false);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addJavaScriptAtPosition(FacesContext context, ResourcePosition position, Class myfacesCustomComponent, String resourceName) {
try {
writeJavaScriptReference(context,getResourceUri(context,new MyFacesResourceHandler(
myfacesCustomComponent, resourceName)),true,false);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addJavaScriptAtPosition(FacesContext context, ResourcePosition position, Class myfacesCustomComponent, String resourceName, boolean defer) {
try {
writeJavaScriptReference(context,getResourceUri(context,new MyFacesResourceHandler(
myfacesCustomComponent, resourceName)),true,true);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addJavaScriptAtPosition(FacesContext context, ResourcePosition position, String uri) {
try {
writeJavaScriptReference(context,getResourceUri(context,uri),true,false);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addJavaScriptAtPosition(FacesContext context, ResourcePosition position, String uri, boolean defer) {
try {
writeJavaScriptReference(context,getResourceUri(context,uri),true,true);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
/**
*
* @param context
* @param javascriptEventName
* @param addedJavaScript
*
* @deprecated
*/
public void addJavaScriptToBodyTag(FacesContext context, String javascriptEventName, String addedJavaScript) {
throw new UnsupportedOperationException("not supported anymore - use javascript to register your body-event-handler directly");
}
public void addJavaScriptAtPosition(FacesContext context, ResourcePosition position, ResourceHandler resourceHandler, boolean defer) {
try {
writeJavaScriptReference(context,getResourceUri(context,resourceHandler),true,defer);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addJavaScriptAtPositionPlain(FacesContext context, ResourcePosition position, Class myfacesCustomComponent, String resourceName) {
try {
writeJavaScriptReference(context,getResourceUri(context,new MyFacesResourceHandler(myfacesCustomComponent, resourceName)),false,false);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addStyleSheet(FacesContext context, ResourcePosition position, Class myfacesCustomComponent, String resourceName) {
try {
writeStyleReference(context,getResourceUri(context,new MyFacesResourceHandler(myfacesCustomComponent, resourceName)));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addStyleSheet(FacesContext context, ResourcePosition position, String uri) {
try {
writeStyleReference(context,getResourceUri(context,uri));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addStyleSheet(FacesContext context, ResourcePosition position, ResourceHandler resourceHandler) {
try {
writeStyleReference(context,getResourceUri(context,resourceHandler));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addInlineStyleAtPosition(FacesContext context, ResourcePosition position, String inlineStyle) {
try {
writeInlineStylesheet(context.getResponseWriter(), inlineStyle);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public void addInlineScriptAtPosition(FacesContext context, ResourcePosition position, String inlineScript) {
try {
writeInlineScript(context.getResponseWriter(), inlineScript);
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public String getResourceUri(FacesContext context, Class myfacesCustomComponent,
String resource, boolean withContextPath)
{
return getResourceUri(context,
new MyFacesResourceHandler(myfacesCustomComponent, resource), withContextPath);
}
public String getResourceUri(FacesContext context, Class myfacesCustomComponent, String resource)
{
return getResourceUri(context, new MyFacesResourceHandler(myfacesCustomComponent, resource));
}
/**
* Get the Path used to retrieve an resource.
*/
public String getResourceUri(FacesContext context, ResourceHandler resourceHandler)
{
String uri = resourceHandler.getResourceUri(context);
if (uri == null)
{
return getResourceUri(context, resourceHandler.getResourceLoaderClass(), true);
}
return getResourceUri(context, resourceHandler.getResourceLoaderClass(), true) + uri;
}
/**
* Get the Path used to retrieve an resource.
*/
public String getResourceUri(FacesContext context, ResourceHandler resourceHandler,
boolean withContextPath)
{
String uri = resourceHandler.getResourceUri(context);
if (uri == null)
{
return getResourceUri(context, resourceHandler.getResourceLoaderClass(),
withContextPath);
}
return getResourceUri(context, resourceHandler.getResourceLoaderClass(), withContextPath)
+ uri;
}
/**
* Get the Path used to retrieve an resource.
*/
public String getResourceUri(FacesContext context, String uri)
{
return getResourceUri(context, uri, true);
}
/**
* Get the Path used to retrieve an resource.
*/
public String getResourceUri(FacesContext context, String uri, boolean withContextPath)
{
if (withContextPath)
{
return context.getApplication().getViewHandler().getResourceURL(context, uri);
}
return uri;
}
/**
* Get the Path used to retrieve an resource.
* @param context current faces-context
* @param resourceLoader resourceLoader
* @param withContextPath use the context-path of the web-app when accessing the resources
*
* @return the URI of the resource
*/
protected String getResourceUri(FacesContext context, Class resourceLoader,
boolean withContextPath)
{
StringBuffer sb = new StringBuffer(200);
sb.append(MyfacesConfig.getCurrentInstance(context.getExternalContext()).getResourceVirtualPath());
sb.append(PATH_SEPARATOR);
sb.append(resourceLoader.getName());
sb.append(PATH_SEPARATOR);
sb.append(getCacheKey(context));
sb.append(PATH_SEPARATOR);
return getResourceUri(context, sb.toString(), withContextPath);
}
/**
* Return a value used in the {cacheKey} part of a generated URL for a
* resource reference.
*
* Caching in browsers normally works by having files served to them
* include last-modified and expiry-time http headers. Until the expiry
* time is reached, a browser will silently use its cached version. After
* the expiry time, it will send a "get if modified since {time}" message,
* where {time} is the last-modified header from the version it has cached.
*
* Unfortunately this scheme only works well for resources represented as
* plain files on disk, where the webserver can easily and efficiently see
* the last-modified time of the resource file. When that query has to be
* processed by a servlet that doesn't scale well, even when it is possible
* to determine the resource's last-modified date from servlet code.
*
* Fortunately, for the AddResource class a static resource is only ever
* accessed because a URL was embedded by this class in a dynamic page.
* This makes it possible to implement caching by instead marking every
* resource served with a very long expiry time, but forcing the URL that
* points to the resource to change whenever the old cached version becomes
* invalid; the browser effectively thinks it is fetching a different
* resource that it hasn't seen before. This is implemented by embedding
* a "cache key" in the generated URL.
*
* Rather than using the actual modification date of a resource as the
* cache key, we simply use the webapp deployment time. This means that all
* data cached by browsers will become invalid after a webapp deploy (all
* the urls to the resources change). It also means that changes that occur
* to a resource without a webapp redeploy will not be seen by browsers.
*
* @param context the current faces-context
*
* @return the key for caching
*/
protected long getCacheKey(FacesContext context)
{
// cache key is hold in application scope so it is recreated on redeploying the webapp.
Map applicationMap = context.getExternalContext().getApplicationMap();
Long cacheKey = (Long) applicationMap.get(RESOURCES_CACHE_KEY);
if (cacheKey == null)
{
cacheKey = new Long(System.currentTimeMillis() / 100000);
applicationMap.put(RESOURCES_CACHE_KEY, cacheKey);
}
return cacheKey.longValue();
}
public boolean isResourceUri(ServletContext servletContext, HttpServletRequest request)
{
String path;
if (_contextPath != null)
{
path = _contextPath + getResourceVirtualPath(servletContext);
}
else
{
path = getResourceVirtualPath(servletContext);
}
//fix for TOMAHAWK-660; to be sure this fix is backwards compatible, the
//encoded context-path is only used as a first option to check for the prefix
//if we're sure this works for all cases, we can directly return the first value
//and not double-check.
try
{
if(request.getRequestURI().startsWith(URLEncoder.encode(path,"UTF-8")))
return true;
}
catch (UnsupportedEncodingException e)
{
log.error("Unsupported encoding UTF-8 used",e);
}
return request.getRequestURI().startsWith(path);
}
private String getResourceVirtualPath(ServletContext servletContext)
{
if(resourceVirtualPath == null)
{
resourceVirtualPath = servletContext.getInitParameter(MyfacesConfig.INIT_PARAM_RESOURCE_VIRTUAL_PATH);
if(resourceVirtualPath == null)
{
resourceVirtualPath = MyfacesConfig.INIT_PARAM_RESOURCE_VIRTUAL_PATH_DEFAULT;
}
}
return resourceVirtualPath;
}
private Class getClass(String className) throws ClassNotFoundException
{
Class clazz = ClassUtils.classForName(className);
validateResourceLoader(clazz);
return clazz;
}
public void serveResource(ServletContext context, HttpServletRequest request,
HttpServletResponse response) throws IOException
{
String pathInfo = request.getPathInfo();
String uri = request.getContextPath() + request.getServletPath()
+ (pathInfo == null ? "" : pathInfo);
String classNameStartsAfter = getResourceVirtualPath(context) + '/';
int posStartClassName = uri.indexOf(classNameStartsAfter) + classNameStartsAfter.length();
int posEndClassName = uri.indexOf(PATH_SEPARATOR, posStartClassName);
String className = uri.substring(posStartClassName, posEndClassName);
int posEndCacheKey = uri.indexOf(PATH_SEPARATOR, posEndClassName + 1);
String resourceUri = null;
if (posEndCacheKey + 1 < uri.length())
{
resourceUri = uri.substring(posEndCacheKey + 1);
}
try
{
Class resourceLoader = getClass(className);
validateResourceLoader(resourceLoader);
((ResourceLoader) resourceLoader.newInstance()).serveResource(context, request,
response, resourceUri);
// Do not call response.flushBuffer buffer here. There is no point, as if there
// ever were header data to write, this would fail as we have already written
// the response body. The only point would be to flush the output stream, but
// that will happen anyway when the servlet container closes the socket.
//
// In addition, flushing could fail here; it appears that Microsoft IE
// hasthe habit of hard-closing its socket as soon as it has received a complete
// gif file, rather than letting the server close it. The container will hopefully
// silently ignore exceptions on close.
}
catch (ResourceLoader.ClosedSocketException e)
{
// The ResourceLoader was unable to send the data because the client closed
// the socket on us; just ignore.
}
catch (ClassNotFoundException e)
{
log.error("Could not find class for name: " + className, e);
response.sendError(HttpServletResponse.SC_NOT_FOUND,
"Could not find resourceloader class for name: " + className);
}
catch (InstantiationException e)
{
log.error("Could not instantiate class for name: " + className, e);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Could not instantiate resourceloader class for name: " + className);
}
catch (IllegalAccessException e)
{
log.error("Could not access class for name: " + className, e);
response.sendError(HttpServletResponse.SC_FORBIDDEN,
"Could not access resourceloader class for name: " + className);
}
catch (Throwable e)
{
log.error("Error while serving resource: " + resourceUri + ", message : " + e.getMessage(), e);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
}
public void parseResponse(HttpServletRequest request, String bufferedResponse, HttpServletResponse response) throws IOException {
throw new UnsupportedOperationException("non-buffering add resource is not buffering.");
}
public void writeMyFacesJavascriptBeforeBodyEnd(HttpServletRequest request, HttpServletResponse response) throws IOException {
throw new UnsupportedOperationException("non-buffering add resource is not buffering.");
}
public void writeWithFullHeader(HttpServletRequest request, HttpServletResponse response) throws IOException {
throw new UnsupportedOperationException("non-buffering add resource is not buffering.");
}
public void writeResponse(HttpServletRequest request, HttpServletResponse response) throws IOException {
throw new UnsupportedOperationException("non-buffering add resource is not buffering.");
}
public boolean requiresBuffer() {
return false;
}
public void responseStarted() {
}
public void responseFinished() {
}
public boolean hasHeaderBeginInfos() {
return false;
}
}