View Javadoc

1   /*
2    * $Id: VMConnector.java 9436 2007-10-29 14:39:54Z aperepel $
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.providers.vm;
12  
13  import org.mule.MuleManager;
14  import org.mule.config.QueueProfile;
15  import org.mule.config.i18n.CoreMessages;
16  import org.mule.impl.MuleMessage;
17  import org.mule.impl.endpoint.MuleEndpointURI;
18  import org.mule.providers.AbstractConnector;
19  import org.mule.routing.filters.WildcardFilter;
20  import org.mule.transaction.TransactionCoordination;
21  import org.mule.umo.MessagingException;
22  import org.mule.umo.TransactionException;
23  import org.mule.umo.UMOComponent;
24  import org.mule.umo.UMOException;
25  import org.mule.umo.UMOTransaction;
26  import org.mule.umo.endpoint.EndpointException;
27  import org.mule.umo.endpoint.UMOEndpoint;
28  import org.mule.umo.endpoint.UMOEndpointURI;
29  import org.mule.umo.lifecycle.InitialisationException;
30  import org.mule.umo.provider.MessageTypeNotSupportedException;
31  import org.mule.umo.provider.UMOMessageAdapter;
32  import org.mule.umo.provider.UMOMessageReceiver;
33  import org.mule.util.ClassUtils;
34  import org.mule.util.queue.QueueManager;
35  import org.mule.util.queue.QueueSession;
36  
37  import java.util.Iterator;
38  
39  /**
40   * <code>VMConnector</code> is a simple endpoint wrapper to allow a Mule component
41   * to be accessed from an endpoint
42   */
43  public class VMConnector extends AbstractConnector
44  {
45      private boolean queueEvents = false;
46      private QueueProfile queueProfile;
47      private Class adapterClass = null;
48      private int queueTimeout = 1000;
49  
50      protected void doInitialise() throws InitialisationException
51      {
52          if (queueEvents)
53          {
54              if (queueProfile == null)
55              {
56                  queueProfile = MuleManager.getConfiguration().getQueueProfile();
57              }
58          }
59  
60          try
61          {
62              adapterClass = ClassUtils.loadClass(serviceDescriptor.getMessageAdapter(), getClass());
63          }
64          catch (ClassNotFoundException e)
65          {
66              throw new InitialisationException(
67                  CoreMessages.failedToLoad("Message Adapter: " + serviceDescriptor.getMessageAdapter()), e);
68          }
69      }
70  
71      protected void doDispose()
72      {
73          // template method
74      }
75  
76      protected void doConnect() throws Exception
77      {
78          // template method
79      }
80  
81      protected void doDisconnect() throws Exception
82      {
83          // template method
84      }
85  
86      protected void doStart() throws UMOException
87      {
88          // template method
89      }
90  
91      protected void doStop() throws UMOException
92      {
93          // template method
94      }
95  
96      public UMOMessageReceiver createReceiver(UMOComponent component, UMOEndpoint endpoint) throws Exception
97      {
98          if (queueEvents)
99          {
100             queueProfile.configureQueue(endpoint.getEndpointURI().getAddress());
101         }
102         return serviceDescriptor.createMessageReceiver(this, component, endpoint);
103     }
104 
105     public UMOMessageAdapter getMessageAdapter(Object message) throws MessagingException
106     {
107         if (message == null)
108         {
109             throw new MessageTypeNotSupportedException(null, adapterClass);
110         }
111         else if (message instanceof MuleMessage)
112         {
113             return ((MuleMessage)message).getAdapter();
114         }
115         else if (message instanceof UMOMessageAdapter)
116         {
117             return (UMOMessageAdapter)message;
118         }
119         else
120         {
121             throw new MessageTypeNotSupportedException(message, adapterClass);
122         }
123     }
124 
125     public String getProtocol()
126     {
127         return "VM";
128     }
129 
130     public boolean isQueueEvents()
131     {
132         return queueEvents;
133     }
134 
135     public void setQueueEvents(boolean queueEvents)
136     {
137         this.queueEvents = queueEvents;
138     }
139 
140     public QueueProfile getQueueProfile()
141     {
142         return queueProfile;
143     }
144 
145     public void setQueueProfile(QueueProfile queueProfile)
146     {
147         this.queueProfile = queueProfile;
148     }
149 
150     VMMessageReceiver getReceiver(UMOEndpointURI endpointUri) throws EndpointException
151     {
152         return (VMMessageReceiver)getReceiverByEndpoint(endpointUri);
153     }
154 
155     QueueSession getQueueSession() throws InitialisationException
156     {
157         QueueManager qm = MuleManager.getInstance().getQueueManager();
158         UMOTransaction tx = TransactionCoordination.getInstance().getTransaction();
159         if (tx != null)
160         {
161             if (tx.hasResource(qm))
162             {
163                 final QueueSession queueSession = (QueueSession) tx.getResource(qm);
164                 if (logger.isDebugEnabled())
165                 {
166                     logger.debug("Retrieved VM queue session " + queueSession + " from current transaction " + tx);
167                 }
168                 return queueSession;
169             }
170         }
171 
172         if (logger.isDebugEnabled())
173         {
174             logger.debug("Retrieving new VM queue session from queue manager");
175         }
176 
177         QueueSession session = qm.getQueueSession();
178         if (tx != null)
179         {
180             if (logger.isDebugEnabled())
181             {
182                 logger.debug("Binding VM queue session " + session + " to current transaction " + tx);
183             }
184             try
185             {
186                 tx.bindResource(qm, session);
187             }
188             catch (TransactionException e)
189             {
190                 throw new RuntimeException("Could not bind queue session to current transaction", e);
191             }
192         }
193         return session;
194     }
195 
196     protected UMOMessageReceiver getReceiverByEndpoint(UMOEndpointURI endpointUri) throws EndpointException
197     {
198         if (logger.isDebugEnabled())
199         {
200             logger.debug("Looking up vm receiver for address: " + endpointUri.toString());
201         }
202 
203         UMOMessageReceiver receiver;
204         // If we have an exact match, use it
205         receiver = (UMOMessageReceiver)receivers.get(endpointUri.getAddress());
206         if (receiver != null)
207         {
208             if (logger.isDebugEnabled())
209             {
210                 logger.debug("Found exact receiver match on endpointUri: " + endpointUri);
211             }
212             return receiver;
213         }
214 
215         // otherwise check each one against a wildcard match
216         for (Iterator iterator = receivers.values().iterator(); iterator.hasNext();)
217         {
218             receiver = (UMOMessageReceiver)iterator.next();
219             String filterAddress = receiver.getEndpointURI().getAddress();
220             WildcardFilter filter = new WildcardFilter(filterAddress);
221             if (filter.accept(endpointUri.getAddress()))
222             {
223                 receiver.getEndpoint().setEndpointURI(new MuleEndpointURI(endpointUri, filterAddress));
224 
225                 if (logger.isDebugEnabled())
226                 {
227                     logger.debug("Found receiver match on endpointUri: " + receiver.getEndpointURI()
228                                  + " against " + endpointUri);
229                 }
230                 return receiver;
231             }
232         }
233         if (logger.isDebugEnabled())
234         {
235             logger.debug("No receiver found for endpointUri: " + endpointUri);
236         }
237         return null;
238     }
239 
240     // @Override
241     public boolean isRemoteSyncEnabled()
242     {
243         return true;
244     }
245 
246     public int getQueueTimeout()
247     {
248         return queueTimeout;
249     }
250 
251     public void setQueueTimeout(int queueTimeout)
252     {
253         this.queueTimeout = queueTimeout;
254     }
255 
256 }