org.mule.runtime.core.api.util

Class ExceptionUtils

java.lang.Object

org.mule.runtime.core.api.util.ExceptionUtils

public class ExceptionUtils
extends Object

Mule exception utilities.

Constructor Summary

Constructors

Constructor and Description
ExceptionUtils()

Method Summary

Modifier and Type	Method and Description
static boolean	containsType(Throwable throwable, Class<?> type) This method returns true if the throwable contains a Throwable that matches the specified class or subclass in the exception chain.
static Event	createErrorEvent(Event currentEvent, Object annotatedObject, MessagingException messagingException, ErrorTypeLocator errorTypeLocator) Create new Event with Error instance set.
static Optional<Throwable>	extractCauseOfType(Throwable throwable, Class<? extends Throwable> throwableType) Introspects the Throwable parameter to obtain the first Throwable of type throwableType in the exception chain and return the cause of it.
static Optional<org.mule.runtime.api.connection.ConnectionException>	extractConnectionException(Throwable throwable) Introspects the Throwable parameter to obtain the first Throwable of type ConnectionException in the exception chain.
static <T extends Throwable> Optional<T>	extractOfType(Throwable throwable, Class<T> throwableType) Introspects the Throwable parameter to obtain the first Throwable of type throwableType in the exception chain.
static <ET> ET	getDeepestOccurrenceOfType(Throwable throwable, Class<ET> type) This method returns the throwable closest to the root cause that matches the specified class or subclass.
static org.mule.runtime.api.message.Error	getErrorFromFailingProcessor(Object annotatedObject, Throwable causeException, ErrorTypeLocator errorTypeLocator)
static org.mule.runtime.api.message.ErrorType	getErrorTypeFromFailingProcessor(Object annotatedObject, Throwable exception, ErrorTypeLocator errorTypeLocator) Determine the ErrorType of a given exception thrown by a given message processor.
static String	getFullStackTraceWithoutMessages(Throwable throwable) Similar to ExceptionUtils.getFullStackTrace(Throwable) but removing the exception and causes messages.
static Throwable	getRootCauseException(Throwable exception) Resolve the root cause of an exception.
static MessagingException	putContext(MessagingException messagingException, Processor failingMessageProcessor, Event event, FlowConstruct flowConstruct, MuleContext muleContext)
static <T,E extends Exception> T	tryExpecting(Class<E> expectedExceptionType, Callable<T> callable, ExceptionHandler<T,E> exceptionHandler) Executes the given callable knowing that it might throw an Exception of type expectedExceptionType.
static MessagingException	updateMessagingException(org.slf4j.Logger logger, Processor processor, MessagingException exception, ErrorTypeLocator errorTypeLocator, ErrorTypeRepository errorTypeRepository, FlowConstruct flowConstruct, MuleContext muleContext) Updates the MessagingException to be thrown based on the content of the exception parameter and the chain of causes inside it.
static MessagingException	updateMessagingExceptionWithError(MessagingException exception, Processor failing, FlowConstruct flowConstruct)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ExceptionUtils

public ExceptionUtils()

Method Detail

containsType

public static boolean containsType(Throwable throwable,
                                   Class<?> type)

This method returns true if the throwable contains a Throwable that matches the specified class or subclass in the exception chain. Subclasses of the specified class do match.

Parameters:

throwable - the throwable to inspect, may be null

type - the type to search for, subclasses match, null returns false

Returns:

the index into the throwable chain, false if no match or null input

getDeepestOccurrenceOfType

public static <ET> ET getDeepestOccurrenceOfType(Throwable throwable,
                                                 Class<ET> type)

This method returns the throwable closest to the root cause that matches the specified class or subclass. Any null argument will make the method return null.

Parameters:

throwable - the throwable to inspect, may be null

type - the type to search for, subclasses match, null returns null

Returns:

the throwable that is closest to the root in the throwable chain that matches the type or subclass of that type.

getFullStackTraceWithoutMessages

public static String getFullStackTraceWithoutMessages(Throwable throwable)

Similar to ExceptionUtils.getFullStackTrace(Throwable) but removing the exception and causes messages. This is useful to determine if two exceptions have matching stack traces regardless of the messages which may contain invokation specific data

Parameters:

throwable - the throwable to inspect, may be null

Returns:

the stack trace as a string, with the messages stripped out. Empty string if throwable was null

extractConnectionException

public static Optional<org.mule.runtime.api.connection.ConnectionException> extractConnectionException(Throwable throwable)

Introspects the Throwable parameter to obtain the first Throwable of type ConnectionException in the exception chain.

Parameters:

throwable - the last throwable in the exception chain.

Returns:

