/** * A helper constructor used to rewrite an event payload * * @param message The message to use as the current payload of the event * @param rewriteEvent the previous event that will be used as a template for this event */ public DefaultMuleEvent(MuleMessage message, MuleEvent rewriteEvent) { this(message, rewriteEvent, rewriteEvent.getSession()); }
public MuleSession getSession() { return event.getSession(); }
/** * Copy constructor to be used when synchronicity, * {@link org.mule.MessageExchangePattern} and {@link ReplyToHandler} all need changing. */ public DefaultMuleEvent(MuleMessage message, MuleEvent rewriteEvent, boolean synchronus, boolean shareFlowVars, MessageExchangePattern messageExchangePattern, ReplyToHandler replyToHandler) { this(message, rewriteEvent, rewriteEvent.getFlowConstruct(), rewriteEvent.getSession(), synchronus, shareFlowVars, messageExchangePattern, replyToHandler); }
public DefaultMuleEvent(MuleMessage message, MuleEvent rewriteEvent, boolean synchronus) { this(message, rewriteEvent, rewriteEvent.getFlowConstruct(), rewriteEvent.getSession(), synchronus); }
protected MuleSession getMergedSession(MuleEvent[] events) { MuleSession session = new DefaultMuleSession(events[0].getSession()); for (int i = 1; i < events.length; i++) { for (String name : events[i].getSession().getPropertyNamesAsSet()) { session.setProperty(name, events[i].getSession().getProperty(name)); } } return session; }
private void addAndOverrideSessionProperties(MuleSession session, MuleEvent event) { for (String name : event.getSession().getPropertyNamesAsSet()) { session.setProperty(name, event.getSession().getProperty(name)); } }
public DefaultMuleEventContext(MuleEvent event) { this.event = event; this.session = event.getSession(); this.muleContext = event.getMuleContext(); this.clientInterface = muleContext.getClient(); }
public DefaultMuleEvent(MuleEvent rewriteEvent, FlowConstruct flowConstruct) { this(rewriteEvent.getMessage(), rewriteEvent, flowConstruct, rewriteEvent.getSession(), rewriteEvent.isSynchronous()); }
public DefaultMuleEvent(MuleEvent rewriteEvent, FlowConstruct flowConstruct, ReplyToHandler replyToHandler, Object replyToDestination, boolean synchronous) { this(rewriteEvent.getMessage(), rewriteEvent, flowConstruct, rewriteEvent.getSession(), synchronous, replyToHandler, replyToDestination, true, rewriteEvent.getExchangePattern()); }
/** * Copy constructor to be used when synchronicity and {@link org.mule.MessageExchangePattern} both need changing. */ public DefaultMuleEvent(MuleMessage message, MuleEvent rewriteEvent, boolean synchronus, boolean shareFlowVars, MessageExchangePattern messageExchangePattern) { this(message, rewriteEvent, rewriteEvent.getFlowConstruct(), rewriteEvent.getSession(), synchronus, shareFlowVars, messageExchangePattern, rewriteEvent.getReplyToHandler()); }
public MuleEvent process(MuleEvent event) throws MuleException { sessionHandler.storeSessionInfoToMessage(event.getSession(), event.getMessage()); return event; }
public DefaultMuleEvent(MuleEvent rewriteEvent, FlowConstruct flowConstruct, ReplyToHandler replyToHandler, Object replyToDestination) { this(rewriteEvent.getMessage(), rewriteEvent, flowConstruct, rewriteEvent.getSession(), rewriteEvent.isSynchronous(), replyToHandler, replyToDestination, true, rewriteEvent.getExchangePattern()); }
public DefaultMuleEvent(MuleMessage message, MuleEvent rewriteEvent, boolean synchronus, boolean shareFlowVars) { this(message, rewriteEvent, rewriteEvent.getFlowConstruct(), rewriteEvent.getSession(), synchronus, shareFlowVars, rewriteEvent.getExchangePattern(), rewriteEvent.getReplyToHandler()); }
protected MuleSession getMergedSession() throws ObjectStoreException { MuleEvent lastStoredEvent = retrieveLastStoredEvent(); MuleSession session = new DefaultMuleSession( lastStoredEvent.getSession()); for (Serializable key : eventsObjectStore.allKeys(eventsPartitionKey)) { if (!key.equals(lastStoredEventKey)) { MuleEvent event = eventsObjectStore.retrieve(key, eventsPartitionKey); addAndOverrideSessionProperties(session, event); } } addAndOverrideSessionProperties(session, lastStoredEvent); return session; }
public MuleEvent process(MuleEvent event) throws MessagingException { try { return endpoint.process(new DefaultMuleEvent(event.getMessage(), endpoint.getExchangePattern(), flow, event.getSession())); } catch (MessagingException e) { throw e; } catch (MuleException e) { throw new MessagingException(e.getI18nMessage(), event, e, endpoint); } }
/** * This method does a complete deep copy of the event. * * This method should be used whenever the event is going to be executed * in a different context and changes to that event must not effect the source event. * * @param event the event that must be copied * @return the copied event */ public static MuleEvent copy(MuleEvent event) { MuleMessage messageCopy = (MuleMessage) ((ThreadSafeAccess) event.getMessage()).newThreadCopy(); DefaultMuleEvent eventCopy = new DefaultMuleEvent(messageCopy, event, new DefaultMuleSession( event.getSession())); eventCopy.flowVariables = ((DefaultMuleEvent) event).flowVariables.clone(); ((DefaultMuleMessage) messageCopy).setInvocationProperties(eventCopy.flowVariables); ((DefaultMuleMessage) messageCopy).resetAccessControl(); return eventCopy; }
private MuleEvent createResponseEvent(MuleMessage resultMessage, MuleEvent requestEvent) throws MuleException { if (resultMessage != null) { resultMessage.setMessageRootId(requestEvent.getMessage().getMessageRootId()); // Ensure ENCODING message property is set to give exactly same behavior as before // OutboundRewriteResponseEventMessageProcessor was removed (MULE-7535). resultMessage.setEncoding(resultMessage.getEncoding()); MuleSession storedSession = connector.getSessionHandler().retrieveSessionInfoFromMessage( resultMessage); requestEvent.getSession().merge(storedSession); MuleEvent resultEvent = new DefaultMuleEvent(resultMessage, requestEvent); unsafeSetEvent(resultEvent); return resultEvent; } else { return null; } }
private MuleEvent createMessageCollection(final List<MuleEvent> nonNullResults, final MuleEvent previous, MuleContext muleContext) { MuleMessageCollection coll = new DefaultMessageCollection(muleContext); for (MuleEvent event : nonNullResults) { coll.addMessage(event.getMessage()); } coll.propagateRootId(previous.getMessage()); MuleEvent resultEvent = new DefaultMuleEvent(coll, previous, previous.getSession()); for (String name : previous.getFlowVariableNames()) { resultEvent.setFlowVariable(name, previous.getFlowVariable(name), previous.getFlowVariableDataType(name)); } return OptimizedRequestContext.unsafeSetEvent(resultEvent); } }
public void dispatch(String url, MuleMessage message) throws MuleException { final MessageProcessor connectorMessageProcessor = getConnectorMessageProcessLocator().locateConnectorOperation(url, newOptions().build(), MessageExchangePattern.ONE_WAY); if (connectorMessageProcessor != null) { connectorMessageProcessor.process(createRequestResponseMuleEvent(message)); } else { OutboundEndpoint endpoint = endpointCache.getOutboundEndpoint(url, MessageExchangePattern.ONE_WAY, null); if (RequestContext.getEvent() != null) { endpoint.process(createMuleEvent(message, endpoint, RequestContext.getEvent().getSession())); } else { endpoint.process(createMuleEvent(message, endpoint)); } } }
public MuleMessage send(String url, MuleMessage message) throws MuleException { final MessageProcessor connectorMessageProcessor = getConnectorMessageProcessLocator().locateConnectorOperation(url, newOptions().build(), MessageExchangePattern.REQUEST_RESPONSE); if (connectorMessageProcessor != null) { return returnMessage(connectorMessageProcessor.process(createRequestResponseMuleEvent(message))); } else { OutboundEndpoint endpoint = endpointCache.getOutboundEndpoint(url, MessageExchangePattern.REQUEST_RESPONSE, null); if (RequestContext.getEvent() != null) { return returnMessage(endpoint.process(createMuleEvent(message, endpoint, RequestContext.getEvent().getSession()))); } else { return returnMessage(endpoint.process(createMuleEvent(message, endpoint))); } } }