View Javadoc

1   /*
2    * $Id: DefaultEndpointMessageProcessorChainFactory.java 23247 2011-10-24 17:16:56Z mike.schilling $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.endpoint;
12  
13  import org.mule.api.MuleException;
14  import org.mule.api.config.ConfigurationException;
15  import org.mule.api.construct.FlowConstruct;
16  import org.mule.api.endpoint.EndpointMessageProcessorChainFactory;
17  import org.mule.api.endpoint.InboundEndpoint;
18  import org.mule.api.endpoint.OutboundEndpoint;
19  import org.mule.api.processor.MessageProcessor;
20  import org.mule.api.transport.Connector;
21  import org.mule.config.i18n.MessageFactory;
22  import org.mule.endpoint.inbound.InboundEndpointMimeTypeCheckingMessageProcessor;
23  import org.mule.endpoint.inbound.InboundEndpointPropertyMessageProcessor;
24  import org.mule.endpoint.inbound.InboundExceptionDetailsMessageProcessor;
25  import org.mule.endpoint.inbound.InboundLoggingMessageProcessor;
26  import org.mule.endpoint.inbound.InboundNotificationMessageProcessor;
27  import org.mule.endpoint.outbound.OutboundEndpointMimeTypeCheckingMessageProcessor;
28  import org.mule.endpoint.outbound.OutboundEndpointPropertyMessageProcessor;
29  import org.mule.endpoint.outbound.OutboundEventTimeoutMessageProcessor;
30  import org.mule.endpoint.outbound.OutboundLoggingMessageProcessor;
31  import org.mule.endpoint.outbound.OutboundResponsePropertiesMessageProcessor;
32  import org.mule.endpoint.outbound.OutboundRewriteResponseEventMessageProcessor;
33  import org.mule.endpoint.outbound.OutboundRootMessageIdPropertyMessageProcessor;
34  import org.mule.endpoint.outbound.OutboundSessionHandlerMessageProcessor;
35  import org.mule.lifecycle.processor.ProcessIfStartedMessageProcessor;
36  import org.mule.processor.TransactionalInterceptingMessageProcessor;
37  import org.mule.processor.chain.DefaultMessageProcessorChainBuilder;
38  import org.mule.routing.requestreply.ReplyToPropertyRequestReplyReplier;
39  
40  import java.util.ArrayList;
41  import java.util.List;
42  
43  public class DefaultEndpointMessageProcessorChainFactory implements EndpointMessageProcessorChainFactory
44  {
45      /** Override this method to change the default MessageProcessors. */
46      protected List<MessageProcessor> createInboundMessageProcessors(InboundEndpoint endpoint)
47      {
48          List<MessageProcessor> list = new ArrayList<MessageProcessor>();
49  
50          list.add(new InboundEndpointMimeTypeCheckingMessageProcessor(endpoint));
51          list.add(new InboundEndpointPropertyMessageProcessor(endpoint));
52          list.add(new InboundNotificationMessageProcessor(endpoint));
53          list.add(new InboundLoggingMessageProcessor(endpoint));
54  
55          return list;
56      }
57      
58      /** Override this method to change the default MessageProcessors. */
59      protected List<MessageProcessor> createInboundResponseMessageProcessors(InboundEndpoint endpoint)
60      {
61          List<MessageProcessor> list = new ArrayList<MessageProcessor>();
62  
63          list.add(new InboundExceptionDetailsMessageProcessor(endpoint.getConnector()));
64          list.add(new ReplyToPropertyRequestReplyReplier());
65          
66          return list;
67      }
68      
69      /** Override this method to change the default MessageProcessors. */
70      protected List<MessageProcessor> createOutboundMessageProcessors(OutboundEndpoint endpoint) throws MuleException
71      {
72          Connector connector = endpoint.getConnector();
73  
74          List<MessageProcessor> list = new ArrayList<MessageProcessor>();
75  
76          // Log but don't proceed if connector is not started
77          list.add(new OutboundLoggingMessageProcessor());
78          list.add(new ProcessIfStartedMessageProcessor(connector, connector.getLifecycleState()));
79  
80          // Everything is processed within TransactionTemplate
81          list.add(new TransactionalInterceptingMessageProcessor(endpoint.getTransactionConfig()));
82  
83          list.add(new OutboundEventTimeoutMessageProcessor());
84  
85          list.add(new OutboundSessionHandlerMessageProcessor(connector.getSessionHandler()));
86          list.add(new OutboundEndpointPropertyMessageProcessor(endpoint));
87          list.add(new OutboundRootMessageIdPropertyMessageProcessor());
88          list.add(new OutboundResponsePropertiesMessageProcessor(endpoint));
89          list.add(new OutboundEndpointMimeTypeCheckingMessageProcessor(endpoint));
90  
91          return list;
92      }
93      
94      /** Override this method to change the default MessageProcessors. */
95      protected List<MessageProcessor> createOutboundResponseMessageProcessors(OutboundEndpoint endpoint) throws MuleException
96      {
97          List<MessageProcessor> list = new ArrayList<MessageProcessor>();
98  
99          list.add(new OutboundRewriteResponseEventMessageProcessor());
100 
101         return list;
102     }
103     
104     public MessageProcessor createInboundMessageProcessorChain(InboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target) throws MuleException
105     {
106         // -- REQUEST CHAIN --
107         DefaultMessageProcessorChainBuilder requestChainBuilder = new EndpointMessageProcessorChainBuilder(endpoint, flowConstruct);
108         requestChainBuilder.setName("InboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' request chain");
109         // Default MPs
110         requestChainBuilder.chain(createInboundMessageProcessors(endpoint));
111         // Configured MPs (if any)
112         if (endpoint.getRedeliveryPolicy() != null)
113         {
114             requestChainBuilder.chain(endpoint.getRedeliveryPolicy());
115         }
116         requestChainBuilder.chain(endpoint.getMessageProcessors());
117         
118         // -- INVOKE SERVICE --
119         if (target == null)
120         {
121             throw new ConfigurationException(MessageFactory.createStaticMessage("No listener (target) has been set for this endpoint"));
122         }
123         requestChainBuilder.chain(target);
124 
125         // -- RESPONSE CHAIN --
126         DefaultMessageProcessorChainBuilder responseChainBuilder = new EndpointMessageProcessorChainBuilder(endpoint, flowConstruct);
127         responseChainBuilder.setName("InboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' response chain");
128         // Default MPs
129         responseChainBuilder.chain(createInboundResponseMessageProcessors(endpoint));
130         // Configured MPs (if any)
131         responseChainBuilder.chain(endpoint.getResponseMessageProcessors());
132 
133         // Compose request and response chains. We do this so that if the request
134         // chain returns early the response chain is still invoked.
135         DefaultMessageProcessorChainBuilder compositeChainBuilder = new EndpointMessageProcessorChainBuilder(endpoint, flowConstruct);
136         compositeChainBuilder.setName("InboundEndpoint '"+ endpoint.getEndpointURI().getUri() +"' composite request/response chain");
137         compositeChainBuilder.chain(requestChainBuilder.build(), responseChainBuilder.build());
138         return compositeChainBuilder.build();
139     }
140 
141     public MessageProcessor createOutboundMessageProcessorChain(OutboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target) throws MuleException
142     {
143         // -- REQUEST CHAIN --
144         DefaultMessageProcessorChainBuilder outboundChainBuilder = new EndpointMessageProcessorChainBuilder(endpoint, flowConstruct);
145         outboundChainBuilder.setName("OutboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' request chain");
146         // Default MPs
147         outboundChainBuilder.chain(createOutboundMessageProcessors(endpoint));
148         // Configured MPs (if any)
149         outboundChainBuilder.chain(endpoint.getMessageProcessors());
150         
151         // -- OUTBOUND ROUTER --
152         if (target == null)
153         {
154             throw new ConfigurationException(MessageFactory.createStaticMessage("No listener (target) has been set for this endpoint"));
155         }
156         outboundChainBuilder.chain(target);
157         
158         // -- RESPONSE CHAIN --
159         DefaultMessageProcessorChainBuilder responseChainBuilder = new EndpointMessageProcessorChainBuilder(endpoint, flowConstruct);
160         responseChainBuilder.setName("OutboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' response chain");
161         // Default MPs
162         responseChainBuilder.chain(createOutboundResponseMessageProcessors(endpoint));
163         // Configured MPs (if any)
164         responseChainBuilder.chain(endpoint.getResponseMessageProcessors());
165 
166         // Compose request and response chains. We do this so that if the request
167         // chain returns early the response chain is still invoked.
168         DefaultMessageProcessorChainBuilder compositeChainBuilder = new EndpointMessageProcessorChainBuilder(endpoint, flowConstruct);
169         compositeChainBuilder.setName("OutboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' composite request/response chain");
170         compositeChainBuilder.chain(outboundChainBuilder.build(), responseChainBuilder.build());
171         return compositeChainBuilder.build();
172     }
173     
174 }
175 
176