Coverage Report - org.mule.context.DefaultMuleContextFactory
 
Classes in this File Line Coverage Branch Coverage Complexity
DefaultMuleContextFactory
93%
27/29
70%
7/10
1.3
 
 1  
 /*
 2  
  * $Id: DefaultMuleContextFactory.java 11370 2008-03-15 03:06:08Z tcarlson $
 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.context;
 12  
 
 13  
 import org.mule.MuleServer;
 14  
 import org.mule.RegistryContext;
 15  
 import org.mule.api.MuleContext;
 16  
 import org.mule.api.config.ConfigurationBuilder;
 17  
 import org.mule.api.config.ConfigurationException;
 18  
 import org.mule.api.context.MuleContextBuilder;
 19  
 import org.mule.api.context.MuleContextFactory;
 20  
 import org.mule.api.lifecycle.InitialisationException;
 21  
 import org.mule.config.builders.AutoConfigurationBuilder;
 22  
 import org.mule.config.builders.DefaultsConfigurationBuilder;
 23  
 import org.mule.config.builders.SimpleConfigurationBuilder;
 24  
 
 25  
 import java.util.List;
 26  
 import java.util.Properties;
 27  
 
 28  
 import org.apache.commons.logging.Log;
 29  
 import org.apache.commons.logging.LogFactory;
 30  
 
 31  
 /**
 32  
  * Default implementation that stores MuleContext in {@link MuleServer} static and
 33  
  * uses {@link DefaultMuleContextBuilder} to build new {@link MuleContext} instances.
 34  
  */
 35  1160
 public class DefaultMuleContextFactory implements MuleContextFactory
 36  
 {
 37  2
     protected static final Log logger = LogFactory.getLog(DefaultMuleContextBuilder.class);
 38  
 
 39  
     /**
 40  
      * Use default ConfigurationBuilder, default MuleContextBuilder
 41  
      */
 42  
     public MuleContext createMuleContext() throws InitialisationException, ConfigurationException
 43  
     {
 44  
         // Configure with defaults needed for a feasible/startable MuleContext
 45  4
         return createMuleContext(new DefaultsConfigurationBuilder(), new DefaultMuleContextBuilder());
 46  
     }
 47  
 
 48  
     /**
 49  
      * Use default MuleContextBuilder
 50  
      */
 51  
     public MuleContext createMuleContext(ConfigurationBuilder configurationBuilder)
 52  
         throws InitialisationException, ConfigurationException
 53  
     {
 54  
         // Create MuleContext using default MuleContextBuilder
 55  2
         return createMuleContext(configurationBuilder, new DefaultMuleContextBuilder());
 56  
     }
 57  
 
 58  
     /**
 59  
      * Use default ConfigurationBuilder
 60  
      */
 61  
     public MuleContext createMuleContext(MuleContextBuilder muleContextBuilder)
 62  
         throws InitialisationException, ConfigurationException
 63  
     {
 64  
         // Configure with defaults needed for a feasible/startable MuleContext
 65  0
         return createMuleContext(new DefaultsConfigurationBuilder(), muleContextBuilder);
 66  
     }
 67  
 
 68  
     /**
 69  
      * {@inheritDoc
 70  
      */
 71  
     public MuleContext createMuleContext(List configurationBuilders, MuleContextBuilder muleContextBuilder)
 72  
         throws InitialisationException, ConfigurationException
 73  
     {
 74  
         // Create MuleContext
 75  1144
         MuleContext muleContext = doCreateMuleContext(muleContextBuilder);
 76  
 
 77  
         // Configure
 78  3432
         for (int i = 0; i < configurationBuilders.size(); i++)
 79  
         {
 80  2288
             ((ConfigurationBuilder) configurationBuilders.get(i)).configure(muleContext);
 81  
         }
 82  
 
 83  1144
         return muleContext;
 84  
     }
 85  
 
 86  
     /**
 87  
      * {@inheritDoc
 88  
      */
 89  
     public MuleContext createMuleContext(ConfigurationBuilder configurationBuilder,
 90  
                                          MuleContextBuilder muleContextBuilder)
 91  
         throws InitialisationException, ConfigurationException
 92  
     {
 93  
         // Create MuleContext
 94  10
         MuleContext muleContext = doCreateMuleContext(muleContextBuilder);
 95  
 
 96  
         // Configure
 97  10
         configurationBuilder.configure(muleContext);
 98  
 
 99  10
         return muleContext;
 100  
     }
 101  
 
 102  
     // Additional Factory methods provided by this implementation.
 103  
 
 104  
     /**
 105  
      * Creates a new {@link MuleContext} instance from the resource provided.
 106  
      * Implementations of {@link MuleContextFactory} can either use a default
 107  
      * {@link ConfigurationBuilder} to implement this, or do some auto-detection to
 108  
      * determine the {@link ConfigurationBuilder} that should be used.
 109  
      * 
 110  
      * @param configResources comma seperated list of configuration resources.
 111  
      * @return
 112  
      * @throws InitialisationException
 113  
      * @throws ConfigurationException
 114  
      */
 115  
     public MuleContext createMuleContext(String resource)
 116  
         throws InitialisationException, ConfigurationException
 117  
     {
 118  2
         return createMuleContext(resource, null);
 119  
     }
 120  
 
 121  
     /**
 122  
      * Creates a new {@link MuleContext} instance from the resource provided.
 123  
      * Implementations of {@link MuleContextFactory} can either use a default
 124  
      * {@link ConfigurationBuilder} to implement this, or do some auto-detection to
 125  
      * determine the {@link ConfigurationBuilder} that should be used. Properties if
 126  
      * provided are used to replace "property placeholder" value in configuration
 127  
      * files.
 128  
      * 
 129  
      * @param resource
 130  
      * @param properties
 131  
      * @return
 132  
      * @throws InitialisationException
 133  
      * @throws ConfigurationException
 134  
      */
 135  
     public MuleContext createMuleContext(String configResources, Properties properties)
 136  
         throws InitialisationException, ConfigurationException
 137  
     {
 138  
         // Create MuleContext
 139  4
         MuleContext muleContext = doCreateMuleContext(new DefaultMuleContextBuilder());
 140  
 
 141  
         // Configure with startup properties
 142  4
         if (properties != null && !properties.isEmpty())
 143  
         {
 144  2
             new SimpleConfigurationBuilder(properties).configure(muleContext);
 145  
         }
 146  
 
 147  
         // Automatically resolve Configuration to be used and delegate configuration
 148  
         // to it.
 149  4
         new AutoConfigurationBuilder(configResources).configure(muleContext);
 150  
 
 151  0
         return muleContext;
 152  
     }
 153  
 
 154  
     /**
 155  
      * Creates a new MuleContext using the given configurationBuilder. Properties if
 156  
      * provided are used to replace "property placeholder" value in configuration
 157  
      * files.
 158  
      * 
 159  
      * @param configurationBuilder
 160  
      * @param properties
 161  
      * @return
 162  
      * @throws InitialisationException
 163  
      * @throws ConfigurationException
 164  
      */
 165  
     public MuleContext createMuleContext(ConfigurationBuilder configurationBuilder, Properties properties)
 166  
         throws InitialisationException, ConfigurationException
 167  
     {
 168  
         // Create MuleContext
 169  2
         MuleContext muleContext = doCreateMuleContext(new DefaultMuleContextBuilder());
 170  
 
 171  
         // Configure with startup properties
 172  2
         if (properties != null && !properties.isEmpty())
 173  
         {
 174  2
             new SimpleConfigurationBuilder(properties).configure(muleContext);
 175  
         }
 176  
 
 177  
         // Configure with cconfigurationBuilder
 178  2
         configurationBuilder.configure(muleContext);
 179  
 
 180  2
         return muleContext;
 181  
     }
 182  
 
 183  
     protected MuleContext doCreateMuleContext(MuleContextBuilder muleContextBuilder)
 184  
         throws InitialisationException
 185  
     {
 186  
         // Create transent registry
 187  1160
         RegistryContext.getOrCreateRegistry();
 188  
 
 189  
         // Create muleContext instance and set it in MuleServer
 190  1160
         MuleContext muleContext = buildMuleContext(muleContextBuilder);
 191  1160
         MuleServer.setMuleContext(muleContext);
 192  
 
 193  
         // Initialiase MuleContext
 194  1160
         muleContext.initialise();
 195  
 
 196  1160
         return muleContext;
 197  
     }
 198  
 
 199  
     protected MuleContext buildMuleContext(MuleContextBuilder muleContextBuilder)
 200  
     {
 201  1160
         return muleContextBuilder.buildMuleContext();
 202  
     }
 203  
 
 204  
 }