Java tutorial
/* * Licensed under the EUPL, Version 1.1 or as soon they will be approved by * the European Commission - subsequent versions of the EUPL (the "Licence"); * You may not use this work except in compliance with the Licence. You may * obtain a copy of the Licence at: * * http://www.osor.eu/eupl/european-union-public-licence-eupl-v.1.1 * * Unless required by applicable law or agreed to in writing, software * distributed under the Licence is distributed on an "AS IS" basis, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * Licence for the specific language governing permissions and limitations under * the Licence. */ package eu.stork.peps.configuration; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.util.HashMap; import java.util.Map; import javax.xml.XMLConstants; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NodeList; import org.xml.sax.SAXException; import eu.stork.peps.exceptions.SAMLEngineException; import eu.stork.peps.exceptions.STORKSAMLEngineRuntimeException; /** * The Class ConfigurationReader. * * @author fjquevedo */ public final class ConfigurationReader { /** The Constant SAML_ENGINE_CONFIGURATION_FILE. */ private static final String ENGINE_CONF_FILE = "SamlEngine.xml"; /** The Constant LOGGER. */ private static final Logger LOGGER = LoggerFactory.getLogger(ConfigurationReader.class.getName()); /** The Constant NODE_CONFIGURATION. */ private static final String NODE_CONF = "configuration"; /** The Constant NODE_CONFIGURATION_NAME. */ private static final String NODE_CONF_NAME = "name"; /** The Constant NODE_INSTANCE_NAME. */ private static final String NODE_INST_NAME = "name"; /** The Constant NODE_INSTANCE. */ private static final String NODE_INSTANCE = "instance"; /** The Constant NODE_CONFIGURATION_NAME. */ private static final String NODE_PARAM_NAME = "name"; /** The Constant NODE_CONFIGURATION_NAME. */ private static final String NODE_PARAM_VALUE = "value"; /** The Constant NODE_CONFIGURATION_NAME. */ private static final String NODE_PARAMETER = "parameter"; /** * Generate parameters. * * @param configurationNode the configuration node * * @return the map< string, string> */ private static Map<String, String> generateParam(final Element configurationNode) { final HashMap<String, String> parameters = new HashMap<String, String>(); final NodeList parameterNodes = configurationNode.getElementsByTagName(NODE_PARAMETER); String parameterName; String parameterValue; for (int k = 0; k < parameterNodes.getLength(); ++k) { // for every parameter find, process. final Element parameterNode = (Element) parameterNodes.item(k); parameterName = parameterNode.getAttribute(NODE_PARAM_NAME); parameterValue = parameterNode.getAttribute(NODE_PARAM_VALUE); // verified the content. if (StringUtils.isBlank(parameterName) || StringUtils.isBlank(parameterValue)) { throw new STORKSAMLEngineRuntimeException("Error reader parameters (name - value)."); } else { parameters.put(parameterName.trim(), parameterValue.trim()); } } return parameters; } /** * Read configuration. * * @return the map< string, instance engine> * * @throws SAMLEngineException the STORKSAML engine runtime * exception */ public static Map<String, InstanceEngine> readConfiguration() throws SAMLEngineException { // fetch base from system properties, give a default if there is nothing configured String base = System.getProperty("eu.stork.samlengine.config.location"); if (null != base) if (!base.endsWith("/")) base += "/"; LOGGER.info("Init reader: " + base + ENGINE_CONF_FILE); final Map<String, InstanceEngine> instanceConfs = new HashMap<String, InstanceEngine>(); Document document = null; // Load configuration file final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder; InputStream engineConf = null; try { factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); builder = factory.newDocumentBuilder(); if (null != base) engineConf = new FileInputStream(base + ENGINE_CONF_FILE); else engineConf = ConfigurationReader.class.getResourceAsStream("/" + ENGINE_CONF_FILE); document = builder.parse(engineConf); // Read instance final NodeList list = document.getElementsByTagName(NODE_INSTANCE); for (int indexElem = 0; indexElem < list.getLength(); ++indexElem) { final Element element = (Element) list.item(indexElem); final InstanceEngine instanceConf = new InstanceEngine(); // read every configuration. final String instanceName = element.getAttribute(NODE_INST_NAME); if (StringUtils.isBlank(instanceName)) { throw new STORKSAMLEngineRuntimeException("Error reader instance name."); } instanceConf.setName(instanceName.trim()); final NodeList confNodes = element.getElementsByTagName(NODE_CONF); for (int indexNode = 0; indexNode < confNodes.getLength(); ++indexNode) { final Element configurationNode = (Element) confNodes.item(indexNode); final String configurationName = configurationNode.getAttribute(NODE_CONF_NAME); if (StringUtils.isBlank(configurationName)) { throw new STORKSAMLEngineRuntimeException("Error reader configuration name."); } final ConfigurationEngine confSamlEngine = new ConfigurationEngine(); // Set configuration name. confSamlEngine.setName(configurationName.trim()); // Read every parameter for this configuration. final Map<String, String> parameters = generateParam(configurationNode); // Set parameters confSamlEngine.setParameters(parameters); // Add parameters to the configuration. instanceConf.getConfiguration().add(confSamlEngine); } // Add to the list of configurations. instanceConfs.put(element.getAttribute(NODE_INST_NAME), instanceConf); } } catch (SAXException e) { LOGGER.error("Error: init library parser."); throw new SAMLEngineException(e); } catch (ParserConfigurationException e) { LOGGER.error("Error: parser configuration file xml."); throw new SAMLEngineException(e); } catch (IOException e) { LOGGER.error("Error: read configuration file."); throw new SAMLEngineException(e); } finally { IOUtils.closeQuietly(engineConf); } return instanceConfs; } /** * Instantiates a new configuration reader. */ private ConfigurationReader() { } }