1 files changed, 234 insertions, 0 deletions
diff --git a/id/server/stork2-saml-engine/src/main/java/eu/stork/peps/configuration/ConfigurationReader.java b/id/server/stork2-saml-engine/src/main/java/eu/stork/peps/configuration/ConfigurationReader.java
new file mode 100644
index 000000000..7968c77ff
--- /dev/null
+++ b/id/server/stork2-saml-engine/src/main/java/eu/stork/peps/configuration/ConfigurationReader.java
@@ -0,0 +1,234 @@
+/* 
+ * 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() {
+
+    }
+
+}