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