View Javadoc

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  public class DefaultMuleContextFactory implements MuleContextFactory
36  {
37      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          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          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          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          MuleContext muleContext = doCreateMuleContext(muleContextBuilder);
76  
77          // Configure
78          for (int i = 0; i < configurationBuilders.size(); i++)
79          {
80              ((ConfigurationBuilder) configurationBuilders.get(i)).configure(muleContext);
81          }
82  
83          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          MuleContext muleContext = doCreateMuleContext(muleContextBuilder);
95  
96          // Configure
97          configurationBuilder.configure(muleContext);
98  
99          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         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         MuleContext muleContext = doCreateMuleContext(new DefaultMuleContextBuilder());
140 
141         // Configure with startup properties
142         if (properties != null && !properties.isEmpty())
143         {
144             new SimpleConfigurationBuilder(properties).configure(muleContext);
145         }
146 
147         // Automatically resolve Configuration to be used and delegate configuration
148         // to it.
149         new AutoConfigurationBuilder(configResources).configure(muleContext);
150 
151         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         MuleContext muleContext = doCreateMuleContext(new DefaultMuleContextBuilder());
170 
171         // Configure with startup properties
172         if (properties != null && !properties.isEmpty())
173         {
174             new SimpleConfigurationBuilder(properties).configure(muleContext);
175         }
176 
177         // Configure with cconfigurationBuilder
178         configurationBuilder.configure(muleContext);
179 
180         return muleContext;
181     }
182 
183     protected MuleContext doCreateMuleContext(MuleContextBuilder muleContextBuilder)
184         throws InitialisationException
185     {
186         // Create transent registry
187         RegistryContext.getOrCreateRegistry();
188 
189         // Create muleContext instance and set it in MuleServer
190         MuleContext muleContext = buildMuleContext(muleContextBuilder);
191         MuleServer.setMuleContext(muleContext);
192 
193         // Initialiase MuleContext
194         muleContext.initialise();
195 
196         return muleContext;
197     }
198 
199     protected MuleContext buildMuleContext(MuleContextBuilder muleContextBuilder)
200     {
201         return muleContextBuilder.buildMuleContext();
202     }
203 
204 }