Coverage report

| %line | %branch
--- | --- | ---
org.apache.stratum.component.ComponentLoader |
84% |
100% |

1 |  |
     package org.apache.stratum.component;
2 |  |
3 |  |
     /*
4 |  |
      * Copyright 2001-2005 The Apache Software Foundation or its licensors,
5 |  |
      * as applicable.
6 |  |
      *
7 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
8 |  |
      * you may not use this file except in compliance with the License.
9 |  |
      * You may obtain a copy of the License at
10 |  |
      *
11 |  |
      *     http://www.apache.org/licenses/LICENSE-2.0
12 |  |
      *
13 |  |
      * Unless required by applicable law or agreed to in writing, software
14 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
15 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 |  |
      * See the License for the specific language governing permissions and
17 |  |
      * limitations under the License.
18 |  |
      */
19 |  |
20 |  |
     import java.io.IOException;
21 |  |
     import java.util.List;
22 |  |
23 |  |
     import org.apache.commons.configuration.CompositeConfiguration;
24 |  |
     import org.apache.commons.configuration.Configuration;
25 |  |
     import org.apache.commons.configuration.PropertiesConfiguration;
26 |  |
     import org.apache.log4j.Category;
27 |  |
     import org.apache.stratum.lifecycle.Configurable;
28 |  |
     import org.apache.stratum.lifecycle.Initializable;
29 |  |
30 |  |
     /**
31 |  |
      * Loader for Components implementing the lifecyle Interfaces. NOTE: This class is in its infancy and will more than likely change.
32 |  |
      *
33 |  |
      * @author <a href="mailto:eric NOSPAM dobbse.net">Eric Dobbs </a>
34 |  |
      * @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl </a>
35 |  |
      * @version $Id: ComponentLoader.java 264191 2005-08-29 18:07:52Z henning $
36 |  |
      */
37 |  |
     public class ComponentLoader
