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.