/**
* Utility method to check if JSF 2.0 Facelets should be disabled. If it's not explicitly disabled
* by the context init parameter, then check the version of the WEB-INF/faces-config.xml document.
* If the version is less than 2.0, then override the default value for the context init parameter
* so that other parts of the system that use that config option will know it has been disabled.
*
* <p>NOTE: Since this method overrides a configuration value, it should be called before *any*
* document parsing is performed the configuration value may be queried by the <code>ConfigParser
* </code>s.
*
* @param webconfig configuration for this application
* @param facesConfigInfo object representing WEB-INF/faces-config.xml
* @return <code>true</code> if Facelets should be disabled
*/
private boolean isFaceletsDisabled(WebConfiguration webconfig, FacesConfigInfo facesConfigInfo) {
boolean isFaceletsDisabled = webconfig.isOptionEnabled(DisableFaceletJSFViewHandler);
if (!isFaceletsDisabled) {
// if not explicitly disabled, make a sanity check against
// /WEB-INF/faces-config.xml
isFaceletsDisabled = !facesConfigInfo.isVersionGreaterOrEqual(2.0);
webconfig.overrideContextInitParameter(DisableFaceletJSFViewHandler, isFaceletsDisabled);
}
return isFaceletsDisabled;
}
public void testClientResourceInfoCompression() throws Exception {
WebConfiguration config = WebConfiguration.getInstance();
config.overrideContextInitParameter(
WebConfiguration.WebContextInitParameter.CompressableMimeTypes,
"image/gif,text/css,text/plain");
// create a new ResourceManager so that the mime type configuration is picked up
ResourceManager manager = new ResourceManager(null);
ClientResourceInfo resource =
(ClientResourceInfo)
manager.findResource("nvLibrary", "duke-nv.gif", "image/gif", getFacesContext());
assertTrue(resource != null);
assertTrue(resource.isCompressable());
assertTrue(compressionPathIsValid(resource));
// ensure compression disabled for a content type that is null
resource =
(ClientResourceInfo)
manager.findResource("nvLibrary", "duke-nv.gif", "text/javascript", getFacesContext());
assertTrue(resource != null);
assertTrue(!resource.isCompressable());
assertTrue(resource.getCompressedPath() == null);
// if a resource is compressable, but the compressed result is larger
// than the original resource, the returned ClientResourceInfo shouldn't
// be marked as compressable and getCompressedPath() will be null
resource =
(ClientResourceInfo)
manager.findResource(null, "simple.txt", "text/plain", getFacesContext());
assertTrue(resource != null);
assertTrue(!resource.isCompressable());
assertTrue(resource.getCompressedPath() == null);
// if a resource is compressable, but the compressed result is larger
// than the original resource, the returned ClientResourceInfo should be
// marked compressable. However, since css files may have EL expressions
// embedded within, the the resource will be marked as supporting such.
resource =
(ClientResourceInfo)
manager.findResource(null, "simple.css", "text/plain", getFacesContext());
assertTrue(resource != null);
assertTrue(resource.isCompressable());
assertTrue(resource.supportsEL());
assertTrue(resource.getCompressedPath() == null);
}
public void contextInitialized(ServletContextEvent sce) {
ServletContext context = sce.getServletContext();
Timer timer = Timer.getInstance();
if (timer != null) {
timer.startTiming();
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(
Level.FINE,
MessageFormat.format(
"ConfigureListener.contextInitialized({0})", getServletContextIdentifier(context)));
}
webConfig = WebConfiguration.getInstance(context);
ConfigManager configManager = ConfigManager.getInstance();
if (configManager.hasBeenInitialized(context)) {
return;
}
// Check to see if the FacesServlet is present in the
// web.xml. If it is, perform faces configuration as normal,
// otherwise, simply return.
Object mappingsAdded = context.getAttribute(RIConstants.FACES_INITIALIZER_MAPPINGS_ADDED);
if (mappingsAdded != null) {
context.removeAttribute(RIConstants.FACES_INITIALIZER_MAPPINGS_ADDED);
}
WebXmlProcessor webXmlProcessor = new WebXmlProcessor(context);
if (mappingsAdded == null) {
if (!webXmlProcessor.isFacesServletPresent()) {
if (!webConfig.isOptionEnabled(ForceLoadFacesConfigFiles)) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(
Level.FINE,
"No FacesServlet found in deployment descriptor - bypassing configuration");
}
WebConfiguration.clear(context);
return;
}
} else {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(
Level.FINE,
"FacesServlet found in deployment descriptor - processing configuration.");
}
}
}
// bootstrap of faces required
webAppListener = new WebappLifecycleListener(context);
webAppListener.contextInitialized(sce);
InitFacesContext initContext = new InitFacesContext(context);
ReflectionUtils.initCache(Thread.currentThread().getContextClassLoader());
Throwable caughtThrowable = null;
try {
if (LOGGER.isLoggable(Level.INFO)) {
LOGGER.log(Level.INFO, "jsf.config.listener.version", getServletContextIdentifier(context));
}
// see if we need to disable our TLValidator
Util.setHtmlTLVActive(webConfig.isOptionEnabled(EnableHtmlTagLibraryValidator));
if (webConfig.isOptionEnabled(VerifyFacesConfigObjects)) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.warning("jsf.config.verifyobjects.development_only");
}
// if we're verifying, force bean validation to occur at startup as well
webConfig.overrideContextInitParameter(EnableLazyBeanValidation, false);
Verifier.setCurrentInstance(new Verifier());
}
initScripting();
configManager.initialize(context);
if (shouldInitConfigMonitoring()) {
initConfigMonitoring(context);
}
// Step 7, verify that all the configured factories are available
// and optionall that configured objects can be created.
Verifier v = Verifier.getCurrentInstance();
if (v != null && !v.isApplicationValid()) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.severe("jsf.config.verifyobjects.failures_detected");
StringBuilder sb = new StringBuilder(128);
for (String m : v.getMessages()) {
sb.append(m).append('\n');
}
LOGGER.severe(sb.toString());
}
}
registerELResolverAndListenerWithJsp(context, false);
ELContext elctx = new ELContextImpl(initContext.getApplication().getELResolver());
elctx.putContext(FacesContext.class, initContext);
initContext.setELContext(elctx);
ApplicationAssociate associate = ApplicationAssociate.getInstance(context);
if (associate != null) {
associate.setContextName(getServletContextIdentifier(context));
BeanManager manager = associate.getBeanManager();
List<String> eagerBeans = manager.getEagerBeanNames();
if (!eagerBeans.isEmpty()) {
for (String name : eagerBeans) {
manager.create(name, initContext);
}
}
boolean isErrorPagePresent = webXmlProcessor.isErrorPagePresent();
associate.setErrorPagePresent(isErrorPagePresent);
context.setAttribute(RIConstants.ERROR_PAGE_PRESENT_KEY_NAME, isErrorPagePresent);
}
Application app = initContext.getApplication();
app.subscribeToEvent(PostConstructViewMapEvent.class, UIViewRoot.class, webAppListener);
app.subscribeToEvent(PreDestroyViewMapEvent.class, UIViewRoot.class, webAppListener);
webConfig.doPostBringupActions();
} catch (Throwable t) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE, "Critical error during deployment: ", t);
}
caughtThrowable = t;
} finally {
Verifier.setCurrentInstance(null);
initContext.release();
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE, "jsf.config.listener.version.complete");
}
if (timer != null) {
timer.stopTiming();
timer.logResult("Initialization of context " + getServletContextIdentifier(context));
}
if (null != caughtThrowable) {
throw new RuntimeException(caughtThrowable);
}
}
}
