common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/AggregateConfiguration.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.config.impl;
  18
  19 import static org.onap.config.Constants.LOAD_ORDER_KEY;
  20
  21 import java.io.File;
  22 import java.net.URL;
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.HashMap;
  26 import java.util.LinkedHashMap;
  27 import java.util.Map;
  28 import org.apache.commons.configuration2.CombinedConfiguration;
  29 import org.apache.commons.configuration2.Configuration;
  30 import org.apache.commons.configuration2.tree.MergeCombiner;
  31 import org.apache.commons.configuration2.tree.OverrideCombiner;
  32 import org.apache.commons.configuration2.tree.UnionCombiner;
  33 import org.onap.config.ConfigurationUtils;
  34 import org.onap.config.type.ConfigurationMode;
  35
  36 public final class AggregateConfiguration {
  37
  38     private final Map<String, Configuration> rootConfig = new HashMap<>();
  39     private final Map<String, Configuration> unionConfig = new HashMap<>();
  40     private final Map<String, Configuration> mergeConfig = new HashMap<>();
  41     private final Map<String, Configuration> overrideConfig = new LinkedHashMap<>();
  42
  43     public void addConfig(File file) throws Exception {
  44         addConfig(file.getAbsolutePath().toUpperCase(), ConfigurationUtils.getMergeStrategy(file),
  45                 ConfigurationUtils.getConfigurationBuilder(file, false).getConfiguration());
  46     }
  47
  48     private void addConfig(String path, ConfigurationMode configMode, Configuration config) {
  49         if (configMode != null) {
  50             switch (configMode) {
  51                 case MERGE:
  52                     mergeConfig.put(path, config);
  53                     break;
  54                 case OVERRIDE:
  55                     overrideConfig.put(path, config);
  56                     break;
  57                 case UNION:
  58                     unionConfig.put(path, config);
  59                     break;
  60                 default:
  61             }
  62         } else {
  63             rootConfig.put(path, config);
  64         }
  65     }
  66
  67     public void addConfig(URL url) throws Exception {
  68         addConfig(url.getFile().toUpperCase(), ConfigurationUtils.getMergeStrategy(url),
  69                 ConfigurationUtils.getConfigurationBuilder(url).getConfiguration());
  70     }
  71
  72     public void removeConfig(File file) {
  73         String key = file.getAbsolutePath().toUpperCase();
  74         if (rootConfig.containsKey(key)) {
  75             rootConfig.remove(key);
  76         } else if (mergeConfig.containsKey(key)) {
  77             mergeConfig.remove(key);
  78         } else if (unionConfig.containsKey(key)) {
  79             unionConfig.remove(key);
  80         } else if (overrideConfig.containsKey(key)) {
  81             overrideConfig.remove(key);
  82         }
  83     }
  84
  85     public boolean containsConfig(File file) {
  86         String key = file.getAbsolutePath().toUpperCase();
  87         return rootConfig.containsKey(key) || mergeConfig.containsKey(key) || unionConfig.containsKey(key)
  88                        || overrideConfig.containsKey(key);
  89     }
  90
  91     public Configuration getFinalConfiguration() {
  92         CombinedConfiguration ccRoot = new CombinedConfiguration(new MergeCombiner());
  93         ArrayList<Configuration> tempList = new ArrayList<>(rootConfig.values());
  94         tempList.sort(this::sortForMerge);
  95         for (Configuration conf : tempList) {
  96             ccRoot.addConfiguration(conf);
  97         }
  98         CombinedConfiguration ccMergeRoot = new CombinedConfiguration(new MergeCombiner());
  99         ccMergeRoot.addConfiguration(ccRoot);
 100         tempList = new ArrayList<>(mergeConfig.values());
 101         tempList.sort(this::sortForMerge);
 102         for (Configuration conf : tempList) {
 103             ccMergeRoot.addConfiguration(conf);
 104         }
 105         CombinedConfiguration ccUnionRoot = new CombinedConfiguration(new UnionCombiner());
 106         ccUnionRoot.addConfiguration(ccMergeRoot);
 107         for (Configuration conf : unionConfig.values()) {
 108             ccUnionRoot.addConfiguration(conf);
 109         }
 110         ArrayList<Configuration> tempOverrideConfigs = new ArrayList<>(overrideConfig.values());
 111         Collections.reverse(tempOverrideConfigs);
 112         tempOverrideConfigs.sort(this::sortForOverride);
 113         CombinedConfiguration ccOverrideRoot = new CombinedConfiguration(new OverrideCombiner());
 114         for (Configuration conf : tempOverrideConfigs) {
 115             ccOverrideRoot.addConfiguration(conf);
 116         }
 117         ccOverrideRoot.addConfiguration(ccUnionRoot);
 118         return ccOverrideRoot;
 119     }
 120
 121     private int sortForOverride(Configuration conf1, Configuration conf2) {
 122         String order1 = conf1.getString(LOAD_ORDER_KEY);
 123         String order2 = conf2.getString(LOAD_ORDER_KEY);
 124         if (ConfigurationUtils.isBlank(order1) || !order1.trim().matches("\\d+")) {
 125             order1 = "0";
 126         }
 127         if (ConfigurationUtils.isBlank(order2) || !order2.trim().matches("\\d+")) {
 128             order2 = "0";
 129         }
 130         return Integer.parseInt(order2.trim()) - Integer.parseInt(order1.trim());
 131     }
 132
 133     private int sortForMerge(Configuration conf1, Configuration conf2) {
 134         String order1 = conf1.getString(LOAD_ORDER_KEY);
 135         String order2 = conf2.getString(LOAD_ORDER_KEY);
 136         if (ConfigurationUtils.isBlank(order1) || !order1.trim().matches("\\d+")) {
 137             order1 = "0";
 138         }
 139         if (ConfigurationUtils.isBlank(order2) || !order2.trim().matches("\\d+")) {
 140             order2 = "0";
 141         }
 142         return Integer.parseInt(order1.trim()) - Integer.parseInt(order2.trim());
 143     }
 144 }