Coverage Report - org.mule.transport.service.DefaultTransportServiceDescriptor
 
Classes in this File Line Coverage Branch Coverage Complexity
DefaultTransportServiceDescriptor
0%
0/196
0%
0/76
0
 
 1  
 /*
 2  
  * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
 3  
  * The software in this package is published under the terms of the CPAL v1.0
 4  
  * license, a copy of which has been included with this distribution in the
 5  
  * LICENSE.txt file.
 6  
  */
 7  
 package org.mule.transport.service;
 8  
 
 9  
 import org.mule.MessageExchangePattern;
 10  
 import org.mule.api.MuleContext;
 11  
 import org.mule.api.MuleException;
 12  
 import org.mule.api.config.MuleProperties;
 13  
 import org.mule.api.construct.FlowConstruct;
 14  
 import org.mule.api.endpoint.EndpointBuilder;
 15  
 import org.mule.api.endpoint.EndpointException;
 16  
 import org.mule.api.endpoint.EndpointURIBuilder;
 17  
 import org.mule.api.endpoint.ImmutableEndpoint;
 18  
 import org.mule.api.endpoint.InboundEndpoint;
 19  
 import org.mule.api.registry.AbstractServiceDescriptor;
 20  
 import org.mule.api.transaction.TransactionFactory;
 21  
 import org.mule.api.transformer.Transformer;
 22  
 import org.mule.api.transport.Connector;
 23  
 import org.mule.api.transport.MessageDispatcherFactory;
 24  
 import org.mule.api.transport.MessageReceiver;
 25  
 import org.mule.api.transport.MessageRequesterFactory;
 26  
 import org.mule.api.transport.MuleMessageFactory;
 27  
 import org.mule.api.transport.SessionHandler;
 28  
 import org.mule.config.i18n.CoreMessages;
 29  
 import org.mule.endpoint.EndpointURIEndpointBuilder;
 30  
 import org.mule.endpoint.UrlEndpointURIBuilder;
 31  
 import org.mule.session.SerializeAndEncodeSessionHandler;
 32  
 import org.mule.transaction.XaTransactionFactory;
 33  
 import org.mule.util.ClassUtils;
 34  
 import org.mule.util.CollectionUtils;
 35  
 import org.mule.util.StringUtils;
 36  
 
 37  
 import java.util.ArrayList;
 38  
 import java.util.Collections;
 39  
 import java.util.List;
 40  
 import java.util.Properties;
 41  
 
 42  
 public class DefaultTransportServiceDescriptor extends AbstractServiceDescriptor implements TransportServiceDescriptor
 43  
 {
 44  
     private String connector;
 45  
     private String dispatcherFactory;
 46  
     private String requesterFactory;
 47  
     private String transactionFactory;
 48  
     private String messageFactory;
 49  
     private String messageReceiver;
 50  
     private String transactedMessageReceiver;
 51  
     private String xaTransactedMessageReceiver;
 52  
     private String endpointUriBuilder;
 53  
     private String sessionHandler;
 54  
     private String defaultInboundTransformer;
 55  
     private String defaultOutboundTransformer;
 56  
     private String defaultResponseTransformer;
 57  
     private String endpointBuilder;
 58  
 
 59  0
     private Properties exceptionMappings = new Properties();
 60  
     private MuleContext muleContext;
 61  
     private List<MessageExchangePattern> inboundExchangePatterns;
 62  
     private List<MessageExchangePattern> outboundExchangePatterns;
 63  
     private String defaultExchangePattern;
 64  
 
 65  
     private ClassLoader classLoader;
 66  
 
 67  
     public DefaultTransportServiceDescriptor(String service, Properties props, ClassLoader classLoader)
 68  
     {
 69  0
         super(service);
 70  0
         this.classLoader = classLoader;
 71  0
         init(props);
 72  0
     }
 73  
 
 74  
     protected void init(Properties props)
 75  
     {
 76  0
         connector = removeProperty(MuleProperties.CONNECTOR_CLASS, props);
 77  0
         dispatcherFactory = removeProperty(MuleProperties.CONNECTOR_DISPATCHER_FACTORY, props);
 78  0
         requesterFactory = removeProperty(MuleProperties.CONNECTOR_REQUESTER_FACTORY, props);
 79  0
         transactionFactory = removeProperty(MuleProperties.CONNECTOR_DISPATCHER_FACTORY, props);
 80  0
         messageReceiver = removeProperty(MuleProperties.CONNECTOR_MESSAGE_RECEIVER_CLASS, props);
 81  0
         transactedMessageReceiver = removeProperty(MuleProperties.CONNECTOR_TRANSACTED_MESSAGE_RECEIVER_CLASS, props);
 82  0
         xaTransactedMessageReceiver = removeProperty(MuleProperties.CONNECTOR_XA_TRANSACTED_MESSAGE_RECEIVER_CLASS, props);
 83  0
         messageFactory = removeProperty(MuleProperties.CONNECTOR_MESSAGE_FACTORY, props);
 84  0
         defaultInboundTransformer = removeProperty(MuleProperties.CONNECTOR_INBOUND_TRANSFORMER, props);
 85  0
         defaultOutboundTransformer = removeProperty(MuleProperties.CONNECTOR_OUTBOUND_TRANSFORMER, props);
 86  0
         defaultResponseTransformer = removeProperty(MuleProperties.CONNECTOR_RESPONSE_TRANSFORMER, props);
 87  0
         endpointBuilder = removeProperty(MuleProperties.CONNECTOR_META_ENDPOINT_BUILDER, props);
 88  0
         endpointUriBuilder = removeProperty(MuleProperties.CONNECTOR_ENDPOINT_BUILDER, props);
 89  0
         sessionHandler = removeProperty(MuleProperties.CONNECTOR_SESSION_HANDLER, props);
 90  
 
 91  0
         initInboundExchangePatterns(props);
 92  0
         initOutboundExchangePatterns(props);
 93  0
         defaultExchangePattern = removeProperty(MuleProperties.CONNECTOR_DEFAULT_EXCHANGE_PATTERN, props);
 94  0
     }
 95  
 
 96  
     public void setOverrides(Properties props)
 97  
     {
 98  0
         if (props == null || props.size() == 0)
 99  
         {
 100  0
             return;
 101  
         }
 102  
 
 103  0
         connector = props.getProperty(MuleProperties.CONNECTOR_CLASS, connector);
 104  0
         dispatcherFactory = props.getProperty(MuleProperties.CONNECTOR_DISPATCHER_FACTORY, dispatcherFactory);
 105  0
         requesterFactory = props.getProperty(MuleProperties.CONNECTOR_REQUESTER_FACTORY, requesterFactory);
 106  0
         messageReceiver = props.getProperty(MuleProperties.CONNECTOR_MESSAGE_RECEIVER_CLASS, messageReceiver);
 107  0
         transactedMessageReceiver = props.getProperty(
 108  
                 MuleProperties.CONNECTOR_TRANSACTED_MESSAGE_RECEIVER_CLASS, transactedMessageReceiver);
 109  0
         xaTransactedMessageReceiver = props.getProperty(
 110  
                 MuleProperties.CONNECTOR_XA_TRANSACTED_MESSAGE_RECEIVER_CLASS, xaTransactedMessageReceiver);
 111  0
         messageFactory = props.getProperty(MuleProperties.CONNECTOR_MESSAGE_FACTORY, messageFactory);
 112  0
         endpointBuilder = props.getProperty(MuleProperties.CONNECTOR_META_ENDPOINT_BUILDER, endpointBuilder);
 113  
 
 114  0
         String temp = props.getProperty(MuleProperties.CONNECTOR_INBOUND_TRANSFORMER);
 115  0
         if (temp != null)
 116  
         {
 117  0
             defaultInboundTransformer = temp;
 118  
         }
 119  
 
 120  0
         temp = props.getProperty(MuleProperties.CONNECTOR_OUTBOUND_TRANSFORMER);
 121  0
         if (temp != null)
 122  
         {
 123  0
             defaultOutboundTransformer = temp;
 124  
         }
 125  
 
 126  0
         temp = props.getProperty(MuleProperties.CONNECTOR_RESPONSE_TRANSFORMER);
 127  0
         if (temp != null)
 128  
         {
 129  0
             defaultResponseTransformer = temp;
 130  
         }
 131  
 
 132  0
         temp = props.getProperty(MuleProperties.CONNECTOR_ENDPOINT_BUILDER);
 133  0
         if (temp != null)
 134  
         {
 135  0
             endpointUriBuilder = temp;
 136  
         }
 137  
 
 138  0
         initInboundExchangePatterns(props);
 139  0
         initOutboundExchangePatterns(props);
 140  0
         defaultExchangePattern = props.getProperty(MuleProperties.CONNECTOR_DEFAULT_EXCHANGE_PATTERN, null);
 141  0
     }
 142  
 
 143  
     public void setMuleContext(MuleContext context)
 144  
     {
 145  0
         this.muleContext = context;
 146  0
     }
 147  
 
 148  
     public MuleMessageFactory createMuleMessageFactory() throws TransportServiceException
 149  
     {
 150  0
         if (messageFactory == null)
 151  
         {
 152  0
             throw new TransportServiceException(CoreMessages.objectNotSetInService("Message Factory",
 153  
                 getService()));
 154  
         }
 155  
 
 156  
         try
 157  
         {
 158  0
             final Object[] args = new Object[] { muleContext };
 159  0
             return (MuleMessageFactory) ClassUtils.instanciateClass(messageFactory, args, classLoader);
 160  
         }
 161  0
         catch (Exception e)
 162  
         {
 163  0
             throw new TransportServiceException(CoreMessages.failedToCreate("Message Factory"), e);
 164  
         }
 165  
     }
 166  
 
 167  
     public SessionHandler createSessionHandler() throws TransportServiceException
 168  
     {
 169  0
         if (sessionHandler == null)
 170  
         {
 171  0
             sessionHandler = SerializeAndEncodeSessionHandler.class.getName();
 172  0
             if (logger.isDebugEnabled())
 173  
             {
 174  0
                 logger.debug("No session.handler set in service description, defaulting to: "
 175  
                         + sessionHandler);
 176  
             }
 177  
         }
 178  
         try
 179  
         {
 180  0
             return (SessionHandler) ClassUtils.instanciateClass(sessionHandler, ClassUtils.NO_ARGS, classLoader);
 181  
         }
 182  0
         catch (Throwable e)
 183  
         {
 184  0
             throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("SessionHandler", sessionHandler), e);
 185  
         }
 186  
     }
 187  
 
 188  
     public MessageReceiver createMessageReceiver(Connector connector,
 189  
                                                  FlowConstruct flowConstruct,
 190  
                                                  InboundEndpoint endpoint) throws MuleException
 191  
     {
 192  
 
 193  0
         MessageReceiver mr = createMessageReceiver(connector, flowConstruct, endpoint, null);
 194  0
         return mr;
 195  
     }
 196  
 
 197  
     public MessageReceiver createMessageReceiver(Connector connector,
 198  
                                                  FlowConstruct flowConstruct,
 199  
                                                  InboundEndpoint endpoint,
 200  
                                                  Object... args) throws MuleException
 201  
     {
 202  0
         String receiverClass = messageReceiver;
 203  
 
 204  0
         if (endpoint.getTransactionConfig().isTransacted())
 205  
         {
 206  0
             boolean xaTx = endpoint.getTransactionConfig().getFactory() instanceof XaTransactionFactory;
 207  0
             if (transactedMessageReceiver != null && !xaTx)
 208  
             {
 209  0
                 receiverClass = transactedMessageReceiver;
 210  
             }
 211  0
             else if (xaTransactedMessageReceiver != null && xaTx)
 212  
             {
 213  0
                 receiverClass = xaTransactedMessageReceiver;
 214  
             }
 215  
 
 216  
         }
 217  
 
 218  0
         if (receiverClass != null)
 219  
         {
 220  
             Object[] newArgs;
 221  
 
 222  0
             if (args != null && args.length != 0)
 223  
             {
 224  0
                 newArgs = new Object[3 + args.length];
 225  
             }
 226  
             else
 227  
             {
 228  0
                 newArgs = new Object[3];
 229  
             }
 230  
 
 231  0
             newArgs[0] = connector;
 232  0
             newArgs[1] = flowConstruct;
 233  0
             newArgs[2] = endpoint;
 234  
 
 235  0
             if (args != null && args.length != 0)
 236  
             {
 237  0
                 System.arraycopy(args, 0, newArgs, 3, newArgs.length - 3);
 238  
             }
 239  
 
 240  
             try
 241  
             {
 242  0
                 MessageReceiver mr = (MessageReceiver) ClassUtils.instanciateClass(receiverClass, newArgs, classLoader);
 243  0
                 return mr;
 244  
             }
 245  0
             catch (Exception e)
 246  
             {
 247  0
                 throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Message Receiver", getService()), e);
 248  
             }
 249  
 
 250  
         }
 251  
         else
 252  
         {
 253  0
             throw new TransportServiceException(CoreMessages.objectNotSetInService("Message Receiver", getService()));
 254  
         }
 255  
     }
 256  
 
 257  
     public MessageDispatcherFactory createDispatcherFactory() throws TransportServiceException
 258  
     {
 259  0
         if (dispatcherFactory != null)
 260  
         {
 261  
             try
 262  
             {
 263  0
                 return (MessageDispatcherFactory) ClassUtils.instanciateClass(dispatcherFactory,
 264  
                         ClassUtils.NO_ARGS, classLoader);
 265  
             }
 266  0
             catch (Exception e)
 267  
             {
 268  0
                 throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Message Dispatcher Factory", dispatcherFactory), e);
 269  
             }
 270  
         }
 271  
         else
 272  
         {
 273  
             //Its valid not to have a Dispatcher factory on the transport
 274  0
             return null;
 275  
         }
 276  
     }
 277  
 
 278  
     public MessageRequesterFactory createRequesterFactory() throws TransportServiceException
 279  
     {
 280  0
         if (requesterFactory != null)
 281  
         {
 282  
             try
 283  
             {
 284  0
                 return (MessageRequesterFactory) ClassUtils.instanciateClass(requesterFactory,
 285  
                         ClassUtils.NO_ARGS, classLoader);
 286  
             }
 287  0
             catch (Exception e)
 288  
             {
 289  0
                 throw new TransportServiceException(
 290  
                         CoreMessages.failedToCreateObjectWith("Message Requester Factory", requesterFactory), e);
 291  
             }
 292  
         }
 293  
         else
 294  
         {
 295  
             //Its valid not to have a Requester factory on the transport
 296  0
             return null;
 297  
         }
 298  
     }
 299  
 
 300  
     public TransactionFactory createTransactionFactory() throws TransportServiceException
 301  
     {
 302  0
         if (transactionFactory != null)
 303  
         {
 304  
             try
 305  
             {
 306  0
                 return (TransactionFactory) ClassUtils.instanciateClass(transactionFactory,
 307  
                         ClassUtils.NO_ARGS, classLoader);
 308  
             }
 309  0
             catch (Exception e)
 310  
             {
 311  0
                 throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Transaction Factory", transactionFactory), e);
 312  
             }
 313  
         }
 314  
         else
 315  
         {
 316  0
             return null;
 317  
         }
 318  
     }
 319  
 
 320  
     @SuppressWarnings("unchecked")
 321  
     public Connector createConnector() throws TransportServiceException
 322  
     {
 323  
         Connector newConnector;
 324  
         // if there is a factory, use it
 325  
         try
 326  
         {
 327  0
             if (connector != null)
 328  
             {
 329  
                 Class<Connector> connectorClass;
 330  0
                 if (classLoader != null)
 331  
                 {
 332  0
                     connectorClass = ClassUtils.loadClass(connector, classLoader);
 333  
                 }
 334  
                 else
 335  
                 {
 336  0
                     connectorClass = ClassUtils.loadClass(connector, getClass());
 337  
                 }
 338  0
                 newConnector = connectorClass.getConstructor(MuleContext.class).newInstance(muleContext);
 339  0
             }
 340  
             else
 341  
             {
 342  0
                 throw new TransportServiceException(CoreMessages.objectNotSetInService("Connector", getService()));
 343  
             }
 344  
         }
 345  0
         catch (TransportServiceException e)
 346  
         {
 347  0
             throw e;
 348  
         }
 349  0
         catch (Exception e)
 350  
         {
 351  0
             throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Connector", connector), e);
 352  0
         }
 353  
 
 354  0
         if (newConnector.getName() == null)
 355  
         {
 356  0
             newConnector.setName("_" + newConnector.getProtocol() + "Connector#" + connector.hashCode());
 357  
         }
 358  0
         return newConnector;
 359  
     }
 360  
 
 361  
     @SuppressWarnings("unchecked")
 362  
     public List<Transformer> createInboundTransformers(ImmutableEndpoint endpoint) throws TransportFactoryException
 363  
     {
 364  0
         if (defaultInboundTransformer != null)
 365  
         {
 366  0
             logger.info("Loading default inbound transformer: " + defaultInboundTransformer);
 367  
             try
 368  
             {
 369  0
                 Transformer newTransformer = createTransformer(defaultInboundTransformer, endpoint);
 370  0
                 return CollectionUtils.singletonList(newTransformer);
 371  
             }
 372  0
             catch (Exception e)
 373  
             {
 374  0
                 throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("inbound",
 375  
                     defaultInboundTransformer), e);
 376  
             }
 377  
         }
 378  0
         return Collections.emptyList();
 379  
     }
 380  
 
 381  
     @SuppressWarnings("unchecked")
 382  
     public List<Transformer> createOutboundTransformers(ImmutableEndpoint endpoint) throws TransportFactoryException
 383  
     {
 384  0
         if (defaultOutboundTransformer != null)
 385  
         {
 386  0
             logger.info("Loading default outbound transformer: " + defaultOutboundTransformer);
 387  
             try
 388  
             {
 389  0
                 Transformer newTransformer = createTransformer(defaultOutboundTransformer, endpoint);
 390  0
                 return CollectionUtils.singletonList(newTransformer);
 391  
             }
 392  0
             catch (Exception e)
 393  
             {
 394  0
                 throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("outbound",
 395  
                     defaultOutboundTransformer), e);
 396  
             }
 397  
         }
 398  0
         return Collections.emptyList();
 399  
     }
 400  
 
 401  
     @SuppressWarnings("unchecked")
 402  
     public List<Transformer> createResponseTransformers(ImmutableEndpoint endpoint) throws TransportFactoryException
 403  
     {
 404  0
         if (defaultResponseTransformer != null)
 405  
         {
 406  0
             logger.info("Loading default response transformer: " + defaultResponseTransformer);
 407  
             try
 408  
             {
 409  0
                 Transformer newTransformer = createTransformer(defaultResponseTransformer, endpoint);
 410  0
                 return CollectionUtils.singletonList(newTransformer);
 411  
             }
 412  0
             catch (Exception e)
 413  
             {
 414  0
                 throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("response",
 415  
                     defaultResponseTransformer), e);
 416  
             }
 417  
         }
 418  0
         return Collections.emptyList();
 419  
     }
 420  
 
 421  
     protected Transformer createTransformer(String className, ImmutableEndpoint endpoint) throws Exception
 422  
     {
 423  0
         Transformer newTransformer = (Transformer) ClassUtils.instanciateClass(className,
 424  
             ClassUtils.NO_ARGS, classLoader);
 425  0
         newTransformer.setMuleContext(muleContext);
 426  0
         newTransformer.setName(newTransformer.getName() + "#" + newTransformer.hashCode());
 427  0
         newTransformer.setEndpoint(endpoint);
 428  0
         return newTransformer;
 429  
     }
 430  
 
 431  
     public EndpointURIBuilder createEndpointURIBuilder() throws TransportFactoryException
 432  
     {
 433  0
         if (endpointUriBuilder == null)
 434  
         {
 435  0
             logger.debug("Endpoint resolver not set, Loading default resolver: "
 436  
                     + UrlEndpointURIBuilder.class.getName());
 437  0
             return new UrlEndpointURIBuilder();
 438  
         }
 439  
         else
 440  
         {
 441  0
             logger.debug("Loading endpointUri resolver: " + endpointUriBuilder);
 442  
             try
 443  
             {
 444  0
                 return (EndpointURIBuilder) ClassUtils.instanciateClass(endpointUriBuilder, ClassUtils.NO_ARGS, classLoader);
 445  
             }
 446  0
             catch (Exception e)
 447  
             {
 448  0
                 throw new TransportFactoryException(CoreMessages.failedToLoad("EndpointURI Builder: " + endpointUriBuilder), e);
 449  
             }
 450  
         }
 451  
     }
 452  
 
 453  
     public EndpointBuilder createEndpointBuilder(String uri) throws TransportFactoryException
 454  
     {
 455  0
         if (endpointBuilder == null)
 456  
         {
 457  0
             logger.debug("Endpoint builder not set, Loading default builder: "
 458  
                     + EndpointURIEndpointBuilder.class.getName());
 459  0
             return new EndpointURIEndpointBuilder(uri, muleContext);
 460  
         }
 461  
         else
 462  
         {
 463  0
             return createEndpointBuilder(new Object[] { uri, muleContext });
 464  
         }
 465  
     }
 466  
 
 467  
     public EndpointBuilder createEndpointBuilder(EndpointURIEndpointBuilder builder) throws TransportFactoryException
 468  
     {
 469  
         EndpointBuilder wrappingBuilder;
 470  0
         if (endpointBuilder == null)
 471  
         {
 472  0
             logger.debug("Endpoint builder not set, Loading default builder: "
 473  
                     + EndpointURIEndpointBuilder.class.getName());
 474  
             try
 475  
             {
 476  0
                 wrappingBuilder = new EndpointURIEndpointBuilder(builder);
 477  
             }
 478  0
             catch (EndpointException e)
 479  
             {
 480  0
                 throw new TransportFactoryException(CoreMessages.failedToLoad("Endpoint Builder: " + endpointBuilder), e);
 481  0
             }
 482  
         }
 483  
         else
 484  
         {
 485  0
             wrappingBuilder = createEndpointBuilder(new Object[] { builder });
 486  
         }
 487  
 
 488  0
         wrappingBuilder.setMuleContext(muleContext);
 489  0
         return wrappingBuilder;
 490  
     }
 491  
 
 492  
     protected EndpointBuilder createEndpointBuilder(Object[] constructorParams) throws TransportFactoryException
 493  
     {
 494  0
         logger.debug("Loading endpoint builder: " + endpointBuilder);
 495  
         try
 496  
         {
 497  0
             return (EndpointBuilder) ClassUtils.instanciateClass(endpointBuilder, constructorParams, classLoader);
 498  
         }
 499  0
         catch (Exception e)
 500  
         {
 501  0
             throw new TransportFactoryException(CoreMessages.failedToLoad("Endpoint Builder: " + endpointBuilder), e);
 502  
         }
 503  
     }
 504  
 
 505  
     public void setExceptionMappings(Properties props)
 506  
     {
 507  0
         this.exceptionMappings = props;
 508  0
     }
 509  
 
 510  
     public Properties getExceptionMappings()
 511  
     {
 512  0
         return this.exceptionMappings;
 513  
     }
 514  
 
 515  
     protected void initInboundExchangePatterns(Properties properties)
 516  
     {
 517  
         // it's valid to configure no inbound exchange patterns but it's invalid to have
 518  
         // no key for inbound exchange patterns
 519  0
         if (!properties.keySet().contains(MuleProperties.CONNECTOR_INBOUND_EXCHANGE_PATTERNS))
 520  
         {
 521  0
             inboundExchangePatterns = null;
 522  
         }
 523  
         else
 524  
         {
 525  0
             String mepsString =
 526  
                 removeProperty(MuleProperties.CONNECTOR_INBOUND_EXCHANGE_PATTERNS, properties);
 527  0
             inboundExchangePatterns = parseExchangePatterns(mepsString);
 528  
         }
 529  0
     }
 530  
 
 531  
     protected void initOutboundExchangePatterns(Properties properties)
 532  
     {
 533  
         // it's valid to configure no outbound exchange patterns but it's invalid to have
 534  
         // no key for outbound exchange patterns
 535  0
         if (!properties.keySet().contains(MuleProperties.CONNECTOR_OUTBOUND_EXCHANGE_PATTERNS))
 536  
         {
 537  0
             outboundExchangePatterns = null;
 538  
         }
 539  
         else
 540  
         {
 541  0
             String mepsString =
 542  
                 removeProperty(MuleProperties.CONNECTOR_OUTBOUND_EXCHANGE_PATTERNS, properties);
 543  0
             outboundExchangePatterns = parseExchangePatterns(mepsString);
 544  
         }
 545  0
     }
 546  
 
 547  
     protected List<MessageExchangePattern> parseExchangePatterns(String mepsString)
 548  
     {
 549  0
         if (StringUtils.isEmpty(mepsString))
 550  
         {
 551  0
             return Collections.emptyList();
 552  
         }
 553  
 
 554  0
         List<MessageExchangePattern> mepList = new ArrayList<MessageExchangePattern>();
 555  
 
 556  0
         String[] meps = StringUtils.splitAndTrim(mepsString, ",");
 557  0
         for (String exchangePattern : meps)
 558  
         {
 559  0
             mepList.add(MessageExchangePattern.fromString(exchangePattern));
 560  
         }
 561  
 
 562  0
         return mepList;
 563  
     }
 564  
 
 565  
     public List<MessageExchangePattern> getInboundExchangePatterns() throws TransportServiceException
 566  
     {
 567  0
         if (inboundExchangePatterns == null)
 568  
         {
 569  0
             throw new TransportServiceException(CoreMessages.objectNotSetInService(
 570  
                 MuleProperties.CONNECTOR_INBOUND_EXCHANGE_PATTERNS, getService()));
 571  
         }
 572  0
         return inboundExchangePatterns;
 573  
     }
 574  
 
 575  
     public List<MessageExchangePattern> getOutboundExchangePatterns() throws TransportServiceException
 576  
     {
 577  0
         if (outboundExchangePatterns == null)
 578  
         {
 579  0
             throw new TransportServiceException(CoreMessages.objectNotSetInService(
 580  
                 MuleProperties.CONNECTOR_OUTBOUND_EXCHANGE_PATTERNS, getService()));
 581  
         }
 582  0
         return outboundExchangePatterns;
 583  
     }
 584  
 
 585  
     public MessageExchangePattern getDefaultExchangePattern() throws TransportServiceException
 586  
     {
 587  0
         if (defaultExchangePattern == null)
 588  
         {
 589  0
             throw new TransportServiceException(CoreMessages.objectNotSetInService(
 590  
                 MuleProperties.CONNECTOR_DEFAULT_EXCHANGE_PATTERN, getService()));
 591  
         }
 592  
 
 593  0
         return MessageExchangePattern.fromString(defaultExchangePattern);
 594  
     }
 595  
 }