38 |  |
     {
39 |  |
         /** Log4j category used for logging. NOTE: we should change this to use the commons-logging API. */
40 | 18 |
         private static Category log = Category.getInstance(ComponentLoader.class);
41 |  |
42 |  |
         /** Component tag used in Configurations */
43 | 9 |
         private static String COMPONENT = "component";
44 |  |
45 | 4 |
         /** Class name tag used in Configurations */
46 | 9 |
         private static String CLASSNAME = "classname";
47 |  |
48 |  |
         /** Extension used for Configuration files. */
49 | 9 |
         private static String CONFIG = "config";
50 | 2 |
51 |  |
         /** Extension used for Additional properties. */
52 | 9 |
         private static String PROPERTY = "property";
53 |  |
54 |  |
         /** Name tag used in Configurations */
55 | 11 |
         private static String NAME = "name";
56 |  |
57 |  |
         /** Configuration used by this ComponentLoader. */
58 |  |
         private Configuration configuration;
59 |  |
60 | 2 |
         /**
61 |  |
          * Constructor
62 |  |
          *
63 |  |
          * @param configuration
64 |  |
          */
65 | 2 |
         public ComponentLoader(Configuration configuration)
66 | 36 |
         {
67 | 36 |
             this.configuration = configuration;
68 | 36 |
         }
69 |  |
70 | 2 |
         /**
71 |  |
          * Set the configuration for this ComponentLoader
72 |  |
          *
73 |  |
          * @param configuration Configuration
74 |  |
          */
75 |  |
         public void setConfiguration(Configuration configuration)
76 |  |
         {
77 | 0 |
             this.configuration = configuration;
78 | 0 |
         }
79 |  |
80 |  |
         /**
81 |  |
          * Support method for testing the constructor
82 | 8 |
          *
83 | 8 |
          * @return the configuration
84 | 8 |
          */
85 |  |
         public Configuration getConfiguration()
86 |  |
         {
87 | 9 |
             return configuration;
88 |  |
         }
89 |  |
90 |  |
         /**
91 |  |
          * <p>
92 |  |
          * Load all the components listed in the ComponentLoader's configuration. Log any errors, but throw no exceptions if components
93 |  |
          * cannot be loaded.
94 |  |
          * </p>
95 |  |
          * Configuration notes:<br>
96 |  |
          * Components are identified in the properties file as follows: <br>
97 |  |
          * <code> component.name=NAME component.NAME.classname = com.mycompany.components.SomeComponent component.NAME.config    =
98 |  |
          * path/to/SomeComponent.properties </code>
99 |  |
          *
100 |  |
          * @return an array of loaded components
101 |  |
          */
102 | 2 |
         public Object [] load()
103 |  |
         {
104 | 9 |
             List components = configuration.getList(COMPONENT + '.' + NAME);
105 | 9 |
             Object [] loadedComponents = new Object[components.size()];
106 |  |
107 |  |
             String componentName;
108 |  |
             String componentClassName;
109 |  |
             String componentConfig;
110 |  |
             Configuration componentAdditionalConfig;
111 |  |
112 | 36 |
             for (int i = 0; i < components.size(); i++)
113 |  |
             {
114 | 27 |
                 componentName = (String) components.get(i);
115 | 27 |
                 componentClassName = getComponentClassname(componentName);
116 | 27 |
                 componentConfig = getComponentConfigFile(componentName);
117 | 27 |
                 componentAdditionalConfig = getComponentAdditionalConfig(componentName);
118 |  |
119 | 27 |
                 log.info("loading component: name=" + componentName + " class=" + componentClassName + " config=" + componentConfig);
120 |  |
121 | 29 |
                 loadedComponents[i] = loadComponent(componentClassName, componentConfig, componentAdditionalConfig);
122 | 2 |
             }
123 |  |
124 | 9 |
             return loadedComponents;
125 |  |
         }
126 |  |
127 |  |
         /**
128 |  |
          * load the given component, configure it with the given config file, and initialize it. <br>
129 | 8 |
          * The component must implement the <code>Initializable</code> and <code>Configurable</code> interfaces.
130 | 6 |
          *
131 | 6 |
          * @param className the String class name of the component to load
132 | 6 |
          * @param configFile the String path name of the component's config file
133 | 6 |
          * @param additionalConfig TODO: DOCUMENT ME!
134 |  |
          *
135 | 6 |
          * @return the loaded component or null if it failed to load
136 |  |
          *
137 |  |
          * @see Initializable
138 | 6 |
          * @see Configurable
139 |  |
          */
140 |  |
         public Object loadComponent(String className, String configFile, Configuration additionalConfig)
141 | 2 |
         {
142 | 54 |
             Object component = null;
143 |  |
144 | 54 |
             if (log.isDebugEnabled())
145 |  |
             {
146 | 0 |
                 log.debug("attempting to load '" + className + "' with the config file '" + configFile + "'.");
147 |  |
             }
148 |  |
149 |  |
             try
150 |  |
             {
151 | 54 |
                 component = Class.forName(className).newInstance();
152 |  |
153 |  |
                 // configure component using the given config file
154 | 36 |
                 CompositeConfiguration config = new CompositeConfiguration();
155 | 36 |
                 config.addConfiguration(new PropertiesConfiguration(configFile));
156 | 27 |
                 config.addConfiguration(additionalConfig);
157 | 27 |
                 ((Configurable) component).configure(config);
158 |  |
159 |  |
                 // initialize component
160 | 39 |
                 ((Initializable) component).initialize();
161 |  |
162 | 39 |
                 if (log.isDebugEnabled())
163 |  |
                 {
164 | 0 |
                     log.debug("good news! " + className + " successfully configured and initialized");
165 |  |
                 }
166 |  |
             }
167 | 0 |
             catch (IOException ioe)
168 | 12 |
             {
169 | 0 |
                 log.error(className + " could not be configured with file '" + configFile + "'.", ioe);
170 |  |
             }
171 | 35 |
             catch (Exception e)
172 | 8 |
             {
173 | 33 |
                 log.error(className + " could not be initialized!", e);
174 | 33 |
             }
175 |  |
176 | 54 |
             return component;
177 | 6 |
         }
178 |  |
179 | 6 |
         /**
180 |  |
          * <p>
181 |  |
          * Get the component's classname as defined in the ComponentLoader configuration.
182 |  |
          * </p>
183 |  |
          *
184 |  |
          * <p>
185 |  |
          * Example property: <br/> component.NAME.classname=com.mycompany.components.MyComponent
186 | 6 |
          * </p>
187 | 6 |
          *
188 | 6 |
          * @param name the String NAME of the component in the classfile
189 |  |
          *
190 | 12 |
          * @return the configured classname
191 |  |
          */
192 |  |
         private String getComponentClassname(String name)
193 |  |
         {
194 | 27 |
             return configuration.getString(COMPONENT + '.' + name + '.' + CLASSNAME);
195 |  |
         }
196 |  |
197 |  |
         /**
198 |  |
          * <p>
199 |  |
          * Get the component's config file as defined in the ComponentLoader configuration.
200 |  |
          * </p>
201 |  |
          *
202 |  |
          * <p>
203 |  |
          * Example property: <br/>component.NAME.config=path/to/your/config
204 |  |
          * </p>
205 |  |
          *
206 |  |
          * @param name the String NAME of the component in the classfile
207 |  |
          *
208 |  |
          * @return the configured config file
209 | 6 |
          */
210 |  |
         private String getComponentConfigFile(String name)
211 |  |
         {
212 | 27 |
             return configuration.getString(COMPONENT + '.' + name + '.' + CONFIG);
213 |  |
         }
214 |  |
215 |  |
         /**
216 |  |
          * <p>
217 |  |
          * Get any additional configuration properties from the master configuration.
218 |  |
          * </p>
219 |  |
          *
220 |  |
          * <p>
221 |  |
          * Example property: <br/>
222 |  |
          * component.NAME.property.key1==value1 <br/>
223 |  |
          * component.NAME.property.key2==value2 <br/>
224 |  |
          * component.NAME.property.key3==value3 <br/>
225 |  |
          * </p>
226 |  |
          *
227 |  |
          * @param name the String NAME of the component in the classfile
228 | 6 |
          *
229 |  |
          * @return the extra properties as a Configuration object
230 |  |
          */
231 |  |
         private Configuration getComponentAdditionalConfig(String name)
232 |  |
         {
233 | 27 |
             return configuration.subset(COMPONENT + '.' + name + '.' + PROPERTY);
234 |  |
         }
235 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.