View Javadoc

1   /*
2    * $Id: MuleDescriptor.java 7976 2007-08-21 14:26:13Z 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.impl;
12  
13  import org.mule.MuleException;
14  import org.mule.config.PoolingProfile;
15  import org.mule.config.QueueProfile;
16  import org.mule.config.ThreadingProfile;
17  import org.mule.impl.container.DescriptorContainerKeyPair;
18  import org.mule.umo.UMODescriptor;
19  import org.mule.umo.UMOInterceptor;
20  import org.mule.umo.endpoint.UMOEndpoint;
21  import org.mule.umo.routing.UMOInboundRouterCollection;
22  import org.mule.umo.routing.UMONestedRouterCollection;
23  import org.mule.umo.routing.UMOOutboundRouterCollection;
24  import org.mule.umo.routing.UMOResponseRouterCollection;
25  import org.mule.umo.transformer.UMOTransformer;
26  import org.mule.util.FileUtils;
27  
28  import java.beans.ExceptionListener;
29  import java.io.FileInputStream;
30  import java.util.List;
31  import java.util.Map;
32  import java.util.Properties;
33  
34  import org.apache.commons.logging.Log;
35  import org.apache.commons.logging.LogFactory;
36  
37  /**
38   * <code>MuleDescriptor</code> describes all the properties for a Mule UMO. New
39   * Mule UMOs can be initialised as needed from their descriptor.
40   *
41   */
42  
43  public class MuleDescriptor extends ImmutableMuleDescriptor implements UMODescriptor
44  {
45      public static final String DEFAULT_INSTANCE_REF_NAME = "_instanceRef";
46      /**
47       * logger used by this class
48       */
49      private static Log logger = LogFactory.getLog(MuleDescriptor.class);
50  
51      public MuleDescriptor(String name)
52      {
53          super();
54          this.name = name;
55      }
56  
57      public MuleDescriptor(MuleDescriptor descriptor)
58      {
59          super(descriptor);
60      }
61  
62      /**
63       * Default constructor. Initalises common properties for the MuleConfiguration
64       * object
65       *
66       * @see org.mule.config.MuleConfiguration
67       */
68      public MuleDescriptor()
69      {
70          super();
71      }
72  
73      public void setThreadingProfile(ThreadingProfile threadingProfile)
74      {
75          this.threadingProfile = threadingProfile;
76      }
77  
78      /*
79       * (non-Javadoc)
80       *
81       * @see org.mule.umo.UMODescriptor#setExceptionListener(org.mule.umo.UMOExceptionStrategy)
82       */
83      public void setExceptionListener(ExceptionListener listener)
84      {
85          if (listener == null)
86          {
87              throw new IllegalArgumentException("Exception Strategy cannot be null");
88          }
89          this.exceptionListener = listener;
90          logger.debug("Using exception strategy: " + listener.getClass().getName());
91      }
92  
93      /*
94       * (non-Javadoc)
95       *
96       * @see org.mule.umo.UMODescriptor#setName(java.lang.String)
97       */
98      public void setName(String newName)
99      {
100         if (newName == null)
101         {
102             throw new IllegalArgumentException("Name cannot be null");
103         }
104         name = newName;
105     }
106 
107     /*
108      * (non-Javadoc)
109      *
110      * @see org.mule.transformers.HasTransformer#setOutboundTransformer(org.mule.umo.transformer.UMOTransformer)
111      */
112     public void setOutboundTransformer(UMOTransformer transformer)
113     {
114         outboundTransformer = transformer;
115     }
116 
117     /*
118      * (non-Javadoc)
119      *
120      * @see org.mule.umo.UMODescriptor#setResponseTransformer(UMOTransformer)
121      */
122     public void setResponseTransformer(UMOTransformer transformer)
123     {
124         responseTransformer = transformer;
125     }
126 
127     /*
128      * (non-Javadoc)
129      *
130      * @see org.mule.umo.UMODescriptor#getPropertiesForURI(java.util.Properties)
131      */
132     public void setProperties(Map props)
133     {
134         properties = props;
135         String delegate = (String) properties.get(MULE_PROPERTY_DOT_PROPERTIES);
136         if (delegate != null)
137         {
138             try
139             {
140                 FileInputStream is = new FileInputStream(FileUtils.newFile(delegate));
141                 Properties dProps = new Properties();
142                 dProps.load(is);
143                 properties.putAll(dProps);
144             }
145             catch (Exception e)
146             {
147                 // TODO MULE-863: Sufficient?  Correct level?
148                 logger.warn(MULE_PROPERTY_DOT_PROPERTIES + " was set  to " + delegate
149                             + " but the file could not be read, exception is: " + e.getMessage());
150             }
151         }
152     }
153 
154     /*
155      * (non-Javadoc)
156      *
157      * @see org.mule.umo.UMODescriptor#setVersion(long)
158      */
159     public void setVersion(String ver)
160     {
161         version = ver;
162     }
163 
164     /*
165      * (non-Javadoc)
166      *
167      * @see org.mule.umo.UMODescriptor#setInboundEndpoint(org.mule.impl.UMOEndpoint)
168      */
169     public void setInboundEndpoint(UMOEndpoint endpoint) throws MuleException
170     {
171         inboundEndpoint = endpoint;
172         if (inboundEndpoint != null)
173         {
174             inboundEndpoint.setType(UMOEndpoint.ENDPOINT_TYPE_RECEIVER);
175             if (inboundEndpoint.getTransformer() != null)
176             {
177                 inboundTransformer = inboundEndpoint.getTransformer();
178             }
179         }
180     }
181 
182     /*
183      * (non-Javadoc)
184      *
185      * @see org.mule.umo.UMODescriptor#setOutboundEndpoint(org.mule.impl.UMO
186      *      ProviderDescriptor)
187      */
188     public void setOutboundEndpoint(UMOEndpoint endpoint) throws MuleException
189     {
190         outboundEndpoint = endpoint;
191         if (outboundEndpoint != null)
192         {
193             outboundEndpoint.setType(UMOEndpoint.ENDPOINT_TYPE_SENDER);
194             if (outboundEndpoint.getTransformer() != null)
195             {
196                 outboundTransformer = outboundEndpoint.getTransformer();
197             }
198         }
199 
200     }
201 
202     /*
203      * (non-Javadoc)
204      *
205      * @see org.mule.transformers.HasTransformer#setInboundTransformer(org.mule.umo.transformer.UMOTransformer)
206      */
207     public void setInboundTransformer(UMOTransformer transformer)
208     {
209         inboundTransformer = transformer;
210     }
211 
212     /*
213      * (non-Javadoc)
214      *
215      * @see org.mule.umo.UMODescriptor#addinteceptor(org.mule.umo.UMOInterceptor)
216      */
217     public void addInterceptor(UMOInterceptor inteceptor)
218     {
219         if (inteceptor != null)
220         {
221             intecerptorList.add(inteceptor);
222         }
223     }
224 
225     public void setInterceptors(List inteceptorList)
226     {
227         this.intecerptorList = inteceptorList;
228     }
229 
230     /*
231      * (non-Javadoc)
232      *
233      * @see org.mule.umo.UMODescriptor#setPoolingProfile(UMOPoolingProfile)
234      */
235     public void setPoolingProfile(PoolingProfile poolingProfile)
236     {
237         this.poolingProfile = poolingProfile;
238     }
239 
240     public void setQueueProfile(QueueProfile queueProfile)
241     {
242         this.queueProfile = queueProfile;
243     }
244 
245     /*
246      * (non-Javadoc)
247      *
248      * @see org.mule.umo.UMODescriptor#setImplementation(java.lang.String)
249      */
250     public void setImplementation(Object reference)
251     {
252         if (reference == null)
253         {
254             throw new IllegalArgumentException("ImplementationReference cannot be null");
255         }
256         implementationReference = reference;
257     }
258 
259     public void setImplementationInstance(Object instance)
260     {
261         if (name == null)
262         {
263             throw new IllegalArgumentException("UMODescriptor.name may not be null");
264         }
265         properties.put(DEFAULT_INSTANCE_REF_NAME, instance);
266         setImplementation(new DescriptorContainerKeyPair(name, DEFAULT_INSTANCE_REF_NAME));
267     }
268 
269     public void setInboundRouter(UMOInboundRouterCollection router)
270     {
271         this.inboundRouter = router;
272     }
273 
274     public void setOutboundRouter(UMOOutboundRouterCollection router)
275     {
276         outboundRouter = router;
277     }
278 
279     public void setNestedRouter(UMONestedRouterCollection router)
280     {
281         nestedRouter = router;
282     }
283 
284     public void setContainerManaged(boolean value)
285     {
286         containerManaged = value;
287     }
288 
289     public void addInitialisationCallback(InitialisationCallback callback)
290     {
291         initialisationCallbacks.add(callback);
292     }
293 
294     /**
295      * Response Routers control how events are returned in a request/response call.
296      * It cn be use to aggregate response events before returning, thus acting as a
297      * Join in a forked process. This can be used to make request/response calls a
298      * lot more efficient as independent tasks can be forked, execute concurrently
299      * and then join before the request completes
300      *
301      * @param router the response router for this component
302      * @see org.mule.umo.routing.UMOResponseRouterCollection
303      */
304     public void setResponseRouter(UMOResponseRouterCollection router)
305     {
306         this.responseRouter = router;
307     }
308 
309     /**
310      * Determines if only a single instance of this component is created. This is
311      * useful when a component hands off event processing to another engine such as
312      * Rules processing or Bpel and the processing engine allocates and manages its
313      * own threads.
314      *
315      * @param singleton true if this component is a singleton
316      */
317     public void setSingleton(boolean singleton)
318     {
319         this.singleton = singleton;
320     }
321 
322     /**
323      * Sets the initial state of this component
324      *
325      * @param state the initial state of this component
326      */
327     public void setInitialState(String state)
328     {
329         this.initialState = state;
330     }
331 
332     public void setEncoding(String encoding)
333     {
334         this.encoding = encoding;
335     }
336 
337     /**
338      * Sets the name of the contaier where the object for this descriptor resides. If
339      * this value is 'none' the 'implementaiton' attributed is expected to be a fully
340      * qualified class name that will be instanciated.
341      *
342      * @param containerName the container name, or null if it is not known - in which
343      *            case each container will be queried for the component
344      *            implementation.
345      */
346     public void setContainer(String containerName)
347     {
348         this.container = containerName;
349     }
350 
351 
352     public void setModelName(String modelName)
353     {
354         this.modelName = modelName;
355     }
356 }