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

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