1 files changed, 50 insertions, 44 deletions

diff --git a/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/AggregateConfiguration.java b/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/AggregateConfiguration.java
index e81d82bf7d..07c81e5f5b 100644
--- a/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/AggregateConfiguration.java
+++ b/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/AggregateConfiguration.java
@@ -19,14 +19,17 @@ package org.onap.config.impl;
 import static org.onap.config.Constants.LOAD_ORDER_KEY;
 
 import java.io.File;
+import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import org.apache.commons.configuration2.CombinedConfiguration;
 import org.apache.commons.configuration2.Configuration;
+import org.apache.commons.configuration2.ex.ConfigurationException;
 import org.apache.commons.configuration2.tree.MergeCombiner;
 import org.apache.commons.configuration2.tree.OverrideCombiner;
 import org.apache.commons.configuration2.tree.UnionCombiner;
@@ -40,61 +43,61 @@ public final class AggregateConfiguration {
     private final Map<String, Configuration> mergeConfig = Collections.synchronizedMap(new HashMap<>());
     private final Map<String, Configuration> overrideConfig = Collections.synchronizedMap(new LinkedHashMap<>());
 
-    public void addConfig(File file) throws Exception {
-        addConfig(file.getAbsolutePath().toUpperCase(), ConfigurationUtils.getMergeStrategy(file),
-                ConfigurationUtils.getConfigurationBuilder(file, false).getConfiguration());
+    public void addConfig(File file) throws ConfigurationException {
+        addConfig(fileToUrl(file), ConfigurationUtils.getMergeStrategy(file),
+                ConfigurationUtils.getConfigurationBuilder(file).getConfiguration());
     }
 
-    private void addConfig(String path, ConfigurationMode configMode, Configuration config) {
+    public void addConfig(URL url) throws ConfigurationException {
+        addConfig(url, ConfigurationUtils.getMergeStrategy(url),
+                ConfigurationUtils.getConfigurationBuilder(url).getConfiguration());
+    }
+
+    private void addConfig(URL url, ConfigurationMode configMode, Configuration config) {
+
+        String normalizedUrl = normalize(url);
         if (configMode != null) {
             switch (configMode) {
                 case MERGE:
-                    mergeConfig.put(path, config);
+                    mergeConfig.put(normalizedUrl, config);
                     break;
                 case OVERRIDE:
-                    overrideConfig.put(path, config);
+                    overrideConfig.put(normalizedUrl, config);
                     break;
                 case UNION:
-                    unionConfig.put(path, config);
+                    unionConfig.put(normalizedUrl, config);
                     break;
                 default:
             }
         } else {
-            rootConfig.put(path, config);
+            rootConfig.put(normalizedUrl, config);
         }
     }
 
-    public void addConfig(URL url) throws Exception {
-        addConfig(url.getFile().toUpperCase(), ConfigurationUtils.getMergeStrategy(url),
-                ConfigurationUtils.getConfigurationBuilder(url).getConfiguration());
+    private String normalize(URL url) {
+        // what about Linux where paths are case sensitive?
+        return  url.toString().toUpperCase();
     }
 
-    public void removeConfig(File file) {
-        String key = file.getAbsolutePath().toUpperCase();
-        if (rootConfig.containsKey(key)) {
-            rootConfig.remove(key);
-        } else if (mergeConfig.containsKey(key)) {
-            mergeConfig.remove(key);
-        } else if (unionConfig.containsKey(key)) {
-            unionConfig.remove(key);
-        } else if (overrideConfig.containsKey(key)) {
-            overrideConfig.remove(key);
-        }
-    }
+    private URL fileToUrl(File file) {
 
-    public boolean containsConfig(File file) {
-        String key = file.getAbsolutePath().toUpperCase();
-        return rootConfig.containsKey(key) || mergeConfig.containsKey(key) || unionConfig.containsKey(key)
-                       || overrideConfig.containsKey(key);
+        try {
+            return  file.getAbsoluteFile().toURI().toURL();
+        } catch (MalformedURLException e) {
+            throw new IllegalStateException("URL produced by JDK and is not expected to be malformed. File: "
+                                                    + file.getAbsoluteFile());
+        }
     }
 
     public Configuration getFinalConfiguration() {
+
         CombinedConfiguration ccRoot = new CombinedConfiguration(new MergeCombiner());
         ArrayList<Configuration> tempList = new ArrayList<>(rootConfig.values());
         tempList.sort(this::sortForMerge);
         for (Configuration conf : tempList) {
             ccRoot.addConfiguration(conf);
         }
+
         CombinedConfiguration ccMergeRoot = new CombinedConfiguration(new MergeCombiner());
         ccMergeRoot.addConfiguration(ccRoot);
         tempList = new ArrayList<>(mergeConfig.values());
@@ -102,11 +105,13 @@ public final class AggregateConfiguration {
         for (Configuration conf : tempList) {
             ccMergeRoot.addConfiguration(conf);
         }
+
         CombinedConfiguration ccUnionRoot = new CombinedConfiguration(new UnionCombiner());
         ccUnionRoot.addConfiguration(ccMergeRoot);
         for (Configuration conf : unionConfig.values()) {
             ccUnionRoot.addConfiguration(conf);
         }
+
         ArrayList<Configuration> tempOverrideConfigs = new ArrayList<>(overrideConfig.values());
         Collections.reverse(tempOverrideConfigs);
         tempOverrideConfigs.sort(this::sortForOverride);
@@ -114,31 +119,32 @@ public final class AggregateConfiguration {
         for (Configuration conf : tempOverrideConfigs) {
             ccOverrideRoot.addConfiguration(conf);
         }
+
         ccOverrideRoot.addConfiguration(ccUnionRoot);
         return ccOverrideRoot;
     }
 
     private int sortForOverride(Configuration conf1, Configuration conf2) {
-        String order1 = conf1.getString(LOAD_ORDER_KEY);
-        String order2 = conf2.getString(LOAD_ORDER_KEY);
-        if (ConfigurationUtils.isBlank(order1) || !order1.trim().matches("\\d+")) {
-            order1 = "0";
-        }
-        if (ConfigurationUtils.isBlank(order2) || !order2.trim().matches("\\d+")) {
-            order2 = "0";
-        }
-        return Integer.parseInt(order2.trim()) - Integer.parseInt(order1.trim());
+        return sort(conf1, conf2, (o1, o2) -> o2 - o1);
     }
 
     private int sortForMerge(Configuration conf1, Configuration conf2) {
-        String order1 = conf1.getString(LOAD_ORDER_KEY);
-        String order2 = conf2.getString(LOAD_ORDER_KEY);
-        if (ConfigurationUtils.isBlank(order1) || !order1.trim().matches("\\d+")) {
-            order1 = "0";
-        }
-        if (ConfigurationUtils.isBlank(order2) || !order2.trim().matches("\\d+")) {
-            order2 = "0";
+        return sort(conf1, conf2, (o1, o2) -> o1 - o2);
+    }
+
+    private int sort(Configuration conf1, Configuration conf2, Comparator<Integer> comparator) {
+        int order1 = readLoadOrder(conf1);
+        int order2 = readLoadOrder(conf2);
+        return comparator.compare(order1, order2);
+    }
+
+    private int readLoadOrder(Configuration conf) {
+
+        String order = conf.getString(LOAD_ORDER_KEY);
+        if (ConfigurationUtils.isBlank(order) || !order.trim().matches("\\d+")) {
+            return 0;
         }
-        return Integer.parseInt(order1.trim()) - Integer.parseInt(order2.trim());
+
+        return Integer.parseInt(order.trim());
     }
 }