2009/04/15 - Apache HiveMind has been retired.

For more information, please explore the Attic.

Clover coverage report - Code Coverage for hivemind release 1.2.1
Coverage timestamp: Fri Feb 10 2006 16:33:43 PST
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 217   Methods: 9
NCLOC: 121   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
XmlModuleDescriptorProvider.java 100% 95.3% 100% 96.9%
coverage coverage
 1    // Copyright 2004, 2005 The Apache Software Foundation
 2    //
 3    // Licensed under the Apache License, Version 2.0 (the "License");
 4    // you may not use this file except in compliance with the License.
 5    // You may obtain a copy of the License at
 6    //
 7    // http://www.apache.org/licenses/LICENSE-2.0
 8    //
 9    // Unless required by applicable law or agreed to in writing, software
 10    // distributed under the License is distributed on an "AS IS" BASIS,
 11    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12    // See the License for the specific language governing permissions and
 13    // limitations under the License.
 14   
 15    package org.apache.hivemind.impl;
 16   
 17    import java.io.IOException;
 18    import java.net.URL;
 19    import java.util.ArrayList;
 20    import java.util.Enumeration;
 21    import java.util.Iterator;
 22    import java.util.List;
 23   
 24    import org.apache.commons.logging.Log;
 25    import org.apache.commons.logging.LogFactory;
 26    import org.apache.hivemind.ApplicationRuntimeException;
 27    import org.apache.hivemind.ClassResolver;
 28    import org.apache.hivemind.ErrorHandler;
 29    import org.apache.hivemind.HiveMind;
 30    import org.apache.hivemind.ModuleDescriptorProvider;
 31    import org.apache.hivemind.Resource;
 32    import org.apache.hivemind.parse.ModuleDescriptor;
 33    import org.apache.hivemind.parse.SubModuleDescriptor;
 34    import org.apache.hivemind.parse.XmlResourceProcessor;
 35    import org.apache.hivemind.util.URLResource;
 36   
 37    /**
 38    * Implementation of the {@link ModuleDescriptorProvider} interface which uses the
 39    * {@link org.apache.hivemind.parse.DescriptorParser} to provide module descriptors defined in XML.
 40    * The module descriptors are loaded from files or resources on the classpath.
 41    *
 42    * @author Knut Wannheden
 43    * @since 1.1
 44    */
 45    public class XmlModuleDescriptorProvider implements ModuleDescriptorProvider
 46    {
 47    private static final Log LOG = LogFactory.getLog(XmlModuleDescriptorProvider.class);
 48   
 49    /**
 50    * The default path, within a JAR or the classpath, to the XML HiveMind module deployment
 51    * descriptor: <code>META-INF/hivemodule.xml</code>. Use this constant with the
 52    * {@link #XmlModuleDescriptorProvider(ClassResolver, String)} constructor.
 53    */
 54    public static final String HIVE_MODULE_XML = "META-INF/hivemodule.xml";
 55   
 56    /**
 57    * Set of all specified resources processed by this ModuleDescriptorProvider. Descriptors of
 58    * sub-modules are not included.
 59    */
 60    private List _resources = new ArrayList();
 61   
 62    /**
 63    * List of parsed {@link ModuleDescriptor} instances. Also includes referenced sub-modules.
 64    */
 65    private List _moduleDescriptors = new ArrayList();
 66   
 67    private ClassResolver _resolver;
 68   
 69    private ErrorHandler _errorHandler;
 70   
 71    /**
 72    * Parser instance used by all parsing of module descriptors.
 73    */
 74    private XmlResourceProcessor _processor;
 75   
 76    /**
 77    * Convenience constructor. Equivalent to using
 78    * {@link #XmlModuleDescriptorProvider(ClassResolver, String)}with {@link #HIVE_MODULE_XML} as
 79    * the second argument.
 80    */
 81  122 public XmlModuleDescriptorProvider(ClassResolver resolver)
 82    {
 83  122 this(resolver, HIVE_MODULE_XML);
 84    }
 85   
 86    /**
 87    * Loads all XML module descriptors found on the classpath (using the given
 88    * {@link org.apache.hivemind.ClassResolver}. Only module descriptors matching the specified
 89    * path are loaded. Use the {@link XmlModuleDescriptorProvider#HIVE_MODULE_XML} constant to load
 90    * all descriptors in the default location.
 91    */
 92  122 public XmlModuleDescriptorProvider(ClassResolver resolver, String resourcePath)
 93    {
 94  122 _resolver = resolver;
 95  122 _resources.addAll(getDescriptorResources(resourcePath, _resolver));
 96    }
 97   
 98    /**
 99    * Constructs an XmlModuleDescriptorProvider only loading the ModuleDescriptor identified by the
 100    * given {@link org.apache.hivemind.Resource}.
 101    */
 102  2 public XmlModuleDescriptorProvider(ClassResolver resolver, Resource resource)
 103    {
 104  2 _resolver = resolver;
 105  2 _resources.add(resource);
 106    }
 107   
 108    /**
 109    * Constructs an XmlModuleDescriptorProvider loading all ModuleDescriptor identified by the
 110    * given List of {@link org.apache.hivemind.Resource} objects.
 111    */
 112  111 public XmlModuleDescriptorProvider(ClassResolver resolver, List resources)
 113    {
 114  111 _resolver = resolver;
 115  111 _resources.addAll(resources);
 116    }
 117   
 118  122 private List getDescriptorResources(String resourcePath, ClassResolver resolver)
 119    {
 120  122 if (LOG.isDebugEnabled())
 121  12 LOG.debug("Processing modules visible to " + resolver);
 122   
 123  122 List descriptors = new ArrayList();
 124   
 125  122 ClassLoader loader = resolver.getClassLoader();
 126  122 Enumeration e = null;
 127   
 128  122 try
 129    {
 130  122 e = loader.getResources(resourcePath);
 131    }
 132    catch (IOException ex)
 133    {
 134  0 throw new ApplicationRuntimeException(ImplMessages.unableToFindModules(resolver, ex),
 135    ex);
 136    }
 137   
 138  122 while (e.hasMoreElements())
 139    {
 140  123 URL descriptorURL = (URL) e.nextElement();
 141   
 142  123 descriptors.add(new URLResource(descriptorURL));
 143    }
 144   
 145  122 return descriptors;
 146    }
 147   
 148  235 public List getModuleDescriptors(ErrorHandler handler)
 149    {
 150  235 _errorHandler = handler;
 151   
 152  235 _processor = getResourceProcessor(_resolver, handler);
 153   
 154  235 for (Iterator i = _resources.iterator(); i.hasNext();)
 155    {
 156  245 Resource resource = (Resource) i.next();
 157   
 158  245 processResource(resource);
 159    }
 160   
 161  235 _processor = null;
 162   
 163  235 _errorHandler = null;
 164   
 165  235 return _moduleDescriptors;
 166    }
 167   
 168  247 private void processResource(Resource resource)
 169    {
 170  247 try
 171    {
 172  247 ModuleDescriptor md = _processor.processResource(resource);
 173   
 174  247 _moduleDescriptors.add(md);
 175   
 176    // After parsing a module, parse any additional modules identified
 177    // within the module (using the <sub-module> element) recursively.
 178  247 processSubModules(md);
 179    }
 180    catch (RuntimeException ex)
 181    {
 182  0 _errorHandler.error(LOG, ex.getMessage(), HiveMind.getLocation(ex), ex);
 183    }
 184    }
 185   
 186  247 private void processSubModules(ModuleDescriptor moduleDescriptor)
 187    {
 188  247 List subModules = moduleDescriptor.getSubModules();
 189   
 190  247 if (subModules == null)
 191  244 return;
 192   
 193  3 for (Iterator i = subModules.iterator(); i.hasNext();)
 194    {
 195  3 SubModuleDescriptor smd = (SubModuleDescriptor) i.next();
 196   
 197  3 Resource descriptorResource = smd.getDescriptor();
 198   
 199  3 if (descriptorResource.getResourceURL() == null)
 200    {
 201  1 _errorHandler.error(
 202    LOG,
 203    ImplMessages.subModuleDoesNotExist(descriptorResource),
 204    smd.getLocation(),
 205    null);
 206  1 continue;
 207    }
 208   
 209  2 processResource(smd.getDescriptor());
 210    }
 211    }
 212   
 213  235 protected XmlResourceProcessor getResourceProcessor(ClassResolver resolver, ErrorHandler handler)
 214    {
 215  235 return new XmlResourceProcessor(resolver, handler);
 216    }
 217    }
 
CloverReport generated by Clover Code Coverage v1.3.8
Fri Feb 10 2006 16:33:59 PST.		   Open Source License registered to the Apache Software Foundation. This license of Clover is provided to support projects of the Apache Software Foundation only.