View Javadoc

1   /*
2    * $Id: DefaultTransportServiceDescriptor.java 11405 2008-03-18 00:13:00Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.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.MuleSessionHandler;
14  import org.mule.api.MuleException;
15  import org.mule.api.config.MuleProperties;
16  import org.mule.api.endpoint.EndpointURIBuilder;
17  import org.mule.api.endpoint.InboundEndpoint;
18  import org.mule.api.registry.AbstractServiceDescriptor;
19  import org.mule.api.registry.Registry;
20  import org.mule.api.service.Service;
21  import org.mule.api.transaction.TransactionConfig;
22  import org.mule.api.transaction.TransactionFactory;
23  import org.mule.api.transformer.Transformer;
24  import org.mule.api.transport.Connector;
25  import org.mule.api.transport.MessageAdapter;
26  import org.mule.api.transport.MessageDispatcherFactory;
27  import org.mule.api.transport.MessageReceiver;
28  import org.mule.api.transport.MessageRequesterFactory;
29  import org.mule.api.transport.SessionHandler;
30  import org.mule.config.i18n.CoreMessages;
31  import org.mule.endpoint.UrlEndpointURIBuilder;
32  import org.mule.transaction.XaTransactionFactory;
33  import org.mule.transport.NullPayload;
34  import org.mule.util.ClassUtils;
35  import org.mule.util.CollectionUtils;
36  
37  import java.util.List;
38  import java.util.Properties;
39  
40  /** @inheritDocs */
41  public class DefaultTransportServiceDescriptor extends AbstractServiceDescriptor implements TransportServiceDescriptor
42  {
43      private String connector;
44      private String dispatcherFactory;
45      private String requesterFactory;
46      private String transactionFactory;
47      private String messageAdapter;
48      private String messageReceiver;
49      private String transactedMessageReceiver;
50      private String xaTransactedMessageReceiver;
51      private String endpointBuilder;
52      private String sessionHandler;
53      private String defaultInboundTransformer;
54      private String defaultOutboundTransformer;
55      private String defaultResponseTransformer;
56  
57      private Transformer inboundTransformer;
58      private Transformer outboundTransformer;
59      private Transformer responseTransformer;
60      // private EndpointBuilder endpointBuilderImpl;
61  
62      private Properties exceptionMappings = new Properties();
63  
64      public DefaultTransportServiceDescriptor(String service, Properties props, Registry registry)
65      {
66          super(service);
67  
68          connector = removeProperty(MuleProperties.CONNECTOR_CLASS, props);
69          dispatcherFactory = removeProperty(MuleProperties.CONNECTOR_DISPATCHER_FACTORY, props);
70          requesterFactory = removeProperty(MuleProperties.CONNECTOR_REQUESTER_FACTORY, props);
71          transactionFactory = removeProperty(MuleProperties.CONNECTOR_DISPATCHER_FACTORY, props);
72          messageReceiver = removeProperty(MuleProperties.CONNECTOR_MESSAGE_RECEIVER_CLASS, props);
73          transactedMessageReceiver = removeProperty(MuleProperties.CONNECTOR_TRANSACTED_MESSAGE_RECEIVER_CLASS, props);
74          xaTransactedMessageReceiver = removeProperty(MuleProperties.CONNECTOR_XA_TRANSACTED_MESSAGE_RECEIVER_CLASS, props);
75          messageAdapter = removeProperty(MuleProperties.CONNECTOR_MESSAGE_ADAPTER, props);
76          defaultInboundTransformer = removeProperty(MuleProperties.CONNECTOR_INBOUND_TRANSFORMER, props);
77          defaultOutboundTransformer = removeProperty(MuleProperties.CONNECTOR_OUTBOUND_TRANSFORMER, props);
78          defaultResponseTransformer = removeProperty(MuleProperties.CONNECTOR_RESPONSE_TRANSFORMER, props);
79          endpointBuilder = removeProperty(MuleProperties.CONNECTOR_ENDPOINT_BUILDER, props);
80          sessionHandler = removeProperty(MuleProperties.CONNECTOR_SESSION_HANDLER, props);
81  
82  //        try
83  //        {
84  //                registerDefaultTransformers(registry);
85  //        }
86  //        catch (Exception e)
87  //        {
88  //            e.printStackTrace();
89  //        }
90      }
91  
92  
93      public void setOverrides(Properties props)
94      {
95          if (props == null || props.size() == 0)
96          {
97              return;
98          }
99  
100         connector = props.getProperty(MuleProperties.CONNECTOR_CLASS, connector);
101         dispatcherFactory = props.getProperty(MuleProperties.CONNECTOR_DISPATCHER_FACTORY, dispatcherFactory);
102         requesterFactory = props.getProperty(MuleProperties.CONNECTOR_REQUESTER_FACTORY, requesterFactory);
103         messageReceiver = props.getProperty(MuleProperties.CONNECTOR_MESSAGE_RECEIVER_CLASS, messageReceiver);
104         transactedMessageReceiver = props.getProperty(
105                 MuleProperties.CONNECTOR_TRANSACTED_MESSAGE_RECEIVER_CLASS, transactedMessageReceiver);
106         xaTransactedMessageReceiver = props.getProperty(
107                 MuleProperties.CONNECTOR_XA_TRANSACTED_MESSAGE_RECEIVER_CLASS, xaTransactedMessageReceiver);
108         messageAdapter = props.getProperty(MuleProperties.CONNECTOR_MESSAGE_ADAPTER, messageAdapter);
109 
110         String temp = props.getProperty(MuleProperties.CONNECTOR_INBOUND_TRANSFORMER);
111         if (temp != null)
112         {
113             defaultInboundTransformer = temp;
114             inboundTransformer = null;
115         }
116 
117         temp = props.getProperty(MuleProperties.CONNECTOR_OUTBOUND_TRANSFORMER);
118         if (temp != null)
119         {
120             defaultOutboundTransformer = temp;
121             outboundTransformer = null;
122         }
123 
124         temp = props.getProperty(MuleProperties.CONNECTOR_RESPONSE_TRANSFORMER);
125         if (temp != null)
126         {
127             defaultResponseTransformer = temp;
128             responseTransformer = null;
129         }
130 
131         temp = props.getProperty(MuleProperties.CONNECTOR_ENDPOINT_BUILDER);
132         if (temp != null)
133         {
134             endpointBuilder = temp;
135         }
136     }
137 
138     /* (non-Javadoc)
139      * @see org.mule.transport.service.TransportServiceDescriptor#createMessageAdapter(java.lang.Object)
140      */
141     public MessageAdapter createMessageAdapter(Object message) throws TransportServiceException
142     {
143         return createMessageAdapter(message, messageAdapter);
144     }
145 
146     protected MessageAdapter createMessageAdapter(Object message, String clazz)
147             throws TransportServiceException
148     {
149         if (message == null)
150         {
151             message = NullPayload.getInstance();
152         }
153         if (messageAdapter != null)
154         {
155             try
156             {
157                 return (MessageAdapter) ClassUtils.instanciateClass(clazz, new Object[]{message});
158             }
159             catch (Exception e)
160             {
161                 throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Message Adapter", clazz), e);
162             }
163         }
164         else
165         {
166             throw new TransportServiceException(CoreMessages.objectNotSetInService("Message Adapter", getService()));
167         }
168     }
169 
170     /* (non-Javadoc)
171      * @see org.mule.transport.service.TransportServiceDescriptor#createSessionHandler()
172      */
173     public SessionHandler createSessionHandler() throws TransportServiceException
174     {
175         if (sessionHandler == null)
176         {
177             sessionHandler = MuleSessionHandler.class.getName();
178             if (logger.isDebugEnabled())
179             {
180                 logger.debug("No session.handler set in service description, defaulting to: "
181                         + sessionHandler);
182             }
183         }
184         try
185         {
186             return (SessionHandler) ClassUtils.instanciateClass(sessionHandler, ClassUtils.NO_ARGS,
187                     getClass());
188         }
189         catch (Throwable e)
190         {
191             throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("SessionHandler", sessionHandler), e);
192         }
193     }
194 
195     /* (non-Javadoc)
196      * @see org.mule.transport.service.TransportServiceDescriptor#createMessageReceiver(org.mule.api.transport.Connector, org.mule.api.Component, org.mule.api.endpoint.Endpoint)
197      */
198     public MessageReceiver createMessageReceiver(Connector connector,
199                                                     Service service,
200                                                     InboundEndpoint endpoint) throws MuleException
201     {
202 
203         return createMessageReceiver(connector, service, endpoint, null);
204     }
205 
206     /* (non-Javadoc)
207      * @see org.mule.transport.service.TransportServiceDescriptor#createMessageReceiver(org.mule.api.transport.Connector, org.mule.api.Component, org.mule.api.endpoint.Endpoint, java.lang.Object[])
208      */
209     public MessageReceiver createMessageReceiver(Connector connector,
210                                                     Service service,
211                                                     InboundEndpoint endpoint,
212                                                     Object[] args) throws MuleException
213     {
214         String receiverClass = messageReceiver;
215 
216         if (endpoint.getTransactionConfig() != null
217                 && endpoint.getTransactionConfig().getAction() != TransactionConfig.ACTION_NONE)
218         {
219             boolean xaTx = endpoint.getTransactionConfig().getFactory() instanceof XaTransactionFactory;
220             if (transactedMessageReceiver != null && !xaTx)
221             {
222                 receiverClass = transactedMessageReceiver;
223             }
224             else if (xaTransactedMessageReceiver != null && xaTx)
225             {
226                 receiverClass = xaTransactedMessageReceiver;
227             }
228 
229         }
230 
231         if (receiverClass != null)
232         {
233             Object[] newArgs;
234 
235             if (args != null && args.length != 0)
236             {
237                 newArgs = new Object[3 + args.length];
238             }
239             else
240             {
241                 newArgs = new Object[3];
242             }
243 
244             newArgs[0] = connector;
245             newArgs[1] = service;
246             newArgs[2] = endpoint;
247 
248             if (args != null && args.length != 0)
249             {
250                 System.arraycopy(args, 0, newArgs, 3, newArgs.length - 3);
251             }
252 
253             try
254             {
255                 return (MessageReceiver) ClassUtils.instanciateClass(receiverClass, newArgs);
256             }
257             catch (Exception e)
258             {
259                 throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Message Receiver", getService()), e);
260             }
261 
262         }
263         else
264         {
265             throw new TransportServiceException(CoreMessages.objectNotSetInService("Message Receiver", getService()));
266         }
267     }
268 
269     /* (non-Javadoc)
270      * @see org.mule.transport.service.TransportServiceDescriptor#createDispatcherFactory()
271      */
272     public MessageDispatcherFactory createDispatcherFactory() throws TransportServiceException
273     {
274         if (dispatcherFactory != null)
275         {
276             try
277             {
278                 return (MessageDispatcherFactory) ClassUtils.instanciateClass(dispatcherFactory,
279                         ClassUtils.NO_ARGS);
280             }
281             catch (Exception e)
282             {
283                 throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Message Dispatcher Factory", dispatcherFactory), e);
284             }
285         }
286         else
287         {
288             //Its valid not to have a Dispatcher factory on the transport
289             return null;
290         }
291     }
292 
293     /* (non-Javadoc)
294      * @see org.mule.transport.service.TransportServiceDescriptor#createRequesterFactory()
295      */
296     public MessageRequesterFactory createRequesterFactory() throws TransportServiceException
297     {
298         if (requesterFactory != null)
299         {
300             try
301             {
302                 return (MessageRequesterFactory) ClassUtils.instanciateClass(requesterFactory,
303                         ClassUtils.NO_ARGS);
304             }
305             catch (Exception e)
306             {
307                 throw new TransportServiceException(
308                         CoreMessages.failedToCreateObjectWith("Message Requester Factory", requesterFactory), e);
309             }
310         }
311         else
312         {
313             //Its valid not to have a Dispatcher factory on the transport
314             return null;
315         }
316     }
317 
318     /* (non-Javadoc)
319      * @see org.mule.transport.service.TransportServiceDescriptor#createTransactionFactory()
320      */
321     public TransactionFactory createTransactionFactory() throws TransportServiceException
322     {
323         if (transactionFactory != null)
324         {
325             try
326             {
327                 return (TransactionFactory) ClassUtils.instanciateClass(transactionFactory,
328                         ClassUtils.NO_ARGS);
329             }
330             catch (Exception e)
331             {
332                 throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Transaction Factory", transactionFactory), e);
333             }
334         }
335         else
336         {
337             return null;
338         }
339     }
340 
341     /* (non-Javadoc)
342      * @see org.mule.transport.service.TransportServiceDescriptor#createConnector(java.lang.String)
343      */
344     public Connector createConnector() throws TransportServiceException
345     {
346         Connector newConnector;
347         // if there is a factory, use it
348         try
349         {
350             if (connector != null)
351             {
352                 newConnector = (Connector) ClassUtils.loadClass(connector, TransportFactory.class)
353                         .newInstance();
354             }
355             else
356             {
357                 throw new TransportServiceException(CoreMessages.objectNotSetInService("Connector", getService()));
358             }
359         }
360         catch (TransportServiceException e)
361         {
362             throw e;
363         }
364         catch (Exception e)
365         {
366             throw new TransportServiceException(CoreMessages.failedToCreateObjectWith("Connector", connector), e);
367         }
368 
369         if (newConnector.getName() == null)
370         {
371             newConnector.setName("_" + newConnector.getProtocol() + "Connector#" + connector.hashCode());
372         }
373         return newConnector;
374     }
375 
376     /* (non-Javadoc)
377      * @see org.mule.transport.service.TransportServiceDescriptor#createInboundTransformer()
378      */
379     public List createInboundTransformers() throws TransportFactoryException
380     {
381         if (inboundTransformer != null)
382         {
383             return CollectionUtils.singletonList(inboundTransformer);
384         }
385         if (defaultInboundTransformer != null)
386         {
387             logger.info("Loading default inbound transformer: " + defaultInboundTransformer);
388             try
389             {
390                 inboundTransformer = (Transformer) ClassUtils.instanciateClass(
391                         defaultInboundTransformer, ClassUtils.NO_ARGS);
392                 return CollectionUtils.singletonList(inboundTransformer);
393             }
394             catch (Exception e)
395             {
396                 throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("inbound", defaultInboundTransformer), e);
397             }
398         }
399         return null;
400     }
401 
402     /* (non-Javadoc)
403      * @see org.mule.transport.service.TransportServiceDescriptor#createOutboundTransformer()
404      */
405     public List createOutboundTransformers() throws TransportFactoryException
406     {
407         if (outboundTransformer != null)
408         {
409             return CollectionUtils.singletonList(outboundTransformer);
410         }
411         if (defaultOutboundTransformer != null)
412         {
413             logger.info("Loading default outbound transformer: " + defaultOutboundTransformer);
414             try
415             {
416                 outboundTransformer = (Transformer) ClassUtils.instanciateClass(
417                         defaultOutboundTransformer, ClassUtils.NO_ARGS);
418                 return CollectionUtils.singletonList(outboundTransformer);
419             }
420             catch (Exception e)
421             {
422                 throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("outbound", defaultOutboundTransformer), e);
423             }
424         }
425         return null;
426     }
427 
428     /* (non-Javadoc)
429      * @see org.mule.transport.service.TransportServiceDescriptor#createResponseTransformer()
430      */
431     public List createResponseTransformers() throws TransportFactoryException
432     {
433         if (responseTransformer != null)
434         {
435             return CollectionUtils.singletonList(responseTransformer);
436         }
437         if (defaultResponseTransformer != null)
438         {
439             logger.info("Loading default response transformer: " + defaultResponseTransformer);
440             try
441             {
442                 responseTransformer = (Transformer) ClassUtils.instanciateClass(
443                         defaultResponseTransformer, ClassUtils.NO_ARGS);
444                 return CollectionUtils.singletonList(responseTransformer);
445             }
446             catch (Exception e)
447             {
448                 throw new TransportFactoryException(CoreMessages.failedToLoadTransformer("response", defaultResponseTransformer), e);
449             }
450         }
451         return null;
452     }
453 
454     /* (non-Javadoc)
455      * @see org.mule.transport.service.TransportServiceDescriptor#createEndpointBuilder()
456      */
457     public EndpointURIBuilder createEndpointBuilder() throws TransportFactoryException
458     {
459         if (endpointBuilder == null)
460         {
461             logger.debug("Endpoint resolver not set, Loading default resolver: "
462                     + UrlEndpointURIBuilder.class.getName());
463             return new UrlEndpointURIBuilder();
464         }
465         else
466         {
467             logger.debug("Loading endpointUri resolver: " + endpointBuilder);
468             try
469             {
470                 return (EndpointURIBuilder) ClassUtils.instanciateClass(endpointBuilder, ClassUtils.NO_ARGS);
471             }
472             catch (Exception e)
473             {
474                 throw new TransportFactoryException(CoreMessages.failedToLoad("Endpoint Builder: " + endpointBuilder), e);
475             }
476         }
477     }
478 
479     public void setExceptionMappings(Properties props)
480     {
481         this.exceptionMappings = props;
482     }
483 
484     public Properties getExceptionMappings()
485     {
486         return this.exceptionMappings;
487     }
488 }