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

   1 package org.onap.config.impl;
   2
   3 import org.apache.commons.configuration2.CombinedConfiguration;
   4 import org.apache.commons.configuration2.Configuration;
   5 import org.apache.commons.configuration2.tree.MergeCombiner;
   6 import org.apache.commons.configuration2.tree.OverrideCombiner;
   7 import org.apache.commons.configuration2.tree.UnionCombiner;
   8 import org.onap.config.ConfigurationUtils;
   9 import org.onap.config.type.ConfigurationMode;
  10
  11 import java.io.File;
  12 import java.net.URL;
  13 import java.util.HashMap;
  14 import java.util.*;
  15
  16 import static org.onap.config.Constants.LOAD_ORDER_KEY;
  17
  18 /**
  19  * The type Aggregate configuration.
  20  */
  21 public final class AggregateConfiguration {
  22
  23   private Map<String, Configuration> rootConfig = new HashMap<>();
  24   private Map<String, Configuration> unionConfig = new HashMap<>();
  25   private Map<String, Configuration> mergeConfig = new HashMap<>();
  26   private Map<String, Configuration> overrideConfig = new LinkedHashMap<>();
  27
  28   /**
  29    * Instantiates a new Aggregate configuration.
  30    */
  31   public AggregateConfiguration() {
  32     try {
  33       Class clazz = Class.forName(Thread.currentThread().getStackTrace()[2].getClassName());
  34       if (!clazz.getCanonicalName()
  35           .equals(ConfigurationImpl.class.getCanonicalName())) {
  36         throw new RuntimeException("Illegal access.");
  37       }
  38     } catch (ClassNotFoundException cfe) {
  39       throw new RuntimeException("Class not found while loading change notifier");
  40     }
  41   }
  42
  43   private void addConfig(String path, ConfigurationMode configMode, Configuration config) {
  44     if (configMode != null) {
  45       switch (configMode) {
  46         case MERGE:
  47           mergeConfig.put(path, config);
  48           break;
  49         case OVERRIDE:
  50           overrideConfig.put(path, config);
  51           break;
  52         case UNION:
  53           unionConfig.put(path, config);
  54           break;
  55         default:
  56       }
  57     } else {
  58       rootConfig.put(path, config);
  59     }
  60   }
  61
  62   /**
  63    * Add config.
  64    *
  65    * @param file the file
  66    * @throws Exception the exception
  67    */
  68   public void addConfig(File file) throws Exception {
  69     addConfig(file.getAbsolutePath().toUpperCase(), ConfigurationUtils.getMergeStrategy(file),
  70         ConfigurationUtils.getConfigurationBuilder(file, false).getConfiguration());
  71   }
  72
  73   /**
  74    * Add config.
  75    *
  76    * @param url the url
  77    * @throws Exception the exception
  78    */
  79   public void addConfig(URL url) throws Exception {
  80     addConfig(url.getFile().toUpperCase(), ConfigurationUtils.getMergeStrategy(url),
  81         ConfigurationUtils.getConfigurationBuilder(url).getConfiguration());
  82   }
  83
  84   /**
  85    * Remove config.
  86    *
  87    * @param file the file
  88    */
  89   public void removeConfig(File file) {
  90     String key = file.getAbsolutePath().toUpperCase();
  91     if (rootConfig.containsKey(key)) {
  92       rootConfig.remove(key);
  93     } else if (mergeConfig.containsKey(key)) {
  94       mergeConfig.remove(key);
  95     } else if (unionConfig.containsKey(key)) {
  96       unionConfig.remove(key);
  97     } else if (overrideConfig.containsKey(key)) {
  98       overrideConfig.remove(key);
  99     }
 100   }
 101
 102   /**
 103    * Contains config boolean.
 104    *
 105    * @param file the file
 106    * @return the boolean
 107    */
 108   public boolean containsConfig(File file) {
 109     String key = file.getAbsolutePath().toUpperCase();
 110     return rootConfig.containsKey(key) || mergeConfig.containsKey(key)
 111         || unionConfig.containsKey(key) || overrideConfig.containsKey(key);
 112   }
 113
 114   /**
 115    * Gets final configuration.
 116    *
 117    * @return the final configuration
 118    */
 119   public Configuration getFinalConfiguration() {
 120     CombinedConfiguration ccRoot = new CombinedConfiguration(new MergeCombiner());
 121     ArrayList<Configuration> tempList = new ArrayList<>(rootConfig.values());
 122     Collections.sort(tempList, this::sortForMerge);
 123     for (Configuration conf : tempList) {
 124       ccRoot.addConfiguration(conf);
 125     }
 126     CombinedConfiguration ccMergeRoot = new CombinedConfiguration(new MergeCombiner());
 127     ccMergeRoot.addConfiguration(ccRoot);
 128     tempList = new ArrayList<>(mergeConfig.values());
 129     Collections.sort(tempList, this::sortForMerge);
 130     for (Configuration conf : tempList) {
 131       ccMergeRoot.addConfiguration(conf);
 132     }
 133     CombinedConfiguration ccUnionRoot = new CombinedConfiguration(new UnionCombiner());
 134     ccUnionRoot.addConfiguration(ccMergeRoot);
 135     for (Configuration conf : unionConfig.values()) {
 136       ccUnionRoot.addConfiguration(conf);
 137     }
 138     ArrayList<Configuration> tempOverrideConfigs = new ArrayList<>(overrideConfig.values());
 139     Collections.reverse(tempOverrideConfigs);
 140     Collections.sort(tempOverrideConfigs, this::sortForOverride);
 141     CombinedConfiguration ccOverrideRoot = new CombinedConfiguration(new OverrideCombiner());
 142     for (Configuration conf : tempOverrideConfigs) {
 143       ccOverrideRoot.addConfiguration(conf);
 144     }
 145     ccOverrideRoot.addConfiguration(ccUnionRoot);
 146     return ccOverrideRoot;
 147   }
 148
 149   private int sortForOverride(Configuration conf1, Configuration conf2){
 150     String order1 = conf1.getString(LOAD_ORDER_KEY);
 151     String order2 = conf2.getString(LOAD_ORDER_KEY);
 152     if (ConfigurationUtils.isBlank(order1) || !order1.trim().matches("\\d+")){
 153       order1 = "0";
 154     }
 155     if (ConfigurationUtils.isBlank(order2) || !order2.trim().matches("\\d+")){
 156       order2 = "0";
 157     }
 158     return Integer.parseInt(order2.trim())-Integer.parseInt(order1.trim());
 159   }
 160
 161   private int sortForMerge(Configuration conf1, Configuration conf2){
 162     String order1 = conf1.getString(LOAD_ORDER_KEY);
 163     String order2 = conf2.getString(LOAD_ORDER_KEY);
 164     if (ConfigurationUtils.isBlank(order1) || !order1.trim().matches("\\d+")){
 165       order1 = "0";
 166     }
 167     if (ConfigurationUtils.isBlank(order2) || !order2.trim().matches("\\d+")){
 168       order2 = "0";
 169     }
 170     return Integer.parseInt(order1.trim())-Integer.parseInt(order2.trim());
 171   }
 172
 173 }