Coverage Report - org.mule.endpoint.DefaultEndpointMessageProcessorChainFactory
 
Classes in this File Line Coverage Branch Coverage Complexity
DefaultEndpointMessageProcessorChainFactory
0%
0/56
0%
0/4
0
 
 1  
 /*
 2  
  * $Id: DefaultEndpointMessageProcessorChainFactory.java 19704 2010-09-22 19:26:15Z tcarlson $
 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.OutboundSessionHandlerMessageProcessor;
 34  
 import org.mule.lifecycle.processor.ProcessIfStartedMessageProcessor;
 35  
 import org.mule.processor.ExceptionHandlingMessageProcessor;
 36  
 import org.mule.processor.TransactionalInterceptingMessageProcessor;
 37  
 import org.mule.processor.builder.InterceptingChainMessageProcessorBuilder;
 38  
 
 39  
 import java.util.ArrayList;
 40  
 import java.util.List;
 41  
 
 42  0
 public class DefaultEndpointMessageProcessorChainFactory implements EndpointMessageProcessorChainFactory
 43  
 {
 44  
     /** Override this method to change the default MessageProcessors. */
 45  
     protected List<MessageProcessor> createInboundMessageProcessors(InboundEndpoint endpoint)
 46  
     {
 47  0
         List<MessageProcessor> list = new ArrayList<MessageProcessor>();
 48  
 
 49  0
         list.add(new ExceptionHandlingMessageProcessor());
 50  0
         list.add(new InboundEndpointMimeTypeCheckingMessageProcessor(endpoint));
 51  0
         list.add(new InboundEndpointPropertyMessageProcessor(endpoint));
 52  0
         list.add(new InboundNotificationMessageProcessor(endpoint));
 53  0
         list.add(new InboundLoggingMessageProcessor(endpoint));
 54  
 
 55  0
         return list;
 56  
     }
 57  
     
 58  
     /** Override this method to change the default MessageProcessors. */
 59  
     protected List<MessageProcessor> createInboundResponseMessageProcessors(InboundEndpoint endpoint)
 60  
     {
 61  0
         List<MessageProcessor> list = new ArrayList<MessageProcessor>();
 62  
 
 63  0
         list.add(new ExceptionHandlingMessageProcessor());
 64  0
         list.add(new InboundExceptionDetailsMessageProcessor(endpoint.getConnector()));
 65  
         
 66  0
         return list;
 67  
     }
 68  
     
 69  
     /** Override this method to change the default MessageProcessors. */
 70  
     protected List<MessageProcessor> createOutboundMessageProcessors(OutboundEndpoint endpoint) throws MuleException
 71  
     {
 72  0
         Connector connector = endpoint.getConnector();
 73  
 
 74  0
         List<MessageProcessor> list = new ArrayList<MessageProcessor>();
 75  
 
 76  
         // Log but don't proceed if connector is not started
 77  0
         list.add(new OutboundLoggingMessageProcessor());
 78  0
         list.add(new ProcessIfStartedMessageProcessor(connector, connector.getLifecycleState()));
 79  
 
 80  
         // Everything is processed within TransactionTemplate
 81  0
         list.add(new TransactionalInterceptingMessageProcessor(endpoint.getTransactionConfig()));
 82  
 
 83  0
         list.add(new OutboundEventTimeoutMessageProcessor());
 84  
 
 85  0
         list.add(new OutboundSessionHandlerMessageProcessor(connector.getSessionHandler()));
 86  0
         list.add(new OutboundEndpointPropertyMessageProcessor());
 87  0
         list.add(new OutboundResponsePropertiesMessageProcessor(endpoint));
 88  0
         list.add(new OutboundEndpointMimeTypeCheckingMessageProcessor(endpoint));
 89  
 
 90  0
         return list;
 91  
     }
 92  
     
 93  
     /** Override this method to change the default MessageProcessors. */
 94  
     protected List<MessageProcessor> createOutboundResponseMessageProcessors(OutboundEndpoint endpoint) throws MuleException
 95  
     {
 96  0
         List<MessageProcessor> list = new ArrayList<MessageProcessor>();
 97  
 
 98  0
         list.add(new OutboundRewriteResponseEventMessageProcessor());
 99  
 
 100  0
         return list;
 101  
     }
 102  
     
 103  
     public MessageProcessor createInboundMessageProcessorChain(InboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target) throws MuleException
 104  
     {
 105  
         // -- REQUEST CHAIN --
 106  0
         InterceptingChainMessageProcessorBuilder requestChainBuilder = new EndpointInterceptingChainMessageProcessorBuilder(endpoint, flowConstruct);
 107  0
         requestChainBuilder.setName("InboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' request chain");
 108  
         // Default MPs
 109  0
         requestChainBuilder.chain(createInboundMessageProcessors(endpoint));
 110  
         // Configured MPs (if any)
 111  0
         requestChainBuilder.chain(endpoint.getMessageProcessors());
 112  
         
 113  
         // -- INVOKE SERVICE --
 114  0
         if (target == null)
 115  
         {
 116  0
             throw new ConfigurationException(MessageFactory.createStaticMessage("No listener (target) has been set for this endpoint"));
 117  
         }
 118  0
         requestChainBuilder.chain(target);
 119  
 
 120  
         // -- RESPONSE CHAIN --
 121  0
         InterceptingChainMessageProcessorBuilder responseChainBuilder = new EndpointInterceptingChainMessageProcessorBuilder(endpoint, flowConstruct);
 122  0
         responseChainBuilder.setName("InboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' response chain");
 123  
         // Default MPs
 124  0
         responseChainBuilder.chain(createInboundResponseMessageProcessors(endpoint));
 125  
         // Configured MPs (if any)
 126  0
         responseChainBuilder.chain(endpoint.getResponseMessageProcessors());
 127  
 
 128  
         // Compose request and response chains. We do this so that if the request
 129  
         // chain returns early the response chain is still invoked.
 130  0
         InterceptingChainMessageProcessorBuilder compositeChainBuilder = new EndpointInterceptingChainMessageProcessorBuilder(endpoint, flowConstruct);
 131  0
         compositeChainBuilder.setName("InboundEndpoint '"+ endpoint.getEndpointURI().getUri() +"' composite request/response chain");
 132  0
         compositeChainBuilder.chain(requestChainBuilder.build(), responseChainBuilder.build());
 133  0
         return compositeChainBuilder.build();
 134  
     }
 135  
 
 136  
     public MessageProcessor createOutboundMessageProcessorChain(OutboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target) throws MuleException
 137  
     {
 138  
         // -- REQUEST CHAIN --
 139  0
         InterceptingChainMessageProcessorBuilder outboundChainBuilder = new EndpointInterceptingChainMessageProcessorBuilder(endpoint, flowConstruct);
 140  0
         outboundChainBuilder.setName("OutboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' request chain");
 141  
         // Default MPs
 142  0
         outboundChainBuilder.chain(createOutboundMessageProcessors(endpoint));
 143  
         // Configured MPs (if any)
 144  0
         outboundChainBuilder.chain(endpoint.getMessageProcessors());
 145  
         
 146  
         // -- OUTBOUND ROUTER --
 147  0
         if (target == null)
 148  
         {
 149  0
             throw new ConfigurationException(MessageFactory.createStaticMessage("No listener (target) has been set for this endpoint"));
 150  
         }
 151  0
         outboundChainBuilder.chain(target);
 152  
         
 153  
         // -- RESPONSE CHAIN --
 154  0
         InterceptingChainMessageProcessorBuilder responseChainBuilder = new EndpointInterceptingChainMessageProcessorBuilder(endpoint, flowConstruct);
 155  0
         responseChainBuilder.setName("OutboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' response chain");
 156  
         // Default MPs
 157  0
         responseChainBuilder.chain(createOutboundResponseMessageProcessors(endpoint));
 158  
         // Configured MPs (if any)
 159  0
         responseChainBuilder.chain(endpoint.getResponseMessageProcessors());
 160  
 
 161  
         // Compose request and response chains. We do this so that if the request
 162  
         // chain returns early the response chain is still invoked.
 163  0
         InterceptingChainMessageProcessorBuilder compositeChainBuilder = new EndpointInterceptingChainMessageProcessorBuilder(endpoint, flowConstruct);
 164  0
         compositeChainBuilder.setName("OutboundEndpoint '" + endpoint.getEndpointURI().getUri() + "' composite request/response chain");
 165  0
         compositeChainBuilder.chain(outboundChainBuilder.build(), responseChainBuilder.build());
 166  0
         return compositeChainBuilder.build();
 167  
     }
 168  
     
 169  
 }
 170  
 
 171