/*
* 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.wicket.settings;
import org.apache.wicket.util.lang.Args;
import org.apache.wicket.util.lang.EnumeratedType;
/**
*
* Settings class for configuring exception handling related settings.
* <p>
* <i>unexpectedExceptionDisplay </i> (defaults to SHOW_EXCEPTION_PAGE) - Determines how exceptions
* are displayed to the developer or user
* <p>
* <i>throwExceptionOnMissingResource </i> (defaults to true) - Set to true to throw a runtime
* exception if a required string resource is not found. Set to false to return the requested
* resource key surrounded by pairs of question mark characters (e.g. "??missingKey??")
*
* @author Jonathan Locke
* @author Chris Turner
* @author Eelco Hillenius
* @author Juergen Donnerstag
* @author Johan Compagner
* @author Igor Vaynberg (ivaynberg)
* @author Martijn Dashorst
* @author James Carman
*/
public class ExceptionSettings
{
/**
* Enumerated type for different ways of displaying unexpected exceptions.
*/
public static final class UnexpectedExceptionDisplay extends EnumeratedType
{
private static final long serialVersionUID = 1L;
UnexpectedExceptionDisplay(final String name)
{
super(name);
}
}
/**
* Indicates that an exception page appropriate to development should be shown when an
* unexpected exception is thrown.
*/
public static final UnexpectedExceptionDisplay SHOW_EXCEPTION_PAGE = new UnexpectedExceptionDisplay(
"SHOW_EXCEPTION_PAGE");
/**
* Indicates a generic internal error page should be shown when an unexpected exception is
* thrown.
*/
public static final UnexpectedExceptionDisplay SHOW_INTERNAL_ERROR_PAGE = new UnexpectedExceptionDisplay(
"SHOW_INTERNAL_ERROR_PAGE");
/**
* Indicates that no exception page should be shown when an unexpected exception is thrown.
*/
public static final UnexpectedExceptionDisplay SHOW_NO_EXCEPTION_PAGE = new UnexpectedExceptionDisplay(
"SHOW_NO_EXCEPTION_PAGE");
/**
* How to handle errors while processing an Ajax request
*
* @author igor
*/
public enum AjaxErrorStrategy {
/** redirect to error page, just like a normal requset */
REDIRECT_TO_ERROR_PAGE,
/** invoke client side failure handler */
INVOKE_FAILURE_HANDLER
}
/**
* Which threads' stacktrace to dump when a page lock timeout occurs
*
* @author papegaaij
*/
public enum ThreadDumpStrategy {
/** Do not dump any stacktraces */
NO_THREADS,
/** Dump the stacktrace of the thread holding the lock */
THREAD_HOLDING_LOCK,
/** Dump stacktraces of all threads of the application */
ALL_THREADS
}
/**
* A strategy defining what to do when a component that will not render its
* markup tag (because of {@link org.apache.wicket.Component#setRenderBodyOnly(boolean) setRenderBodyOnly(true)}
* or used with <wicket:xyz>) is also asked to output a
* markup {@link org.apache.wicket.Component#setOutputMarkupId(boolean) id} or
* {@link org.apache.wicket.Component#setOutputMarkupPlaceholderTag(boolean) placeholder tag}
*/
public enum NotRenderableErrorStrategy {
/**
* Log a message with level {@link org.slf4j.Logger#warn(String) WARNING}
*/
LOG_WARNING,
/**
* Throw a runtime exception
*/
THROW_EXCEPTION
}
/** Type of handling for unexpected exceptions */
private UnexpectedExceptionDisplay unexpectedExceptionDisplay = SHOW_EXCEPTION_PAGE;
private AjaxErrorStrategy errorHandlingStrategyDuringAjaxRequests = AjaxErrorStrategy.REDIRECT_TO_ERROR_PAGE;
/**
* Strategy to use for dumping stack traces of live threads in the JVM.
* <p>
* By default will dump the stacktrace of the thread that holds the lock on the page.
* </p>
*/
private ThreadDumpStrategy threadDumpStrategy = ThreadDumpStrategy.THREAD_HOLDING_LOCK;
private NotRenderableErrorStrategy notRenderableErrorStrategy = NotRenderableErrorStrategy.LOG_WARNING;
/**
* @return Returns the unexpectedExceptionDisplay.
*/
public UnexpectedExceptionDisplay getUnexpectedExceptionDisplay()
{
return unexpectedExceptionDisplay;
}
/**
* The exception display type determines how the framework displays exceptions to you as a
* developer or user.
* <p>
* The default value for exception display type is SHOW_EXCEPTION_PAGE. When this value is set
* and an unhandled runtime exception is thrown by a page, a redirect to a helpful exception
* display page will occur.
* <p>
* This is a developer feature, however, and you may want to instead show an internal error page
* without developer details that allows a user to start over at the application's home page.
* This can be accomplished by setting the exception display type to SHOW_INTERNAL_ERROR_PAGE.
* <p>
* Finally, if you are having trouble with the exception display pages themselves, you can
* disable exception displaying entirely with the value SHOW_NO_EXCEPTION_PAGE. This will cause
* the framework to re-throw any unhandled runtime exceptions after wrapping them in a
* ServletException wrapper.
*
* @param unexpectedExceptionDisplay
* The unexpectedExceptionDisplay to set.
* @return {@code this} object for chaining
*/
public ExceptionSettings setUnexpectedExceptionDisplay(UnexpectedExceptionDisplay unexpectedExceptionDisplay)
{
this.unexpectedExceptionDisplay = unexpectedExceptionDisplay;
return this;
}
/**
* @return strategy used to handle errors during Ajax request processing
*/
public AjaxErrorStrategy getAjaxErrorHandlingStrategy()
{
return errorHandlingStrategyDuringAjaxRequests;
}
/**
* Sets strategy used to handle errors during Ajax request processing
*
* @param errorHandlingStrategyDuringAjaxRequests
* @return {@code this} object for chaining
*/
public ExceptionSettings setAjaxErrorHandlingStrategy(
AjaxErrorStrategy errorHandlingStrategyDuringAjaxRequests)
{
this.errorHandlingStrategyDuringAjaxRequests = errorHandlingStrategyDuringAjaxRequests;
return this;
}
/**
* Sets the strategy to use for dumping stack traces of live threads in the JVM.
*
* @param strategy
* @return {@code this} object for chaining
*/
public ExceptionSettings setThreadDumpStrategy(ThreadDumpStrategy strategy)
{
threadDumpStrategy = Args.notNull(strategy, "strategy");
return this;
}
/**
* @return strategy to use for dumping stack traces of live threads in the JVM.
*/
public ThreadDumpStrategy getThreadDumpStrategy()
{
return threadDumpStrategy;
}
public NotRenderableErrorStrategy getNotRenderableErrorStrategy() {
return notRenderableErrorStrategy;
}
public void setNotRenderableErrorStrategy(final NotRenderableErrorStrategy notRenderableErrorStrategy) {
this.notRenderableErrorStrategy = notRenderableErrorStrategy;
}
}