protected DefaultMuleEvent(MuleMessage message, MuleEvent rewriteEvent, FlowConstruct flowConstruct, MuleSession session, boolean synchronous, boolean shareFlowVars, MessageExchangePattern messageExchangePattern, ReplyToHandler replyToHandler) { this(message, rewriteEvent, flowConstruct, session, synchronous, replyToHandler, rewriteEvent.getReplyToDestination(), shareFlowVars, messageExchangePattern); }
protected DefaultMuleEvent(MuleMessage message, MuleEvent rewriteEvent, FlowConstruct flowConstruct, MuleSession session, boolean synchronous) { this(message, rewriteEvent, flowConstruct, session, synchronous, rewriteEvent.getReplyToHandler(), rewriteEvent.getReplyToDestination(), true, rewriteEvent.getExchangePattern()); }
private MuleEvent createReturnEventForParentFlowConstruct(MuleEvent result, MuleEvent original) { if (result != null && !(result instanceof VoidMuleEvent)) { // Create new event with original FlowConstruct, ReplyToHandler and synchronous result = new DefaultMuleEvent(result, original.getFlowConstruct(), original.getReplyToHandler(), original.getReplyToDestination(), original.isSynchronous()); } resetRequestContextEvent(result); return result; }
@Override public MuleEvent process(MuleEvent event) throws MuleException { MuleEvent resultEvent; if (shouldProcessEvent(event)) { Object replyTo = event.getReplyToDestination(); ReplyToHandler replyToHandler = event.getReplyToHandler(); resultEvent = processNext(event); // Allow components to stop processing of the ReplyTo property (e.g. CXF) final String replyToStop = resultEvent.getMessage().getInvocationProperty( MuleProperties.MULE_REPLY_TO_STOP_PROPERTY); if (resultEvent != null && !VoidMuleEvent.getInstance().equals(resultEvent) && !BooleanUtils.toBoolean(replyToStop)) { // reply-to processing should not resurrect a dead event processReplyTo(event, resultEvent, replyToHandler, replyTo); } } else { resultEvent = processNext(event); } return resultEvent; }
@Override protected void preProcess(MessageProcessor processor) { if (event.isAllowNonBlocking()) { if (!processorSupportsNonBlocking(processor)) { fallbackWarning.warn(processor.getClass()); // Make event synchronous so that non-blocking is not used event = new DefaultMuleEvent(event, event.getFlowConstruct(), event.getReplyToHandler(), event.getReplyToDestination(), true); // Update RequestContext ThreadLocal for backwards compatibility OptimizedRequestContext.unsafeSetEvent(event); } if (processor instanceof NonBlockingMessageProcessor) { // Even if there is no ReplyToHandler available, using non-blocking processing anyway for a non-blocking // message processor if a response isn't required. if (!(messageExchangePattern.hasResponse() && replyToHandler == null)) { event = new DefaultMuleEvent(event, new NonBlockingProcessorExecutorReplyToHandler()); // Update RequestContext ThreadLocal for backwards compatibility OptimizedRequestContext.unsafeSetEvent(event); } } } }
@Override public MuleEvent process(final MuleEvent event) throws MuleException { final MuleEvent newEvent = createMuleEventForCurrentFlow(event, event.getReplyToDestination(), event.getReplyToHandler()); try { ExecutionTemplate<MuleEvent> executionTemplate = ErrorHandlingExecutionTemplate.createErrorHandlingExecutionTemplate(muleContext, getExceptionListener()); MuleEvent result = executionTemplate.execute(new ExecutionCallback<MuleEvent>() { @Override public MuleEvent process() throws Exception { return pipeline.process(newEvent); } }); return createReturnEventForParentFlowConstruct(result, event); } catch (MessagingException e) { e.setProcessedEvent(createReturnEventForParentFlowConstruct(e.getEvent(), event)); throw e; } catch (Exception e) { resetRequestContextEvent(event); throw new DefaultMuleException(CoreMessages.createStaticMessage("Flow execution exception"),e); } }
Object replyTo = event.getReplyToDestination(); ReplyToHandler replyToHandler = event.getReplyToHandler();