Coverage Report - org.mule.impl.MuleDescriptor
 
Classes in this File Line Coverage Branch Coverage Complexity
MuleDescriptor
0%
0/90
0%
0/10
1.5
 
 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  0
     private static Log logger = LogFactory.getLog(MuleDescriptor.class);
 50  
 
 51  
     public MuleDescriptor(String name)
 52  
     {
 53  0
         super();
 54  0
         this.name = name;
 55  0
     }
 56  
 
 57  
     public MuleDescriptor(MuleDescriptor descriptor)
 58  
     {
 59  0
         super(descriptor);
 60  0
     }
 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  0
         super();
 71  0
     }
 72  
 
 73  
     public void setThreadingProfile(ThreadingProfile threadingProfile)
 74  
     {
 75  0
         this.threadingProfile = threadingProfile;
 76  0
     }
 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  0
         if (listener == null)
 86  
         {
 87  0
             throw new IllegalArgumentException("Exception Strategy cannot be null");
 88  
         }
 89  0
         this.exceptionListener = listener;
 90  0
         logger.debug("Using exception strategy: " + listener.getClass().getName());
 91  0
     }
 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  0
         if (newName == null)
 101  
         {
 102  0
             throw new IllegalArgumentException("Name cannot be null");
 103  
         }
 104  0
         name = newName;
 105  0
     }
 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  0
         outboundTransformer = transformer;
 115  0
     }
 116  
 
 117  
     /*
 118  
      * (non-Javadoc)
 119  
      *
 120  
      * @see org.mule.umo.UMODescriptor#setResponseTransformer(UMOTransformer)
 121  
      */
 122  
     public void setResponseTransformer(UMOTransformer transformer)
 123  
     {
 124  0
         responseTransformer = transformer;
 125  0
     }
 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  0
         properties = props;
 135  0
         String delegate = (String) properties.get(MULE_PROPERTY_DOT_PROPERTIES);
 136  0
         if (delegate != null)
 137  
         {
 138  
             try
 139  
             {
 140  0
                 FileInputStream is = new FileInputStream(FileUtils.newFile(delegate));
 141  0
                 Properties dProps = new Properties();
 142  0
                 dProps.load(is);
 143  0
                 properties.putAll(dProps);
 144  
             }
 145  0
             catch (Exception e)
 146  
             {
 147  
                 // TODO MULE-863: Sufficient?  Correct level?
 148  0
                 logger.warn(MULE_PROPERTY_DOT_PROPERTIES + " was set  to " + delegate
 149  
                             + " but the file could not be read, exception is: " + e.getMessage());
 150  0
             }
 151  
         }
 152  0
     }
 153  
 
 154  
     /*
 155  
      * (non-Javadoc)
 156  
      *
 157  
      * @see org.mule.umo.UMODescriptor#setVersion(long)
 158  
      */
 159  
     public void setVersion(String ver)
 160  
     {
 161  0
         version = ver;
 162  0
     }
 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  0
         inboundEndpoint = endpoint;
 172  0
         if (inboundEndpoint != null)
 173  
         {
 174  0
             inboundEndpoint.setType(UMOEndpoint.ENDPOINT_TYPE_RECEIVER);
 175  0
             if (inboundEndpoint.getTransformer() != null)
 176  
             {
 177  0
                 inboundTransformer = inboundEndpoint.getTransformer();
 178  
             }
 179  
         }
 180  0
     }
 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  0
         outboundEndpoint = endpoint;
 191  0
         if (outboundEndpoint != null)
 192  
         {
 193  0
             outboundEndpoint.setType(UMOEndpoint.ENDPOINT_TYPE_SENDER);
 194  0
             if (outboundEndpoint.getTransformer() != null)
 195  
             {
 196  0
                 outboundTransformer = outboundEndpoint.getTransformer();
 197  
             }
 198  
         }
 199  
 
 200  0
     }
 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  0
         inboundTransformer = transformer;
 210  0
     }
 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  0
         if (inteceptor != null)
 220  
         {
 221  0
             intecerptorList.add(inteceptor);
 222  
         }
 223  0
     }
 224  
 
 225  
     public void setInterceptors(List inteceptorList)
 226  
     {
 227  0
         this.intecerptorList = inteceptorList;
 228  0
     }
 229  
 
 230  
     /*
 231  
      * (non-Javadoc)
 232  
      *
 233  
      * @see org.mule.umo.UMODescriptor#setPoolingProfile(UMOPoolingProfile)
 234  
      */
 235  
     public void setPoolingProfile(PoolingProfile poolingProfile)
 236  
     {
 237  0
         this.poolingProfile = poolingProfile;
 238  0
     }
 239  
 
 240  
     public void setQueueProfile(QueueProfile queueProfile)
 241  
     {
 242  0
         this.queueProfile = queueProfile;
 243  0
     }
 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  0
         if (reference == null)
 253  
         {
 254  0
             throw new IllegalArgumentException("ImplementationReference cannot be null");
 255  
         }
 256  0
         implementationReference = reference;
 257  0
     }
 258  
 
 259  
     public void setImplementationInstance(Object instance)
 260  
     {
 261  0
         if (name == null)
 262  
         {
 263  0
             throw new IllegalArgumentException("UMODescriptor.name may not be null");
 264  
         }
 265  0
         properties.put(DEFAULT_INSTANCE_REF_NAME, instance);
 266  0
         setImplementation(new DescriptorContainerKeyPair(name, DEFAULT_INSTANCE_REF_NAME));
 267  0
     }
 268  
 
 269  
     public void setInboundRouter(UMOInboundRouterCollection router)
 270  
     {
 271  0
         this.inboundRouter = router;
 272  0
     }
 273  
 
 274  
     public void setOutboundRouter(UMOOutboundRouterCollection router)
 275  
     {
 276  0
         outboundRouter = router;
 277  0
     }
 278  
 
 279  
     public void setNestedRouter(UMONestedRouterCollection router)
 280  
     {
 281  0
         nestedRouter = router;
 282  0
     }
 283  
 
 284  
     public void setContainerManaged(boolean value)
 285  
     {
 286  0
         containerManaged = value;
 287  0
     }
 288  
 
 289  
     public void addInitialisationCallback(InitialisationCallback callback)
 290  
     {
 291  0
         initialisationCallbacks.add(callback);
 292  0
     }
 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  0
         this.responseRouter = router;
 307  0
     }
 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  0
         this.singleton = singleton;
 320  0
     }
 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  0
         this.initialState = state;
 330  0
     }
 331  
 
 332  
     public void setEncoding(String encoding)
 333  
     {
 334  0
         this.encoding = encoding;
 335  0
     }
 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  0
         this.container = containerName;
 349  0
     }
 350  
 
 351  
 
 352  
     public void setModelName(String modelName)
 353  
     {
 354  0
         this.modelName = modelName;
 355  0
     }
 356  
 }