/*
* 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.context;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.FacesException;
import javax.faces.application.ProjectStage;
import javax.faces.component.UIComponent;
import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerWrapper;
import javax.faces.context.FacesContext;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.ExceptionQueuedEvent;
import javax.faces.event.ExceptionQueuedEventContext;
import javax.faces.event.SystemEvent;
import javax.servlet.http.HttpServletResponse;
import org.apache.myfaces.lifecycle.ViewNotFoundException;
import org.apache.myfaces.renderkit.ErrorPageWriter;
import org.apache.myfaces.shared.util.WebConfigParamUtils;
import org.apache.myfaces.spi.WebConfigProvider;
import org.apache.myfaces.spi.WebConfigProviderFactory;
/**
* Extended MyFaces-specific ExceptionHandler implementation.
*
* @author Leonardo Uribe
*
*/
public class MyFacesExceptionHandlerWrapperImpl extends ExceptionHandlerWrapper
{
private static final Logger log = Logger.getLogger(MyFacesExceptionHandlerWrapperImpl.class.getName());
private Queue<ExceptionQueuedEvent> handled;
private Queue<ExceptionQueuedEvent> unhandled;
private ExceptionQueuedEvent handledAndThrown;
private ExceptionHandler _delegate;
private boolean _isErrorPagePresent;
private boolean _useMyFacesErrorHandling;
private boolean _inited;
public MyFacesExceptionHandlerWrapperImpl(ExceptionHandler delegate)
{
this._delegate = delegate;
this._inited = false;
}
protected void init()
{
if (!_inited)
{
FacesContext facesContext = FacesContext.getCurrentInstance();
WebConfigProvider webConfigProvider = WebConfigProviderFactory.getWebConfigProviderFactory(
facesContext.getExternalContext()).getWebConfigProvider(facesContext.getExternalContext());
_isErrorPagePresent = webConfigProvider.isErrorPagePresent(facesContext.getExternalContext());
_useMyFacesErrorHandling = WebConfigParamUtils.getBooleanInitParameter(facesContext.getExternalContext(),
ErrorPageWriter.ERROR_HANDLING_PARAMETER, facesContext.isProjectStage(ProjectStage.Development));
_inited = true;
}
}
protected void init(FacesContext facesContext)
{
if (!_inited)
{
if (facesContext == null)
{
facesContext = FacesContext.getCurrentInstance();
}
WebConfigProvider webConfigProvider = WebConfigProviderFactory.getWebConfigProviderFactory(
facesContext.getExternalContext()).getWebConfigProvider(facesContext.getExternalContext());
_isErrorPagePresent = webConfigProvider.isErrorPagePresent(facesContext.getExternalContext());
_useMyFacesErrorHandling = WebConfigParamUtils.getBooleanInitParameter(facesContext.getExternalContext(),
ErrorPageWriter.ERROR_HANDLING_PARAMETER, facesContext.isProjectStage(ProjectStage.Development));
_inited = true;
}
}
protected void init(SystemEvent exceptionQueuedEvent)
{
if (!_inited)
{
if (exceptionQueuedEvent instanceof ExceptionQueuedEvent)
{
ExceptionQueuedEvent eqe = (ExceptionQueuedEvent)exceptionQueuedEvent;
ExceptionQueuedEventContext eqec = eqe.getContext();
if (eqec != null)
{
FacesContext facesContext = eqec.getContext();
if (facesContext != null)
{
init(facesContext);
return;
}
}
}
init(FacesContext.getCurrentInstance());
}
}
protected boolean isUseMyFacesErrorHandling()
{
return _useMyFacesErrorHandling;
}
protected boolean isErrorPagePresent()
{
return _isErrorPagePresent;
}
/**
* {@inheritDoc}
*/
@Override
public ExceptionQueuedEvent getHandledExceptionQueuedEvent()
{
init();
if (!isUseMyFacesErrorHandling())
{
return super.getHandledExceptionQueuedEvent();
}
else
{
return handledAndThrown;
}
}
/**
* {@inheritDoc}
*/
@Override
public Iterable<ExceptionQueuedEvent> getHandledExceptionQueuedEvents()
{
init();
if (!isUseMyFacesErrorHandling())
{
return super.getHandledExceptionQueuedEvents();
}
else
{
return handled == null ? Collections.<ExceptionQueuedEvent>emptyList() : handled;
}
}
/**
* {@inheritDoc}
*/
@Override
public Iterable<ExceptionQueuedEvent> getUnhandledExceptionQueuedEvents()
{
init();
if (!isUseMyFacesErrorHandling())
{
return super.getUnhandledExceptionQueuedEvents();
}
else
{
return unhandled == null ? Collections.<ExceptionQueuedEvent>emptyList() : unhandled;
}
}
/**
* {@inheritDoc}
*/
@Override
public void handle() throws FacesException
{
init();
if (!isUseMyFacesErrorHandling())
{
if (isErrorPagePresent())
{
FacesContext facesContext = FacesContext.getCurrentInstance();
// save current view in the request map to access it on the error page
facesContext.getExternalContext().getRequestMap().put(ErrorPageWriter.VIEW_KEY,
facesContext.getViewRoot());
}
try
{
super.handle();
}
catch (FacesException e)
{
FacesContext facesContext = FacesContext.getCurrentInstance();
if (e.getCause() instanceof ViewNotFoundException)
{
facesContext.getExternalContext().setResponseStatus(HttpServletResponse.SC_NOT_FOUND);
}
else
{
facesContext.getExternalContext().setResponseStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
throw e;
}
return;
}
else
{
if (unhandled != null && !unhandled.isEmpty())
{
if (handled == null)
{
handled = new LinkedList<ExceptionQueuedEvent>();
}
List<Throwable> throwableList = new ArrayList<Throwable>();
List<UIComponent> components = new ArrayList<UIComponent>();
FacesContext facesContext = null;
do
{
// For each ExceptionEvent in the list
// get the event to handle
ExceptionQueuedEvent event = unhandled.peek();
try
{
// call its getContext() method
ExceptionQueuedEventContext context = event.getContext();
if (facesContext == null)
{
facesContext = event.getContext().getContext();
}
// and call getException() on the returned result
Throwable exception = context.getException();
// Upon encountering the first such Exception that is not an instance of
// javax.faces.event.AbortProcessingException
if (!shouldSkip(exception))
{
// set handledAndThrown so that getHandledExceptionQueuedEvent() returns this event
handledAndThrown = event;
Throwable rootCause = getRootCause(exception);
throwableList.add(rootCause == null ? exception : rootCause);
components.add(event.getContext().getComponent());
//break;
}
else
{
// Testing mojarra it logs a message and the exception
// however, this behaviour is not mentioned in the spec
log.log(Level.SEVERE, exception.getClass().getName() + " occured while processing " +
(context.inBeforePhase() ? "beforePhase() of " :
(context.inAfterPhase() ? "afterPhase() of " : "")) +
"phase " + context.getPhaseId() + ": " +
"UIComponent-ClientId=" +
(context.getComponent() != null ?
context.getComponent().getClientId(context.getContext()) : "") + ", " +
"Message=" + exception.getMessage());
log.log(Level.SEVERE, exception.getMessage(), exception);
}
}
finally
{
// if we will throw the Exception or if we just logged it,
// we handled it in either way --> add to handled
handled.add(event);
unhandled.remove(event);
}
} while (!unhandled.isEmpty());
if (facesContext == null)
{
facesContext = FacesContext.getCurrentInstance();
}
if (throwableList.size() == 1)
{
ErrorPageWriter.handle(facesContext, components, throwableList.get(0));
}
else if (throwableList.size() > 1)
{
ErrorPageWriter.handle(facesContext, components,
throwableList.toArray(new Throwable[throwableList.size()]));
}
}
}
}
/**
* {@inheritDoc}
*/
@Override
public void processEvent(SystemEvent exceptionQueuedEvent) throws AbortProcessingException
{
init(exceptionQueuedEvent);
if (!isUseMyFacesErrorHandling())
{
super.processEvent(exceptionQueuedEvent);
}
else
{
if (unhandled == null)
{
unhandled = new LinkedList<ExceptionQueuedEvent>();
}
unhandled.add((ExceptionQueuedEvent)exceptionQueuedEvent);
}
}
protected Throwable getRethrownException(Throwable exception)
{
// Let toRethrow be either the result of calling getRootCause() on the Exception,
// or the Exception itself, whichever is non-null
Throwable toRethrow = getRootCause(exception);
if (toRethrow == null)
{
toRethrow = exception;
}
return toRethrow;
}
protected FacesException wrap(Throwable exception)
{
if (exception instanceof FacesException)
{
return (FacesException) exception;
}
return new FacesException(exception);
}
protected boolean shouldSkip(Throwable exception)
{
return exception instanceof AbortProcessingException;
}
@Override
public ExceptionHandler getWrapped()
{
return _delegate;
}
}