an Optional value with the first ConnectionException in the exception chain if any.

extractCauseOfType

public static Optional<Throwable> extractCauseOfType(Throwable throwable,
                                                     Class<? extends Throwable> throwableType)

Introspects the Throwable parameter to obtain the first Throwable of type throwableType in the exception chain and return the cause of it.

Parameters:

throwable - the last throwable on the exception chain.

throwableType - the type of the throwable that the cause is wanted.

Returns:

the cause of the first Throwable of type throwableType.

extractOfType

public static <T extends Throwable> Optional<T> extractOfType(Throwable throwable,
                                                              Class<T> throwableType)

Introspects the Throwable parameter to obtain the first Throwable of type throwableType in the exception chain.

This method handles recursive cause structures that might otherwise cause infinite loops. If the throwable parameter is a ConnectionException the same value will be returned. If the throwable parameter has a cause of itself, then an empty value will be returned.

Parameters:

throwable - the last throwable on the exception chain.

throwableType - the type of the throwable is wanted to find.

Returns:

the cause of the first Throwable of type throwableType.

tryExpecting

public static <T,E extends Exception> T tryExpecting(Class<E> expectedExceptionType,
                                                     Callable<T> callable,
                                                     ExceptionHandler<T,E> exceptionHandler)
                                              throws E extends Exception

Executes the given callable knowing that it might throw an Exception of type expectedExceptionType. If that happens, then it will re throw such exception.

If the callable throws a RuntimeException of a different type, then it is also re-thrown. Finally, if an exception of any different type is thrown, then it is handled by delegating into the exceptionHandler, which might in turn also throw an exception or handle it returning a value.

Type Parameters:

T - the generic type of the return value

E - the generic type of the expected exception

Parameters:

expectedExceptionType - the type of exception which is expected to be thrown

callable - the delegate to be executed

exceptionHandler - a ExceptionHandler in case an unexpected exception is found instead

Returns:

a value returned by either the callable or the exceptionHandler

Throws:

E - if the expected exception is actually thrown

E extends Exception

getErrorTypeFromFailingProcessor

public static org.mule.runtime.api.message.ErrorType getErrorTypeFromFailingProcessor(Object annotatedObject,
                                                                                      Throwable exception,
                                                                                      ErrorTypeLocator errorTypeLocator)

Determine the ErrorType of a given exception thrown by a given message processor.

Parameters:

annotatedObject - the component that threw the exception.

exception - the exception thrown.

errorTypeLocator - the ErrorTypeLocator.

Returns:

the resolved ErrorType

putContext

public static MessagingException putContext(MessagingException messagingException,
                                            Processor failingMessageProcessor,
                                            Event event,
                                            FlowConstruct flowConstruct,
                                            MuleContext muleContext)

createErrorEvent

public static Event createErrorEvent(Event currentEvent,
                                     Object annotatedObject,
                                     MessagingException messagingException,
                                     ErrorTypeLocator errorTypeLocator)

Create new Event with Error instance set.

Parameters:

currentEvent - event when error occured.

annotatedObject - message processor/source.

messagingException - messaging exception.

errorTypeLocator - the mule context.

Returns:

new Event with relevant Error set.

updateMessagingException

public static MessagingException updateMessagingException(org.slf4j.Logger logger,
                                                          Processor processor,
                                                          MessagingException exception,
                                                          ErrorTypeLocator errorTypeLocator,
                                                          ErrorTypeRepository errorTypeRepository,
                                                          FlowConstruct flowConstruct,
                                                          MuleContext muleContext)

Updates the MessagingException to be thrown based on the content of the exception parameter and the chain of causes inside it.

Parameters:

logger - instance to use for logging

processor - the failing processor

exception - the exception to update based on it's content

errorTypeLocator - the error type locator

errorTypeRepository - the error type repository

flowConstruct - the flow associated with the exception

muleContext - the context of the artifact

Returns:

a MessagingException with the proper Error associated to it's Event

getErrorFromFailingProcessor

public static org.mule.runtime.api.message.Error getErrorFromFailingProcessor(Object annotatedObject,
                                                                              Throwable causeException,
                                                                              ErrorTypeLocator errorTypeLocator)

getRootCauseException

public static Throwable getRootCauseException(Throwable exception)

Resolve the root cause of an exception. If the exception is an instance of ErrorMessageAwareException then it's root cause is used, else the candidate exception instance if returned.

Parameters:

exception - candidate exception.

Returns:

root cause exception.

updateMessagingExceptionWithError

public static MessagingException updateMessagingExceptionWithError(MessagingException exception,
                                                                   Processor failing,
                                                                   FlowConstruct flowConstruct)