All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.sun.faces.application.resource.ResourceHelper Maven / Gradle / Ivy

Go to download

This is the master POM file for Oracle's Implementation of the JSF 2.2 Specification.

There is a newer version: 2.4.0
Show newest version
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.faces.application.resource;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.zip.GZIPOutputStream;

import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.servlet.http.HttpServletResponse;
import javax.el.ELException;
import javax.el.ValueExpression;
import javax.el.ELContext;

import com.sun.faces.util.FacesLogger;
import com.sun.faces.util.Util;
import com.sun.faces.util.MessageUtils;

/**
 * 

* Implementations of this class contain the knowledge for finding and serving * web application resources. *

* * @since 2.0 */ public abstract class ResourceHelper { private static final Logger LOGGER = FacesLogger.RESOURCE.getLogger(); /** * This pattern represents a version for a library. * Examples: * 1_1 * 1_11 * 1_11_1 * 1_11_1_2 */ private static final Pattern LIBRARY_VERSION_PATTERN = Pattern.compile("^(\\d+)(_\\d+)+"); /** * This pattern represents a version for a resource. * Examples: * 1_1.jpg * 1_11.323 * 1_11_1.gif * 1_11_1_2.txt * 1_1 * 1_11 * 1_11_1 * 1_11_1_2 * * The extension is optional. */ private static final Pattern RESOURCE_VERSION_PATTERN = Pattern.compile("^((?:\\d+)(?:_\\d+)+)[\\.]?(\\w+)?"); /** * Arbitrary file name to write the compressed bits to. */ private static final String COMPRESSED_CONTENT_FILENAME = "compressed-content"; private static final String[] EL_CONTENT_TYPES = { "text/css", }; static { Arrays.sort(EL_CONTENT_TYPES); } // ---------------------------------------------------------- Public Methods /** * @return the base path in which resources will be stored */ public abstract String getBaseResourcePath(); public abstract String getBaseContractsPath(); protected String getBasePath(String contract) { if(contract == null) { return getBaseResourcePath(); } return getBaseContractsPath() + '/' + contract; } /** *

* If the resource is compressable, return an InputStream to read the * compressed content, otherwise, call {@link #getNonCompressedInputStream(ResourceInfo, javax.faces.context.FacesContext)} * to return the content of the original resource. *

*

* Implementation Note: If any exception occurs trying to return a stream * to the compressed content, log the exception, and instead try to return * a stream to the original content. *

* @param toStream the resource to obtain an InputStream to * @param ctx the {@link javax.faces.context.FacesContext} for the current request * @return an InputStream to the resource, or * null if no resource is found * @throws IOException if an error occurs obtaining the stream */ public InputStream getInputStream(ResourceInfo toStream, FacesContext ctx) throws IOException { // PENDING(edburns): this is a sub-optimal implementation choice // done in the interest of prototyping. It's never a good idea // to do a switch statement based on the type of an object. InputStream in = null; if (toStream instanceof ClientResourceInfo) { ClientResourceInfo resource = (ClientResourceInfo) toStream; in = getInputStreamFromClientInfo(resource, ctx); if (null == in) { ClientResourceInfo resourceWithoutLocalePrefix = new ClientResourceInfo(resource, false); in = getInputStreamFromClientInfo(resourceWithoutLocalePrefix, ctx); if (null != in) { resource.copy(resourceWithoutLocalePrefix); } } } // else { // // PENDING(edburns): get the input stream from the facelet ResourceInfo. // } return in; } private InputStream getInputStreamFromClientInfo(ClientResourceInfo resource, FacesContext ctx) throws IOException { InputStream in = null; if (resource.isCompressable() && clientAcceptsCompression(ctx)) { if (!resource.supportsEL()) { try { String path = resource.getCompressedPath(); in = new BufferedInputStream( new FileInputStream(path + File.separatorChar + COMPRESSED_CONTENT_FILENAME)); } catch (IOException ioe) { if (LOGGER.isLoggable(Level.SEVERE)) { LOGGER.log(Level.SEVERE, ioe.getMessage(), ioe); } // return null so that the override code will try to serve // the non-compressed content in = null; } } else { InputStream temp = null; try { // using dynamic compression here temp = new BufferedInputStream( new ELEvaluatingInputStream(ctx, resource, getNonCompressedInputStream(resource, ctx))); byte[] buf = new byte[512]; ByteArrayOutputStream baos = new ByteArrayOutputStream(512); OutputStream out = new GZIPOutputStream(baos); for (int read = temp.read(buf); read != -1; read = temp.read(buf)) { out.write(buf, 0, read); } out.flush(); out.close(); in = new BufferedInputStream( new ByteArrayInputStream(baos.toByteArray())); } catch (IOException ioe) { if (LOGGER.isLoggable(Level.SEVERE)) { LOGGER.log(Level.SEVERE, ioe.getMessage(), ioe); } } finally { if (temp != null) { try { temp.close(); } catch (IOException ioe) { if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.log(Level.FINEST, "Closing stream", ioe); } } } } } } if (in == null) { if (resource.supportsEL()) { return new BufferedInputStream( new ELEvaluatingInputStream(ctx, resource, getNonCompressedInputStream(resource, ctx))); } else { in = getNonCompressedInputStream(resource, ctx); } } return in; } /** * @param resource the resource to obtain a URL reference to * @param ctx the {@link FacesContext} for the current request * @return a URL to the specified resource, otherwise null * if no resource is found */ public abstract URL getURL(ResourceInfo resource, FacesContext ctx); /** * Search for the specified library/localPrefix combination in an * implementation dependent manner. * * @param libraryName the name of the library * @param localePrefix the logicial identifier for a locale specific library. * if no localePrefix is configured, pass null * @param contract the name of the contract *@param ctx the {@link javax.faces.context.FacesContext} for the current request @return a {@link LibraryInfo} if a matching library based off the inputs * can be found, otherwise returns null */ public abstract LibraryInfo findLibrary(String libraryName, String localePrefix, String contract, FacesContext ctx); /** *

* Search for the specified resource based in the library/localePrefix/resourceName * combination in an implementation dependent manner. *

*

* If the resource is found, and is compressable, call {@link #handleCompression(com.sun.faces.application.resource.ClientResourceInfo)} * to compress the content. *

* * @param library the library this resource should be a part of. If the * the resource that is being searched for isn't part of a library, then * pass null * @param resourceName the name of the resource that is being searched for * @param localePrefix the logicial identifier for a locale specific library. * if no localePrefix is configured, pass null * @param compressable true if the resource can be compressed * @param ctx the {@link javax.faces.context.FacesContext} for the current request * @return a {@link ResourceInfo} if a matching resource based off the inputs * can be found, otherwise returns null */ public abstract ResourceInfo findResource(LibraryInfo library, String resourceName, String localePrefix, boolean compressable, FacesContext ctx); /** *

* The default implementation of this method will call through to * {@link ResourceHelper#getURL(ResourceInfo, javax.faces.context.FacesContext)} * and leverage the URL to obtain the date information of the resource and * return the value of URLConnection.getLastModified() *

* @param resource the resource in question * @param ctx the {@link FacesContext} for the current request * @return the date of the resource in milliseconds (since epoch), * or 0 if the date cannot be determined */ public long getLastModified(ResourceInfo resource, FacesContext ctx) { URL url = getURL(resource, ctx); // resource may have been deleted. if (url == null) { return 0; } return Util.getLastModified(url); } // ------------------------------------------------------- Protected Methods /** * If a {@link ResourceInfo} is not compressable, {@link #getInputStream(ResourceInfo, javax.faces.context.FacesContext)} * will call this method to return a stream to the actual resource. * * @param info the resource to obtain an InputStream to * @param ctx the {@link FacesContext} for the current request * @return an InputStream to the resource * @throws IOException if an error occurs obtaining the stream */ protected abstract InputStream getNonCompressedInputStream(ResourceInfo info, FacesContext ctx) throws IOException; /** *

* Given a collection of path names: *

*
     *   1.1, scripts, images, 1.2
     * 
*

* this method will pick out the directories that represent a library or * resource version and return the latest version found, if any. *

* * @param resourcePaths a collection of paths (consisting of single path * elements) * @param isResource true if the version being looked up * is for a reource, otherwise, pass false if the version * is a library version * @return the latest version or if no version can be detected, otherwise * this method returns null */ protected VersionInfo getVersion(Collection resourcePaths, boolean isResource) { List versionedPaths = new ArrayList(resourcePaths.size()); for (String p : resourcePaths) { VersionInfo vp = getVersion(p, isResource); if (vp != null) { versionedPaths.add(vp); } } VersionInfo version = null; if (!versionedPaths.isEmpty()) { Collections.sort(versionedPaths); version = versionedPaths.get(versionedPaths.size() - 1); } return version; } /** * Utility method to compress the content of the original resource * to the temporary directory specified by {@link com.sun.faces.application.resource.ClientResourceInfo#getCompressedPath()}. * * @param info the resource to be compressed * @return true if compression succeeded and the compressed * result is smaller than the original content, otherwise false * @throws IOException if any error occur reading/writing */ protected boolean compressContent(ClientResourceInfo info) throws IOException { InputStream source = null; OutputStream dest = null; try { URL url = info.getHelper() .getURL(info, FacesContext.getCurrentInstance()); URLConnection conn = url.openConnection(); conn.setUseCaches(false); conn.connect(); source = conn.getInputStream(); byte[] buf = new byte[512]; ByteArrayOutputStream baos = new ByteArrayOutputStream(); dest = new GZIPOutputStream(baos); int totalRead = 0; for (int len = source.read(buf); len != -1; len = source.read(buf)) { dest.write(buf, 0, len); totalRead += len; } dest.flush(); try { dest.close(); } catch (IOException ioe) { if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.log(Level.FINEST, "Closing stream", ioe); } } if (baos.size() < totalRead) { String outputFile = info.getCompressedPath() + File.separatorChar + COMPRESSED_CONTENT_FILENAME; dest = new FileOutputStream(outputFile); dest.write(baos.toByteArray()); dest.flush(); return true; } return false; } finally { if (source != null) { try { source.close(); } catch (IOException ioe) { if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.log(Level.FINEST, "Closing stream", ioe); } } } if (dest != null) { try { dest.close(); } catch (IOException ioe) { if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.log(Level.FINEST, "Closing stream", ioe); } } } } } /** *

* This method attempt to verify that the user agent can accept a gzip * encoded response by interrogating the Accept-Encoding * requester header. If it is determined safe to send a gzip encoded * response, send the Content-Encoding header with a value * of gzip.

* *

* See * Utility method to peform the necessary actions to compress content. *

* *

* Implmentation Note: If an exception occurs while compressing the content, * log the IOException and rebuilt the {@link ResourceInfo} as non-compressable. *

* * @param resource the resource to compression * @return the ResourceInfo after compression is complete. If compression * was successful, this should be the same instance. If compression was * not successful, it will be a different instance than what was passed. */ protected ClientResourceInfo handleCompression(ClientResourceInfo resource) { try { if (!resource.supportsEL() && !compressContent(resource)) { resource = rebuildAsNonCompressed(resource); } } catch (IOException ioe) { if (LOGGER.isLoggable(Level.SEVERE)) { LOGGER.log(Level.SEVERE, ioe.getMessage(), ioe); } resource = rebuildAsNonCompressed(resource); } return resource; } protected boolean resourceSupportsEL(String resourceName, String libraryName, FacesContext ctx) { ExternalContext extContext = ctx.getExternalContext(); String contentType = extContext.getMimeType(resourceName); boolean result = (contentType != null && (Arrays.binarySearch(EL_CONTENT_TYPES, contentType) >= 0)) || (null != resourceName && null != libraryName && "javax.faces".equals(libraryName) && "jsf.js".equals(resourceName)); return result; } /** * @param s input String * @return the String without a leading slash if it has one. */ protected String trimLeadingSlash(String s) { if (s.charAt(0) == '/') { return s.substring(1); } else { return s; } } // --------------------------------------------------------- Private Methods private ClientResourceInfo rebuildAsNonCompressed(ClientResourceInfo resource) { LibraryInfo library = resource.getLibraryInfo(); ClientResourceInfo ret; if (library != null) { ret = new ClientResourceInfo(resource.library, resource.contract, resource.name, resource.version, false, resource.supportsEL, resource.isDevStage, resource.cacheTimestamp); } else { ret = new ClientResourceInfo(resource.contract, resource.name, resource.version, resource.localePrefix, this, false, resource.supportsEL, resource.isDevStage, resource.cacheTimestamp); } return ret; } /** * @param pathElement the path element to verify * @param isResource true if the version being looked up * is for a reource, otherwise, pass false if the version * is a library version * @return true if this path element represents a version * (i.e. matches {@link #LIBRARY_VERSION_PATTERN}), otherwise * returns false */ private VersionInfo getVersion(String pathElement, boolean isResource) { Map appMap = FacesContext.getCurrentInstance().getExternalContext().getApplicationMap(); String[] pathElements = Util.split(appMap, pathElement, "/"); String path = pathElements[pathElements.length - 1]; String extension = null; if (isResource) { Matcher m = RESOURCE_VERSION_PATTERN.matcher(path); return ((m.matches()) ? new VersionInfo(m.group(1), m.group(2)) : null); } else { return ((LIBRARY_VERSION_PATTERN.matcher(path).matches()) ? new VersionInfo(path, extension) : null); } } // ---------------------------------------------------------- Nested Classes private static final class ELEvaluatingInputStream extends InputStream { // Premature optimization is the root of all evil. Blah blah. private List buf = new ArrayList(1024); private boolean failedExpressionTest = false; private boolean writingExpression = false; private InputStream inner; private ClientResourceInfo info; private FacesContext ctx; private boolean expressionEvaluated; private boolean endOfStreamReached; // ---------------------------------------------------- Constructors public ELEvaluatingInputStream(FacesContext ctx, ClientResourceInfo info, InputStream inner) { this.inner = inner; this.info = info; this.ctx = ctx; } // ------------------------------------------------ Methods from InputStream @Override public int read() throws IOException { if (null == inner) { return -1; } int i; char c; if (failedExpressionTest) { i = nextRead; nextRead = -1; failedExpressionTest = false; } else if (writingExpression) { if (0 < buf.size()) { i = buf.remove(0); } else { writingExpression = false; i = inner.read(); } } else { // Read a character. i = inner.read(); c = (char) i; // If it *might* be an expression... if (c == '#') { // read another character. i = inner.read(); c = (char) i; // If it's '{', assume we have an expression. if (c == '{') { // read it into the buffer, and evaluate it into the // same buffer. readExpressionIntoBufferAndEvaluateIntoBuffer(); // set the flag so that we need to return content // from the buffer. writingExpression = true; // Make sure to swallow the '{'. i = this.read(); } else { // It's not an expression, we need to return '#', i = (int) '#'; // then return whatever we just read, on the // *next* read; nextRead = (int) c; failedExpressionTest = true; } } } if (i == -1) { endOfStreamReached = true; } return i; } private int nextRead = -1; private void readExpressionIntoBufferAndEvaluateIntoBuffer() throws IOException { int i; char c; do { i = inner.read(); c = (char) i; if (c == '}') { evaluateExpressionIntoBuffer(); } else { buf.add(i); } } while (c != '}' && i != -1); } /* * At this point, we know that getBuf() returns a List * that contains the bytes of the expression. * Turn it into a String, turn the String into a ValueExpression, * evaluate it, store the toString() of it in * expressionResult; */ private void evaluateExpressionIntoBuffer() { char chars[] = new char[buf.size()]; for (int i = 0, len = buf.size(); i < len; i++) { chars[i] = (char) (int) buf.get(i); } String expressionBody = new String(chars); int colon; // If this expression contains a ":" if (-1 != (colon = expressionBody.indexOf(":"))) { // Make sure it contains only one ":" if (!isPropertyValid(expressionBody)) { String message = MessageUtils .getExceptionMessageString(MessageUtils.INVALID_RESOURCE_FORMAT_COLON_ERROR, expressionBody); throw new ELException(message); } Map appMap = FacesContext.getCurrentInstance().getExternalContext().getApplicationMap(); String[] parts = Util.split(appMap, expressionBody, ":"); if (null == parts[0] || null == parts[1]) { String message = MessageUtils .getExceptionMessageString(MessageUtils.INVALID_RESOURCE_FORMAT_NO_LIBRARY_NAME_ERROR, expressionBody); throw new ELException(message); } try { int mark = parts[0].indexOf("[") + 2; char quoteMark = parts[0].charAt(mark - 1); parts[0] = parts[0].substring(mark, colon); if (parts[0].equals("this")) { LibraryInfo libInfo = info.getLibraryInfo(); if (null != libInfo) { parts[0] = libInfo.getName(); } else if (null != info.getContract()) { parts[0] = info.getContract(); } else { throw new NullPointerException("Resource expression is not a library or resource library contract"); } mark = parts[1].indexOf("]") - 1; parts[1] = parts[1].substring(0, mark); expressionBody = "resource[" + quoteMark + parts[0] + ":" + parts[1] + quoteMark + "]"; } } catch (Exception e) { String message = MessageUtils .getExceptionMessageString(MessageUtils.INVALID_RESOURCE_FORMAT_ERROR, expressionBody); throw new ELException(message); } } ELContext elContext = ctx.getELContext(); expressionEvaluated = true; ValueExpression ve = ctx.getApplication().getExpressionFactory(). createValueExpression(elContext, "#{" + expressionBody + "}", String.class); Object value = ve.getValue(elContext); String expressionResult = ((value != null) ? value.toString() : ""); buf.clear(); for (int i = 0, len = expressionResult.length(); i < len; i++) { buf.add((int) expressionResult.charAt(i)); } } @Override public void close() throws IOException { if (endOfStreamReached && !expressionEvaluated) { info.disableEL(); } inner.close(); super.close(); } private boolean isPropertyValid(String property) { int idx = property.indexOf(':'); return (property.indexOf(':', idx + 1) == -1); } } // END ELEvaluatingInputStream }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy