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