/*
* 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.view.facelets.impl;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import javax.el.ELException;
import javax.faces.FacesException;
import javax.faces.FactoryFinder;
import javax.faces.view.facelets.FaceletCache;
import javax.faces.view.facelets.FaceletCacheFactory;
import javax.faces.view.facelets.FaceletContext;
import javax.faces.view.facelets.FaceletException;
import javax.faces.view.facelets.FaceletHandler;
import javax.faces.view.facelets.ResourceResolver;
import org.apache.myfaces.shared.resource.ResourceLoaderUtils;
import org.apache.myfaces.view.facelets.AbstractFaceletCache;
import org.apache.myfaces.view.facelets.Facelet;
import org.apache.myfaces.view.facelets.FaceletFactory;
import org.apache.myfaces.view.facelets.compiler.Compiler;
import org.apache.myfaces.view.facelets.util.ParameterCheck;
/**
* Default FaceletFactory implementation.
*
* @author Jacob Hookom
* @version $Id: DefaultFaceletFactory.java 1470662 2013-04-22 19:04:45Z lu4242 $
*/
public final class DefaultFaceletFactory extends FaceletFactory
{
private static final long INFINITE_DELAY = -1;
private static final long NO_CACHE_DELAY = 0;
//protected final Log log = LogFactory.getLog(DefaultFaceletFactory.class);
protected final Logger log = Logger.getLogger(DefaultFaceletFactory.class.getName());
private URL _baseUrl;
private Compiler _compiler;
//private Map<String, DefaultFacelet> _facelets;
//private Map<String, DefaultFacelet> _viewMetadataFacelets;
private Map<String, DefaultFacelet> _compositeComponentMetadataFacelets;
private long _refreshPeriod;
private Map<String, URL> _relativeLocations;
private javax.faces.view.facelets.ResourceResolver _resolver;
private FaceletCache<Facelet> _faceletCache;
private AbstractFaceletCache<Facelet> _abstractFaceletCache;
public DefaultFaceletFactory(Compiler compiler, ResourceResolver resolver) throws IOException
{
this(compiler, resolver, -1);
}
public DefaultFaceletFactory(Compiler compiler, ResourceResolver resolver, long refreshPeriod)
{
ParameterCheck.notNull("compiler", compiler);
ParameterCheck.notNull("resolver", resolver);
_compiler = compiler;
//_facelets = new HashMap<String, DefaultFacelet>();
//_viewMetadataFacelets = new HashMap<String, DefaultFacelet>();
_compositeComponentMetadataFacelets = new HashMap<String, DefaultFacelet>();
_relativeLocations = new HashMap<String, URL>();
_resolver = resolver;
_baseUrl = resolver.resolveUrl("/");
_refreshPeriod = refreshPeriod < 0 ? INFINITE_DELAY : refreshPeriod * 1000;
// facelet cache. Lookup here, because after all this is a "part" of the facelet factory implementation.
FaceletCacheFactory cacheFactory
= (FaceletCacheFactory) FactoryFinder.getFactory(FactoryFinder.FACELET_CACHE_FACTORY);
_faceletCache = (FaceletCache<Facelet>) cacheFactory.getFaceletCache();
FaceletCache.MemberFactory<Facelet> faceletFactory = new FaceletCache.MemberFactory<Facelet>()
{
public Facelet newInstance(URL url) throws IOException
{
return _createFacelet(url);
}
};
FaceletCache.MemberFactory<Facelet> viewMetadataFaceletFactory = new FaceletCache.MemberFactory<Facelet>()
{
public Facelet newInstance(URL url) throws IOException
{
return _createViewMetadataFacelet(url);
}
};
if (_faceletCache instanceof AbstractFaceletCache)
{
_abstractFaceletCache = (AbstractFaceletCache<Facelet>) _faceletCache;
FaceletCache.MemberFactory<Facelet> compositeComponentMetadataFaceletFactory =
new FaceletCache.MemberFactory<Facelet>()
{
public Facelet newInstance(URL url) throws IOException
{
return _createCompositeComponentMetadataFacelet(url);
}
};
try
{
Method setMemberFactoriesMethod = AbstractFaceletCache.class.getDeclaredMethod("setMemberFactories",
new Class[]{FaceletCache.MemberFactory.class, FaceletCache.MemberFactory.class,
FaceletCache.MemberFactory.class});
setMemberFactoriesMethod.setAccessible(true);
setMemberFactoriesMethod.invoke(_faceletCache, faceletFactory, viewMetadataFaceletFactory,
compositeComponentMetadataFaceletFactory);
}
catch (Exception e)
{
throw new FacesException(
"Cannot call setMemberFactories method, Initialization of FaceletCache failed.",
e);
}
}
else
{
// Note that FaceletCache.setMemberFactories method is protected, and this is the place where call
// this method has sense, because DefaultFaceletFactory is the responsible to create Facelet instances.
// The only way to do it is using reflection, and it has sense, because in this way it is possible to
// setup a java SecurityManager that prevents call this method (because it is protected, and to do that
// the code first check for "suppressAccessChecks" permission).
try
{
Method setMemberFactoriesMethod = FaceletCache.class.getDeclaredMethod("setMemberFactories",
new Class[]{FaceletCache.MemberFactory.class, FaceletCache.MemberFactory.class});
setMemberFactoriesMethod.setAccessible(true);
setMemberFactoriesMethod.invoke(_faceletCache, faceletFactory, viewMetadataFaceletFactory);
}
catch (Exception e)
{
throw new FacesException(
"Cannot call setMemberFactories method, Initialization of FaceletCache failed.",
e);
}
}
if (log.isLoggable(Level.FINE))
{
log.fine("Using ResourceResolver: " + _resolver);
log.fine("Using Refresh Period: " + _refreshPeriod);
}
}
/**
* Compiler this factory uses
*
* @return final Compiler instance
*/
public Compiler getCompiler()
{
return _compiler;
}
/*
* (non-Javadoc)
*
* @see org.apache.myfaces.view.facelets.FaceletFactory#getFacelet(java.lang.String)
*/
@Override
public Facelet getFacelet(String uri) throws IOException, FaceletException, FacesException, ELException
{
URL url = (URL) _relativeLocations.get(uri);
if (url == null)
{
url = resolveURL(_baseUrl, uri);
if (url != null)
{
Map<String, URL> newLoc = new HashMap<String, URL>(_relativeLocations);
newLoc.put(uri, url);
_relativeLocations = newLoc;
}
else
{
throw new IOException("'" + uri + "' not found.");
}
}
return this.getFacelet(url);
}
/**
* Create a Facelet from the passed URL. This method checks if the cached Facelet needs to be refreshed before
* returning. If so, uses the passed URL to build a new instance;
*
* @param url
* source url
* @return Facelet instance
* @throws IOException
* @throws FaceletException
* @throws FacesException
* @throws ELException
*/
@Override
public Facelet getFacelet(URL url) throws IOException, FaceletException, FacesException, ELException
{
return _faceletCache.getFacelet(url);
}
@Override
public Facelet getFacelet(FaceletContext ctx, URL url)
throws IOException, FaceletException, FacesException, ELException
{
if (_abstractFaceletCache != null)
{
return _abstractFaceletCache.getFacelet(ctx, url);
}
else
{
return _faceletCache.getFacelet(url);
}
}
public long getRefreshPeriod()
{
return _refreshPeriod;
}
/**
* Resolves a path based on the passed URL. If the path starts with '/', then resolve the path against
* {@link javax.faces.context.ExternalContext#getResource(java.lang.String)
* javax.faces.context.ExternalContext#getResource(java.lang.String)}. Otherwise create a new URL via
* {@link URL#URL(java.net.URL, java.lang.String) URL(URL, String)}.
*
* @param source
* base to resolve from
* @param path
* relative path to the source
* @return resolved URL
* @throws IOException
*/
public URL resolveURL(URL source, String path) throws IOException
{
if (path.startsWith("/"))
{
URL url = _resolver.resolveUrl(path);
if (url == null)
{
throw new FileNotFoundException(path + " Not Found in ExternalContext as a Resource");
}
return url;
}
else
{
return new URL(source, path);
}
}
/**
* Template method for determining if the Facelet needs to be refreshed.
*
* @param facelet
* Facelet that could have expired
* @return true if it needs to be refreshed
*/
protected boolean needsToBeRefreshed(DefaultFacelet facelet)
{
// if set to 0, constantly reload-- nocache
if (_refreshPeriod == NO_CACHE_DELAY)
{
return true;
}
// if set to -1, never reload
if (_refreshPeriod == INFINITE_DELAY)
{
return false;
}
long target = facelet.getCreateTime() + _refreshPeriod;
if (System.currentTimeMillis() > target)
{
// Should check for file modification
try
{
URLConnection conn = facelet.getSource().openConnection();
long lastModified = ResourceLoaderUtils.getResourceLastModified(conn);
return lastModified == 0 || lastModified > target;
}
catch (IOException e)
{
throw new FaceletException("Error Checking Last Modified for " + facelet.getAlias(), e);
}
}
return false;
}
/**
* Uses the internal Compiler reference to build a Facelet given the passed URL.
*
* @param url
* source
* @return a Facelet instance
* @throws IOException
* @throws FaceletException
* @throws FacesException
* @throws ELException
*/
private DefaultFacelet _createFacelet(URL url) throws IOException, FaceletException, FacesException, ELException
{
if (log.isLoggable(Level.FINE))
{
log.fine("Creating Facelet for: " + url);
}
String alias = "/" + _removeFirst(url.getFile(), _baseUrl.getFile());
try
{
FaceletHandler h = _compiler.compile(url, alias);
DefaultFacelet f = new DefaultFacelet(this, _compiler.createExpressionFactory(), url, alias, alias, h);
return f;
}
catch (FileNotFoundException fnfe)
{
throw new FileNotFoundException("Facelet " + alias + " not found at: " + url.toExternalForm());
}
}
/**
* @since 2.0
* @param url
* @return
* @throws IOException
* @throws FaceletException
* @throws FacesException
* @throws ELException
*/
private DefaultFacelet _createViewMetadataFacelet(URL url)
throws IOException, FaceletException, FacesException, ELException
{
if (log.isLoggable(Level.FINE))
{
log.fine("Creating Facelet used to create View Metadata for: " + url);
}
// The alias is used later for informative purposes, so we append
// some prefix to identify later where the errors comes from.
String faceletId = "/"+ _removeFirst(url.getFile(), _baseUrl.getFile());
String alias = "/viewMetadata" + faceletId;
try
{
FaceletHandler h = _compiler.compileViewMetadata(url, alias);
DefaultFacelet f = new DefaultFacelet(this, _compiler.createExpressionFactory(), url, alias,
faceletId, h);
return f;
}
catch (FileNotFoundException fnfe)
{
throw new FileNotFoundException("Facelet " + alias + " not found at: " + url.toExternalForm());
}
}
/**
* @since 2.0.1
* @param url
* @return
* @throws IOException
* @throws FaceletException
* @throws FacesException
* @throws ELException
*/
private DefaultFacelet _createCompositeComponentMetadataFacelet(URL url)
throws IOException, FaceletException, FacesException, ELException
{
if (log.isLoggable(Level.FINE))
{
log.fine("Creating Facelet used to create Composite Component Metadata for: " + url);
}
// The alias is used later for informative purposes, so we append
// some prefix to identify later where the errors comes from.
String alias = "/compositeComponentMetadata/" + _removeFirst(url.getFile(), _baseUrl.getFile());
try
{
FaceletHandler h = _compiler.compileCompositeComponentMetadata(url, alias);
DefaultFacelet f = new DefaultFacelet(this, _compiler.createExpressionFactory(), url, alias,
alias, h, true);
return f;
}
catch (FileNotFoundException fnfe)
{
throw new FileNotFoundException("Facelet " + alias + " not found at: " + url.toExternalForm());
}
}
/**
* Works in the same way as getFacelet(String uri), but redirect
* to getViewMetadataFacelet(URL url)
* @since 2.0
*/
@Override
public Facelet getViewMetadataFacelet(String uri) throws IOException
{
URL url = (URL) _relativeLocations.get(uri);
if (url == null)
{
url = resolveURL(_baseUrl, uri);
if (url != null)
{
Map<String, URL> newLoc = new HashMap<String, URL>(_relativeLocations);
newLoc.put(uri, url);
_relativeLocations = newLoc;
}
else
{
throw new IOException("'" + uri + "' not found.");
}
}
return this.getViewMetadataFacelet(url);
}
/**
* @since 2.0
*/
@Override
public Facelet getViewMetadataFacelet(URL url) throws IOException,
FaceletException, FacesException, ELException
{
if (_abstractFaceletCache != null)
{
return _abstractFaceletCache.getViewMetadataFacelet(url);
}
else
{
return _faceletCache.getViewMetadataFacelet(url);
}
}
/**
* Works in the same way as getFacelet(String uri), but redirect
* to getViewMetadataFacelet(URL url)
* @since 2.0.1
*/
@Override
public Facelet getCompositeComponentMetadataFacelet(String uri) throws IOException
{
URL url = (URL) _relativeLocations.get(uri);
if (url == null)
{
url = resolveURL(_baseUrl, uri);
if (url != null)
{
Map<String, URL> newLoc = new HashMap<String, URL>(_relativeLocations);
newLoc.put(uri, url);
_relativeLocations = newLoc;
}
else
{
throw new IOException("'" + uri + "' not found.");
}
}
return this.getCompositeComponentMetadataFacelet(url);
}
/**
* @since 2.0.1
*/
@Override
public Facelet getCompositeComponentMetadataFacelet(URL url) throws IOException,
FaceletException, FacesException, ELException
{
if (_abstractFaceletCache != null)
{
return _abstractFaceletCache.getCompositeComponentMetadataFacelet(url);
}
else
{
ParameterCheck.notNull("url", url);
String key = url.toString();
DefaultFacelet f = _compositeComponentMetadataFacelets.get(key);
if (f == null || this.needsToBeRefreshed(f))
{
f = this._createCompositeComponentMetadataFacelet(url);
if (_refreshPeriod != NO_CACHE_DELAY)
{
Map<String, DefaultFacelet> newLoc
= new HashMap<String, DefaultFacelet>(_compositeComponentMetadataFacelets);
newLoc.put(key, f);
_compositeComponentMetadataFacelets = newLoc;
}
}
return f;
}
}
/**
* Removes the first appearance of toRemove in string.
*
* Works just like string.replaceFirst(toRemove, ""), except that toRemove
* is not treated as a regex (which could cause problems with filenames).
*
* @param string
* @param toRemove
* @return
*/
private String _removeFirst(String string, String toRemove)
{
// do exactly what String.replaceFirst(toRemove, "") internally does,
// except treating the search as literal text and not as regex
return Pattern.compile(toRemove, Pattern.LITERAL).matcher(string).replaceFirst("");
}
}