/*
    * ConfigurationToolkit.java
    *
    * Created on June 4, 2004, 10:51 AM
    */
   
   package gov.bnl.gums.configuration;
   
   import gov.bnl.gums.GUMS;
  import gov.bnl.gums.GridUser;
  import gov.bnl.gums.SiteUser;
  import gov.bnl.gums.account.AccountMapper;
  import gov.bnl.gums.account.ManualAccountMapper;
  import gov.bnl.gums.admin.CertCache;
  import gov.bnl.gums.groupToAccount.GroupToAccountMapping;
  import gov.bnl.gums.hostToGroup.CertificateHostToGroupMapping;
  import gov.bnl.gums.hostToGroup.HostToGroupMapping;
  import gov.bnl.gums.userGroup.UserGroup;
  import gov.bnl.gums.userGroup.VOMSUserGroup;
  import gov.bnl.gums.userGroup.ManualUserGroup;
  import gov.bnl.gums.util.StringUtil;
  import gov.bnl.gums.util.URIToolkit;
  
  import java.io.ByteArrayInputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.io.PrintStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.*;
  import java.util.jar.JarFile;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.Source;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.sax.SAXSource;
  import javax.xml.transform.stream.StreamResult;
  import javax.xml.transform.stream.StreamSource;
  
  import org.xml.sax.ErrorHandler;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXParseException;
  import org.xml.sax.SAXException;
  import org.xml.sax.XMLReader;
  import org.xml.sax.helpers.XMLReaderFactory;
  import org.apache.commons.beanutils.MethodUtils;
  import org.apache.commons.digester.*;
  import org.apache.log4j.Logger;
  
  /**
   * Contains the logic on how to parse an XML configuration file to create a
   * correctly built Configuration object.
   * 
   * @author Gabriele Carcassi, Jay Packard
   */
  public class ConfigurationToolkit {
  	/**
  	 * Simple error handler that logs errors
  	 * 
  	 * @author jpackard
  	 */
  	public class SimpleErrorHandler implements ErrorHandler {
  		public String error = null;
  
  		public void error(SAXParseException exception) {
  			log.error(exception.getMessage());
  			adminLog.error(exception.getMessage());
  			error = exception.getMessage();
  		}
  
  		public void fatalError(SAXParseException exception) {
  			log.fatal(exception.getMessage());
  			adminLog.fatal(exception.getMessage());
  			error = exception.getMessage();
  		}
  
  		public void warning(SAXParseException exception) {
  			log.warn(exception.getMessage());
  			adminLog.warn(exception.getMessage());
  		}
  	}
  	// Config Element Rule
  	private static class ConfElementRule extends Rule {
  		public void begin(String str, String str1, org.xml.sax.Attributes attributes) throws java.lang.Exception {
  			Object configElement = getDigester().peek();
  			for (int i = 0; i < attributes.getLength(); i++) {
  				String attribute = attributes.getQName(i);
  				String value = attributes.getValue(i);
  				String setMethod = "set" + attribute.substring(0, 1).toUpperCase() + attribute.substring(1);
  				try {
  					try {
  						// Try set method
 						MethodUtils.invokeMethod(configElement, setMethod, value);
 					} catch (NoSuchMethodException e) {
 						if (value.length()==0)
 							// For case when transform results in '' for boolean - too difficult to change in transform file
 							continue;
 						// Try interpreting value as boolean
 						Boolean boolVal;
 						try {
 							boolVal = new Boolean(value);
 							MethodUtils.invokeMethod(configElement, setMethod, boolVal);
 						}
 						catch (Exception e2) {
 							throw new NoSuchMethodException();
 						}
 					}
 				} catch (NoSuchMethodException e) {
 					// Try using add method
 					try {
 						StringTokenizer tokens = new StringTokenizer(value, ",");
 						while (tokens.hasMoreTokens()) {
 							value = tokens.nextToken().trim();
 							String addMethod = "add" + attribute.substring(0, 1).toUpperCase() + attribute.substring(1, attribute.length() - 1);
 							MethodUtils.invokeMethod(configElement, addMethod, value);
 						}
 					} catch (NoSuchMethodException e1) {
 						throw new NoSuchMethodException("Could not find setter function for "+attribute);
 					}
 				}
 			}
 		}
 	}
 	static public String testHostDN = "/DC=com/DC=example/OU=Services/CN=example.site.com";
 	static public Pattern testHostDNPattern = (Pattern) Pattern.compile(testHostDN);
 	static public String testUserDN = "/DC=com/DC=example/OU=People/CN=Example User 12345";
 	static private Logger adminLog = Logger.getLogger(GUMS.gumsAdminLogName);
 	static private Logger log = Logger.getLogger(ConfigurationToolkit.class);
 	static private String schemaPath = null;
 	static private String templateSchemaPath = null;
 	static private String transformDir = null;
 	static String gumsJarPath = null;
 	static public Set<Class<ConfigElement>> userGroupSet = null;
 	static public Set<Class<ConfigElement>> accountMapperSet = null;
 	static public Set<Class<ConfigElement>> groupToAccountSet = null;
 	static public Set<Class<ConfigElement>> hostToGroupSet = null;
 	
 	static {
 		String resourceDir = null;
 		try {
 			resourceDir = CertCache.getResourceDir();
 		} catch (Exception e) {
 			// For testing or command line
 			URL resource = new ConfigurationToolkit().getClass().getClassLoader().getResource("gums.config");
 			if (resource == null) {
 				String temp = System.getProperty("user.dir");
 				if (temp.endsWith("/WEB-INF/scripts"))
 					resourceDir = temp + "/..";
 			}
 
 			if (resource != null)
 				resourceDir = resource.getPath().replace("/gums.config", "");
 		}
 		if (resourceDir != null) {
 			schemaPath = resourceDir + "/gums.config.schema";
 			templateSchemaPath = resourceDir + "/gums.config.template.schema";
 			transformDir = resourceDir + "/";
 		}
 		String[] classPaths = System.getProperty("java.class.path").split(File.pathSeparator);
 		for (int i=0; i<classPaths.length; i++) {
 			if (classPaths[i].contains("gums-core") && classPaths[i].contains(".jar")) {
 				gumsJarPath = classPaths[i];
 				break;
 			}
 		}
 		try {
 			userGroupSet = findClasses(Thread.currentThread().getContextClassLoader(), null, Collections.singleton("gov.bnl.gums.userGroup"), gumsJarPath!=null?Collections.singleton(gumsJarPath):null);
 			userGroupSet.remove(UserGroup.class);
 			accountMapperSet = findClasses(Thread.currentThread().getContextClassLoader(), null, Collections.singleton("gov.bnl.gums.account"), gumsJarPath!=null?Collections.singleton(gumsJarPath):null);
 			accountMapperSet.remove(AccountMapper.class);
 			groupToAccountSet = findClasses(Thread.currentThread().getContextClassLoader(), null, Collections.singleton("gov.bnl.gums.groupToAccount"), gumsJarPath!=null?Collections.singleton(gumsJarPath):null);
 			hostToGroupSet = findClasses(Thread.currentThread().getContextClassLoader(), null, Collections.singleton("gov.bnl.gums.hostToGroup"), gumsJarPath!=null?Collections.singleton(gumsJarPath):null);
 			hostToGroupSet.remove(HostToGroupMapping.class);
 		} catch (ClassNotFoundException e) {
 			log.fatal(e);
 			throw new RuntimeException(e.getMessage());
 		}
 	}
 
 	static public Configuration do1_1_to_1_4Transform(String configText,
 			String transformPath) {
 		try {
 			log.trace("Transforming configuration file using transform '" + transformPath);
 
 			File configFileTemp = File.createTempFile("gums", "config");
 
 			XMLReader reader = XMLReaderFactory.createXMLReader();
 			Source source = new SAXSource(reader, new InputSource(new ByteArrayInputStream(configText.getBytes())));
 
 			StreamResult result = new StreamResult(configFileTemp);
 			Source style = new StreamSource(transformPath);
 
 			TransformerFactory transFactory = TransformerFactory.newInstance();
 			Transformer trans = transFactory.newTransformer(style);
 
 			trans.transform(source, result);
 
 			// Reload it to get rid of duplicates that the transform 
 			// couldn't handle as well as to clean up the formatting
 			Digester digester = ConfigurationToolkit.retrieveDigester();
 			Configuration configuration = new Configuration(true);
 			digester.push(configuration);
 			digester.parse("file://" + configFileTemp.getAbsolutePath());
 
 			configFileTemp.delete();
 
 			// Clean up account mapper names
 			Iterator<String> it = new ArrayList<String>(configuration.getAccountMappers().keySet()).iterator();
 			while (it.hasNext()) {
 				String name = it.next();
 				String origName = new String(name);
 				if (name.indexOf("://") != -1) {
 					name = name.replaceAll(".*://", "");
 					name = name.replaceAll(".*/dc=", "");
 					name = name.replaceAll("dc=", "");
 					name = name.toLowerCase();
 					if (configuration.getAccountMapper(name) != null) {
 						int count = 1;
 						while (configuration.getAccountMapper(name + Integer.toString(count)) != null)
 							count++;
 						name += Integer.toString(count);
 					}
 					AccountMapper accountMapper = configuration.getAccountMapper(origName);
 					if (accountMapper != null) {
 						accountMapper.setName(name);
 						configuration.removeAccountMapper(origName, false);
 						configuration.addAccountMapper(accountMapper);
 						Iterator<GroupToAccountMapping> it2 = configuration.getGroupToAccountMappings().values().iterator();
 						while (it2.hasNext()) {
 							GroupToAccountMapping groupToAccountMapping = it2.next();
 							List<String> accountMappers = StringUtil.toList(groupToAccountMapping.getAccountMappers());
 							Iterator<String> it3 = accountMappers.iterator();
 							int index = 0;
 							while (it3.hasNext()) {
 								String str = it3.next();
 								if (str.equals(origName)) {
 									groupToAccountMapping.removeAccountMapper(index);
 									groupToAccountMapping.addAccountMapper(index, name);
 									it3 = accountMappers.iterator();
 									index = 0;
 								} else
 									index++;
 							}
 						}
 					}
 				}
 			}
 
 			if (configuration.getUserGroup("osg") != null) {
 				// Assume this is OSG template
 				configuration.setSource("OSG");
 				configuration.setIsTemplate(true);
 			}
 
 			return configuration;
 		} catch (Exception e) {
 			String message = "Could not convert older version of gums.config";
 			log.error(message, e);
 			adminLog.error(message);
 			throw new RuntimeException(message);
 		}
 	}
 
 	static public Configuration do1_3_to_1_4Transform(String configText) {
 		try {
 			configText = configText.replaceAll("\n", " ");
 			
 			// Get information from VomsServers
 			Map<String, String> vsMap = new HashMap<String, String>();
 			String vomsServerName = null;
 			String vomsUrl = null;
 			int i = configText.indexOf("<vomsServers", 0) + 1;
 			while (i != -1) {
 				if ((i = configText.indexOf("<vomsServer", i)) != -1) {
 					int j = -1;
 					if ((j = configText.indexOf("name", i)) != -1) {
 						int startingIndex = -1, endingIndex = -1;
 						for (; j < configText.length() && configText.charAt(j) != '\n'; j++) {
 							if (configText.charAt(j) == '\'' || configText.charAt(j) == '"') {
 								startingIndex = j + 1;
 								break;
 							}
 						}
 						j++;
 						for (; j < configText.length() && configText.charAt(j) != '\n'; j++) {
 							if (configText.charAt(j) == '\'' || configText.charAt(j) == '"') {
 								endingIndex = j;
 								break;
 							}
 						}
 						if (startingIndex != -1 && endingIndex != -1)
 							vomsServerName = configText.substring(startingIndex, endingIndex);
 					}
 					if ((j = configText.indexOf("baseUrl", i)) != -1) {
 						int startingIndex = -1, endingIndex = -1;
 						for (; j < configText.length() && configText.charAt(j) != '\n'; j++) {
 							if (configText.charAt(j) == '\'' || configText.charAt(j) == '"') {
 								startingIndex = j + 1;
 								break;
 							}
 						}
 						j++;
 						for (; j < configText.length() && configText.charAt(j) != '\n'; j++) {
 							if (configText.charAt(j) == '\'' || configText.charAt(j) == '"') {
 								endingIndex = j;
 								break;
 							}
 						}
 						if (startingIndex != -1 && endingIndex != -1)
 							vomsUrl = configText.substring(startingIndex, endingIndex);
 					}
 					i++;
 				}
 				if (vomsServerName != null && vomsUrl != null) {
 					vsMap.put(vomsServerName, vomsUrl);
 					vomsServerName = null;
 					vomsUrl = null;
 				}
 			}
 
 			// Get information from VomsUserGroups
 			Map<String, String> ugMap = new HashMap<String, String>();
 			String userGroupName = null;
 			String vomsServer = null;
 			i = configText.indexOf("<vomsUserGroups", 0) + 1;
 			while (i != -1) {
 				if ((i = configText.indexOf("<vomsUserGroup", i)) != -1) {
 					int j = -1;
 					if ((j = configText.indexOf("name", i)) != -1) {
 						int startingIndex = -1, endingIndex = -1;
 						for (; j < configText.length() && configText.charAt(j) != '\n'; j++) {
 							if (configText.charAt(j) == '\'' || configText.charAt(j) == '"') {
 								startingIndex = j + 1;
 								break;
 							}
 						}
 						j++;
 						for (; j < configText.length() && configText.charAt(j) != '\n'; j++) {
 							if (configText.charAt(j) == '\'' || configText.charAt(j) == '"') {
 								endingIndex = j;
 								break;
 							}
 						}
 						if (startingIndex != -1 && endingIndex != -1)
 							userGroupName = configText.substring(startingIndex, endingIndex);
 					}
 					if ((j = configText.indexOf("vomsServer", i)) != -1) {
 						int startingIndex = -1, endingIndex = -1;
 						for (; j < configText.length() && configText.charAt(j) != '\n'; j++) {
 							if (configText.charAt(j) == '\'' || configText.charAt(j) == '"') {
 								startingIndex = j + 1;
 								break;
 							}
 						}
 						j++;
 						for (; j < configText.length() && configText.charAt(j) != '\n'; j++) {
 							if (configText.charAt(j) == '\'' || configText.charAt(j) == '"') {
 								endingIndex = j;
 								break;
 							}
 						}
 						if (startingIndex != -1 && endingIndex != -1)
 							vomsServer = configText.substring(startingIndex, endingIndex);
 					}
 					i++;
 				}
 				if (userGroupName != null && vomsServer != null) {
 					ugMap.put(userGroupName, vomsServer);
 					userGroupName = null;
 					vomsServer = null;
 				}
 			}
 
 			// Get SSL fields from first VomsServer and set in global properties
 			String sslKey = "";
 			Pattern p = Pattern.compile(".*sslKey[\\s]*=[\\s]*['|\"](.*?)['|\"].*");
 			Matcher m = p.matcher(configText);
 			if (m.matches())
 				sslKey = m.group(1);
 			String sslCertfile = "";
 			p = Pattern.compile(".*sslCertfile[\\s]*=[\\s]*['|\"](.*?)['|\"].*");
 			m = p.matcher(configText);
 			if (m.matches())
 				sslCertfile = m.group(1);
 			String sslCaFiles = "";
 			p = Pattern.compile(".*sslCAFiles[\\s]*=[\\s]*['|\"](.*?)['|\"].*");
 			m = p.matcher(configText);
 			if (m.matches())
 				sslCaFiles = m.group(1);
 			String sslKeyPasswd = "";
 			p = Pattern.compile(".*sslKeyPasswd[\\s]*=[\\s]*['|\"](.*?)['|\"].*");
 			m = p.matcher(configText);
 			if (m.matches())
 				sslKeyPasswd = m.group(1);
 
 			// replacements
 			configText = configText.replaceAll("<vomsServers>.*</vomsServers>", "");
 			configText = configText.replaceAll("remainderUrl", "vomsServerUrls");
 			configText = configText.replaceAll("vomsServer=['|\"].*?['|\"]", "");
 			configText = configText.replaceAll("persistenceFactory=['|\"].*?['|\"]", "");
 			configText = configText.replaceAll("<hostToGroupMapping[\\s]", "<certificateHostToGroupMapping");
 
 			// parse
 			Configuration configuration = new Configuration();
 			Digester digester = retrieveDigester();
 			digester.push(configuration);
 			digester.parse(new ByteArrayInputStream(configText.getBytes()));
 
 			// set ssl key stuff extracted earlier
 			configuration.setSslKey(sslKey);
 			configuration.setSslCertfile(sslCertfile);
 			configuration.setSslCAFiles(sslCaFiles);
 			configuration.setSslKeyPasswd(sslKeyPasswd);
 
 			// set voms stuff extracted earlier
 			for (UserGroup u : configuration.getUserGroups().values()) {
 				if (u instanceof VOMSUserGroup) {
 					VOMSUserGroup vug = (VOMSUserGroup) u;
 					String remainderUrl = vug.getVomsServerUrls();
 					String temp = ugMap.get(vug.getName());
 					if (temp != null) {
 						String baseUrl = vsMap.get(temp);
 						vug.setVomsServerUrls(baseUrl + remainderUrl);
 					}
 				}
 			}
 
 			return configuration;
 		} catch (Exception e) {
 			String message = "Could not convert older version of gums.config";
 			log.error(message, e);
 			adminLog.error(message);
 			throw new RuntimeException(message);
 		}
 	}
 
 	public static Set<Class<ConfigElement>> getConfigElementTypes(Class<?> configElementClass) {
 		if (configElementClass.equals(AccountMapper.class))
 			return accountMapperSet;
 		else if (configElementClass.equals(UserGroup.class))
 			return userGroupSet;
 		else if (configElementClass.equals(GroupToAccountMapping.class))
 			return groupToAccountSet;
 		else if (configElementClass.equals(HostToGroupMapping.class))
 			return hostToGroupSet;
 		else
 			assert(false);
 		return null;
 	}
 
 	static public void insertTest(Configuration configuration) {
 		// Add test user to manual user group
 		ManualUserGroup manualUserGroup;
 		UserGroup userGroup = (ManualUserGroup) configuration.getUserGroup("_test");
 		if (userGroup != null && userGroup instanceof ManualUserGroup)
 			manualUserGroup = (ManualUserGroup) userGroup;
 		else {
 			String name = "_test";
 			while (configuration.getUserGroup(name) != null)
 				name = name + "_";
 			manualUserGroup = new ManualUserGroup(configuration, name);
 		}
 		GridUser testUser = new GridUser(testUserDN);
 		if (!manualUserGroup.isMember(testUser))
 			manualUserGroup.addMember(testUser);
 
 		// Add test account mapper
 		ManualAccountMapper manualAccountMapper;
 		AccountMapper accountMapper = configuration.getAccountMapper("_test");
 		if (accountMapper != null && accountMapper instanceof ManualAccountMapper)
 			manualAccountMapper = (ManualAccountMapper) accountMapper;
 		else {
 			String name = "_test";
 			while (configuration.getAccountMapper(name) != null)
 				name = name + "_";
 			manualAccountMapper = new ManualAccountMapper(configuration, name);
 		}
 		if (manualAccountMapper.mapDn(testUser.getDn(), false) == null)
 			manualAccountMapper.createMapping(testUser.getDn(),
 					new SiteUser("test"));
 
 		// Add test groupToAccountMapping
 		GroupToAccountMapping g2AMapping = configuration.getGroupToAccountMapping("_test");
 		if (g2AMapping == null) {
 			g2AMapping = new GroupToAccountMapping(configuration, "_test");
 			g2AMapping.setName("_test");
 		}
 		if (!StringUtil.toList(g2AMapping.getUserGroups()).contains(manualUserGroup.getName()))
 			g2AMapping.addUserGroup(manualUserGroup.getName());
 		if (!StringUtil.toList(g2AMapping.getAccountMappers()).contains(manualAccountMapper.getName()))
 			g2AMapping.addAccountMapper(manualAccountMapper.getName());
 
 		// Add test hostToGroupMapping
 		HostToGroupMapping h2GMapping = configuration.getHostToGroupMapping(testHostDN);
 		if (h2GMapping == null) {
 			h2GMapping = new CertificateHostToGroupMapping(configuration);
 			((CertificateHostToGroupMapping) h2GMapping).setDn(testHostDN);
 		}
 		if (!StringUtil.toList(h2GMapping.getGroupToAccountMappings()).contains(g2AMapping.getName()))
 			h2GMapping.addGroupToAccountMapping(g2AMapping.getName());
 	}
 
 	public static void main(String args[]) {
 		if (args.length != 1) {
 			System.out.println("Must specify arguments: {configuration path}");
 			return;
 		}
 
 		// Disable system error output since getBuilderFactory is outputting a
 		// bunch of information messages to it
 		PrintStream errStreamOriginal = System.err;
 		System.setErr(new PrintStream(new OutputStream() {
 			public void write(int b) {
 			}
 		}));
 		PrintStream outStreamOriginal = System.out;
 		System.setOut(new PrintStream(new OutputStream() {
 			public void write(int b) {
 			}
 		}));
 
 		try {
 			FileInputStream fileInputStream = new FileInputStream(args[0]);
 			try {
 				StringBuffer configBuffer = new StringBuffer();
 				int ch;
 				while ((ch = fileInputStream.read()) != -1)
 					configBuffer.append((char) ch);
 				ConfigurationToolkit.parseConfiguration(
 						configBuffer.toString(), false);
 			} finally {
 				fileInputStream.close();
 			}
 		} catch (Exception e) {
 			System.setErr(errStreamOriginal);
 			System.setOut(outStreamOriginal);
 			System.out.println("Configuration is NOT valid:");
 			System.out.println(e.getMessage());
 			System.exit(1);
 		}
 
 		System.setErr(errStreamOriginal);
 		System.setOut(outStreamOriginal);
 
 		System.out.println("Configuration is valid");
 	}
 
 	/**
 	 * Get the gums.config version for the given file
 	 * 
 	 * @param filename
 	 * @return
 	 * @throws IOException
 	 * @throws SAXException
 	 */
 	public static Configuration metaParse(ByteArrayInputStream inputStream)
 			throws IOException, SAXException {
 		Digester digester = new Digester();
 		digester.setValidating(false);
 		digester.addObjectCreate("gums", Configuration.class);
 		digester.addSetProperties("gums");
 		digester.parse(inputStream);
 		Configuration conf = (Configuration) digester.getRoot();
 		conf.setMetaOnly(true);
 		return conf;
 	}
 
 	/**
 	 * new StringBufferInputStream(configText) Load gums.config
 	 * 
 	 * @param configFile
 	 * @param configText
 	 * @param schemaPath
 	 * @return
 	 * @throws ParserConfigurationException
 	 * @throws IOException
 	 * @throws SAXException
 	 * 
 	 *             Either set configPath or configText
 	 */
 	public static Configuration parseConfiguration(String configText,
 			boolean insertTest) throws ParserConfigurationException,
 			IOException, SAXException, ClassNotFoundException {
 		// Parse if current version, otherwise perform one or more
 		// transforms to get to the right version
 		Configuration configuration = metaParse(new ByteArrayInputStream(
 				configText.getBytes()));
 		boolean isTemplate = configuration.isTemplate();
 		if (!configuration.versionWasSet)
 			configuration.setVersion("1.1");
 		if (configuration.getVersion().startsWith(GUMS.getMajorMinorVersion())) {
 			// Parse normally
 			log.trace("Loading configuration");
 			validate(configText, isTemplate);
 			configuration = new Configuration();
 			Digester digester = retrieveDigester();
 			digester.push(configuration);
 			digester.parse(new ByteArrayInputStream(configText.getBytes()));
 		} else {
 			// Transform
 			if (configuration.getVersion().equals("1.1")) {
 				configuration = do1_1_to_1_4Transform(configuration.isMetaOnly() ? configText : configuration.toXml(), transformDir + "gums.config.transform1_1-1_4");
 				configuration.setSource("OSG");
 			} else if (configuration.getVersion().equals("1.3")) {
 				log.trace("Loading configuration");
 				configuration = do1_3_to_1_4Transform(configuration.isMetaOnly() ? configText : configuration.toXml());
 			} else {
 				String message = "Cannot parse configurations with version '" + configuration.getVersion() + "'";
 				adminLog.error(message);
 				throw new RuntimeException(message);
 			}
 
 			configuration.setVersion(GUMS.getMajorMinorVersion());
 		}
 
 		return configuration;
 	}
 
 	static public Configuration parseConfigurationTemplates(String uris,
 			String tempFile) throws Exception {
 		Configuration conf = null;
 		StringTokenizer st = new StringTokenizer(uris, ",");
 		while (st.hasMoreTokens()) {
 			String uri = st.nextToken().trim();
 			String configText = URIToolkit.parseUri(uri, tempFile);
 			if (conf == null) {
 				conf = parseConfiguration(configText, false);
 				if (!conf.isTemplate())
 					throw new RuntimeException(uri
 							+ " is not a configuration template");
 			} else {
 				Configuration tempConf = parseConfiguration(configText, false);
 				if (!tempConf.isTemplate())
 					throw new RuntimeException(uri
 							+ " is not a configuration template");
 				conf.mergeConfigurationTemplate(tempConf, null, false);
 			}
 		}
 
 		// clean up old temp files
 		if (tempFile != null) {
 			File tempDir = new File(new File(tempFile).getParent());
 			String[] tempFiles = tempDir.list();
 			for (String tfName : tempFiles) {
 				File tf = new File(tfName);
 				Calendar cal = Calendar.getInstance();
 				cal.add(Calendar.HOUR, -1);
 				if (new Date(tf.lastModified()).before(cal.getTime()))
 					tf.delete();
 			}
 		}
 
 		return conf;
 	}
 
 	/**
 	 * @return a Digestor object for parsing gums.config
 	 */
 	public static Digester retrieveDigester() throws ClassNotFoundException,
 			IOException {
 		Digester digester = new Digester();
 		digester.setValidating(false);
 
 		digester.addSetProperties("gums");
 		
 		addRules(digester, userGroupSet, "gums/userGroups", "addUserGroup");
 		addRules(digester, accountMapperSet, "gums/accountMappers", "addAccountMapper");
 		addRules(digester, groupToAccountSet, "gums/groupToAccountMappings", "addGroupToAccountMapping");
 		addRules(digester, hostToGroupSet, "gums/hostToGroupMappings", "addHostToGroupMapping");
 		
 		return digester;
 	}
 
 	/**
 	 * Validate gums.config given a config file and a schema file
 	 * 
 	 * @param configFile
 	 * @param schemaFile
 	 * @throws ParserConfigurationException
 	 * @throws SAXException
 	 * @throws IOException
 	 */
 	public static void validate(String configText, boolean isTemplate)
 			throws ParserConfigurationException, SAXException, IOException {
 		System.setProperty("javax.xml.parsers.DocumentBuilderFactory",
 				"org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");
 		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 		log.trace("DocumentBuilderFactory: " + factory.getClass().getName());
 
 		factory.setNamespaceAware(true);
 		factory.setValidating(true);
 		factory.setAttribute(
 				"http://java.sun.com/xml/jaxp/properties/schemaLanguage",
 				"http://www.w3.org/2001/XMLSchema");
 		if (isTemplate)
 			factory.setAttribute(
 					"http://java.sun.com/xml/jaxp/properties/schemaSource",
 					"file:" + templateSchemaPath);
 		else
 			factory.setAttribute(
 					"http://java.sun.com/xml/jaxp/properties/schemaSource",
 					"file:" + schemaPath);
 
 		DocumentBuilder builder = factory.newDocumentBuilder();
 		SimpleErrorHandler errorHandler = new ConfigurationToolkit().new SimpleErrorHandler();
 		builder.setErrorHandler(errorHandler);
 
 		builder.parse(new ByteArrayInputStream(configText.getBytes()));
 
 		if (errorHandler.error != null)
 			throw new ParserConfigurationException(errorHandler.error);
 	}
 	
 	@SuppressWarnings("unchecked")
 	protected static void addRules(Digester digester, Set<Class<ConfigElement>> configElementMap, String xmlGroup, String addMethodName) throws ClassNotFoundException, IOException {
 		for (Class c: configElementMap) {
 			char[] xmlElementName = c.getSimpleName().replace("VOMS", "voms").replace("LDAP", "ldap").toCharArray();
 			xmlElementName[0] = Character.toLowerCase(xmlElementName[0]);
 			String xmlPattern = xmlGroup + "/" + new String(xmlElementName);
 			digester.addObjectCreate(xmlPattern, c);
 			digester.addRule(xmlPattern, new ConfElementRule());
 			digester.addSetNext(xmlPattern, addMethodName, c.getName());
 		}
 	}
 
 	/**
 	   * Searches the classpath for all classes matching a specified search criteria, 
 	   * returning them in a map keyed with the interfaces they implement or null if they
 	   * have no interfaces. The search criteria can be specified via interface, package
 	   * and jar name filter arguments
 	   * <p>
 	   * @param classLoader       The classloader whose classpath will be traversed
 	   * @param interfaceFilter   A Set of fully qualified interface names to search for
 	   *                          or null to return classes implementing all interfaces
 	   * @param packageFilter     A Set of fully qualified package names to search for or
 	   *                          or null to return classes in all packages
 	   * @param jarFilter         A Set of jar file names to search for or null to return
 	   *                          classes from all jars
 	   * @return A Map of a Set of Classes keyed to their interface names
 	   *
 	   * @throws ClassNotFoundException if the current thread's classloader cannot load
 	   *                                a requested class for any reason
 	   */
 	@SuppressWarnings("unchecked")
 	protected static Set<Class<ConfigElement>> findClasses(ClassLoader classLoader,
 			Set<String> interfaceFilter, Set<String> packageFilter,
 			Set<String> jarFilter) throws ClassNotFoundException {
 		Map<String, Set<Class<ConfigElement>>> classTable = new HashMap();
 		Object[] classPaths;
 		try {
 			// get a list of all classpaths
 			classPaths = ((java.net.URLClassLoader) classLoader).getURLs();
 			if (classPaths.length<=1)
 				// somethings wrong with the class load so get it from properties
 				classPaths = System.getProperty("java.class.path", "").split(File.pathSeparator);
 		} catch (ClassCastException cce) {
 			// or cast failed; tokenize the system classpath
 			classPaths = System.getProperty("java.class.path", "").split(File.pathSeparator);
 		}
 
 		for (int h = 0; h < classPaths.length; h++) {
 			Enumeration files = null;
 			JarFile module = null;
 			// for each classpath ...
 			File classPath = new File((URL.class).isInstance(classPaths[h]) ? ((URL) classPaths[h]).getFile() : classPaths[h].toString());
 			if (classPath.isDirectory() && jarFilter == null) { 
 				List<String> dirListing = new ArrayList();
 				// get a recursive listing of this classpath
 				recursivelyListDir(dirListing, classPath, new StringBuffer());
 				// an enumeration wrapping our list of files
 				files = Collections.enumeration(dirListing);
 			} else if (classPath.getName().endsWith(".jar")) { 
 				// skip any jars not list in the filter
 				if (jarFilter != null && !jarFilter.contains(classPath.getName())) {
 					continue;
 				}
 				try {
 					// if our resource is a jar, instantiate a jarfile using the
 					// full path to resource
 					module = new JarFile(classPath);
 				} catch (MalformedURLException mue) {
 					throw new ClassNotFoundException("Bad classpath. Error: "
 							+ mue.getMessage());
 				} catch (IOException io) {
 					throw new ClassNotFoundException(
 							"jar file '"
 							+ classPath.getName()
 							+ "' could not be instantiate from file path. Error: "
 							+ io.getMessage());
 				}
 				// get an enumeration of the files in this jar
 				files = module.entries();
 			}
 			
 			// for each file path in our directory or jar
 			while (files != null && files.hasMoreElements()) {
 				// get each fileName
 				String fileName = files.nextElement().toString();
 				// we only want the class files
 				if (fileName.endsWith(".class")) {
 					// convert our full filename to a fully qualified class name
 					String className = fileName.replaceAll("/", ".").substring(0, fileName.length() - 6);
 					// debug class list
 					// System.out.println(className);
 					// skip any classes in packages not explicitly requested in
 					// our package filter
 					if (packageFilter != null && !packageFilter.contains(className.substring(0, className.lastIndexOf(".")))) {
 						continue;
 					}
 					// get the class for our class name
 					Class theClass = null;
 					try {
 						theClass = Class.forName(className, false, classLoader);
 					} catch (NoClassDefFoundError e) {
 						log.trace("Skipping class '" + className + "' for reason " + e.getMessage());
 						continue;
 					}
 					// skip interfaces
 					if (theClass.isInterface()) {
 						continue;
 					}
 					// then get an array of all the interfaces in our class
 					Class[] classInterfaces = theClass.getInterfaces();
 
 					// for each interface in this class, add both class and
 					// interface into the map
 					String interfaceName = null;
 					for (int i = 0; i < classInterfaces.length
 							|| (i == 0 && interfaceFilter == null); i++) {
 						if (i < classInterfaces.length) {
 							interfaceName = classInterfaces[i].getName();
 							// was this interface requested?
 							if (interfaceFilter != null
 									&& !interfaceFilter.contains(interfaceName)) {
 								continue;
 							}
 						}
 						// is this interface already in the map?
 						if (classTable.containsKey(interfaceName)) {
 							// if so then just add this class to the end of the
 							// list of classes implementing this interface
 							classTable.get(interfaceName).add(theClass);
 						} else {
 							// else create a new list initialised with our first
 							// class and put the list into the map
 							Set<Class<ConfigElement>> allClasses = new HashSet();
 							allClasses.add(theClass);
 							classTable.put(interfaceName, allClasses);
 						}
 					}
 
 				}
 			}
 
 			// close the jar if it was used
 			if (module != null) {
 				try {
 					module.close();
 				} catch (IOException ioe) {
 					throw new ClassNotFoundException("The module jar file '"
 							+ classPath.getName()
 							+ "' could not be closed. Error: "
 							+ ioe.getMessage());
 				}
 			}
 
 		} // end for loop
 
 		return classTable.values().iterator().next();
 	} // end method
 
 	/**
 	 * Recursively lists a directory while generating relative paths. This is a
 	 * helper function for findClasses. Note: Uses a StringBuffer to avoid the
 	 * excessive overhead of multiple String concatentation
 	 * 
 	 * @param dirListing
 	 *            A list variable for storing the directory listing as a list of
 	 *            Strings
 	 * @param dir
 	 *            A File for the directory to be listed
 	 * @param relativePath
 	 *            A StringBuffer used for building the relative paths
 	 */
 	protected static void recursivelyListDir(List<String> dirListing, File dir,
 			StringBuffer relativePath) {
 		int prevLen; // used to undo append operations to the StringBuffer
 
 		// if the dir is really a directory
 		if (dir.isDirectory()) {
 			// get a list of the files in this directory
 			File[] files = dir.listFiles();
 			// for each file in the present dir
 			for (int i = 0; i < files.length; i++) {
 				// store our original relative path string length
 				prevLen = relativePath.length();
 				// call this function recursively with file list from present
 				// dir and relateveto appended with present dir
 				recursivelyListDir(dirListing, files[i], relativePath.append(
 						prevLen == 0 ? "" : "/").append(files[i].getName()));
 				// delete subdirectory previously appended to our relative path
 				relativePath.delete(prevLen, relativePath.length());
 			}
 		} else {
 			// this dir is a file; append it to the relativeto path and add it
 			// to the directory listing
 			dirListing.add(relativePath.toString());
 		}
 	}
 
 }