}
@Override
public void runPhase(final FlowProcessingPhaseTemplate flowProcessingPhaseTemplate, final MessageProcessContext messageProcessContext, final PhaseResultNotifier phaseResultNotifier)
{
Work flowExecutionWork = new Work()
{
@Override
public void release()
{
}
@Override
public void run()
{
try
{
try
{
final AtomicReference exceptionThrownDuringFlowProcessing = new AtomicReference();
TransactionalErrorHandlingExecutionTemplate transactionTemplate = TransactionalErrorHandlingExecutionTemplate.
createMainExecutionTemplate(messageProcessContext.getFlowConstruct().getMuleContext(),
(messageProcessContext.getTransactionConfig() == null ? new MuleTransactionConfig() : messageProcessContext.getTransactionConfig()),
messageProcessContext.getFlowConstruct().getExceptionListener());
MuleEvent response = transactionTemplate.execute(new ExecutionCallback<MuleEvent>()
{
@Override
public MuleEvent process() throws Exception
{
try
{
Object message = flowProcessingPhaseTemplate.getOriginalMessage();
if (message == null)
{
return null;
}
MuleEvent muleEvent = flowProcessingPhaseTemplate.getMuleEvent();
muleEvent = flowProcessingPhaseTemplate.beforeRouteEvent(muleEvent);
muleEvent = flowProcessingPhaseTemplate.routeEvent(muleEvent);
muleEvent = flowProcessingPhaseTemplate.afterRouteEvent(muleEvent);
sendResponseIfNeccessary(muleEvent, flowProcessingPhaseTemplate);
return muleEvent;
}
catch (Exception e)
{
exceptionThrownDuringFlowProcessing.set(e);
throw e;
}
}
});
if (exceptionThrownDuringFlowProcessing.get() != null && !(exceptionThrownDuringFlowProcessing.get() instanceof ResponseDispatchException))
{
sendResponseIfNeccessary(response, flowProcessingPhaseTemplate);
}
flowProcessingPhaseTemplate.afterSuccessfulProcessingFlow(response);
}
catch (ResponseDispatchException e)
{
flowProcessingPhaseTemplate.afterFailureProcessingFlow(e);
}
catch (MessagingException e)
{
sendFailureResponseIfNeccessary(e, flowProcessingPhaseTemplate);
flowProcessingPhaseTemplate.afterFailureProcessingFlow(e);
}
phaseResultNotifier.phaseSuccessfully();
}
catch (Exception e)
{
MuleException me = new DefaultMuleException(e);
try
{
flowProcessingPhaseTemplate.afterFailureProcessingFlow(me);
}
catch (MuleException e1)
{
logger.warn("Failure during exception processing in flow template: " + e.getMessage());
if (logger.isDebugEnabled())
{
logger.debug(e);
}
}
phaseResultNotifier.phaseFailure(e);
}
}
};
if (messageProcessContext.supportsAsynchronousProcessing())
{
try
{
messageProcessContext.getFlowExecutionWorkManager().scheduleWork(flowExecutionWork);
}
catch (WorkException e)
{
phaseResultNotifier.phaseFailure(e);
}
}
else
{
flowExecutionWork.run();
}
}