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

   1 package org.openecomp.config;
   2
   3 import static org.openecomp.config.api.Hint.EXTERNAL_LOOKUP;
   4 import static org.openecomp.config.api.Hint.LATEST_LOOKUP;
   5 import static org.openecomp.config.api.Hint.NODE_SPECIFIC;
   6
   7 import com.virtlink.commons.configuration2.jackson.JsonConfiguration;
   8 import net.sf.corn.cps.CPScanner;
   9 import net.sf.corn.cps.ResourceFilter;
  10 import org.apache.commons.configuration2.CompositeConfiguration;
  11 import org.apache.commons.configuration2.Configuration;
  12 import org.apache.commons.configuration2.FileBasedConfiguration;
  13 import org.apache.commons.configuration2.PropertiesConfiguration;
  14 import org.apache.commons.configuration2.XMLConfiguration;
  15 import org.apache.commons.configuration2.builder.BasicConfigurationBuilder;
  16 import org.apache.commons.configuration2.builder.ReloadingFileBasedConfigurationBuilder;
  17 import org.apache.commons.configuration2.builder.fluent.Configurations;
  18 import org.apache.commons.configuration2.builder.fluent.Parameters;
  19 import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
  20 import org.apache.commons.configuration2.ex.ConfigurationException;
  21 import org.apache.commons.io.IOUtils;
  22 import org.openecomp.config.api.ConfigurationManager;
  23 import org.openecomp.config.impl.AgglomerateConfiguration;
  24 import org.openecomp.config.impl.ConfigurationDataSource;
  25 import org.openecomp.config.impl.ConfigurationRepository;
  26 import org.openecomp.config.impl.YamlConfiguration;
  27 import org.openecomp.config.type.ConfigurationMode;
  28 import org.openecomp.config.type.ConfigurationType;
  29
  30 import java.io.File;
  31 import java.lang.reflect.Field;
  32 import java.lang.reflect.ParameterizedType;
  33 import java.lang.reflect.Type;
  34 import java.net.URL;
  35 import java.nio.file.Files;
  36 import java.nio.file.Path;
  37 import java.sql.Connection;
  38 import java.sql.PreparedStatement;
  39 import java.sql.ResultSet;
  40 import java.sql.Statement;
  41 import java.util.ArrayDeque;
  42 import java.util.ArrayList;
  43 import java.util.Arrays;
  44 import java.util.Collection;
  45 import java.util.Deque;
  46 import java.util.HashMap;
  47 import java.util.HashSet;
  48 import java.util.Iterator;
  49 import java.util.LinkedHashMap;
  50 import java.util.List;
  51 import java.util.Map;
  52 import java.util.Queue;
  53 import java.util.Set;
  54 import java.util.SortedSet;
  55 import java.util.Stack;
  56 import java.util.TreeSet;
  57 import java.util.concurrent.BlockingQueue;
  58 import java.util.concurrent.ConcurrentLinkedQueue;
  59 import java.util.concurrent.Executors;
  60 import java.util.concurrent.LinkedBlockingQueue;
  61 import java.util.concurrent.LinkedTransferQueue;
  62 import java.util.concurrent.ScheduledExecutorService;
  63 import java.util.concurrent.ThreadFactory;
  64 import java.util.concurrent.TransferQueue;
  65 import java.util.regex.Matcher;
  66 import java.util.regex.Pattern;
  67 import javax.sql.DataSource;
  68
  69 /**
  70  * The type Configuration utils.
  71  */
  72 public class ConfigurationUtils {
  73
  74   /**
  75    * Gets scheduled executor service.
  76    *
  77    * @return the scheduled executor service
  78    */
  79   public static ScheduledExecutorService getScheduledExecutorService() {
  80     return Executors.newScheduledThreadPool(1, (r1) -> {
  81       Thread thread = Executors.privilegedThreadFactory().newThread(r1);
  82       thread.setDaemon(true);
  83       return thread;
  84     });
  85   }
  86
  87   /**
  88    * Gets thread factory.
  89    *
  90    * @return the thread factory
  91    */
  92   public static ThreadFactory getThreadFactory() {
  93     return (r1) -> {
  94       Thread thread = Executors.privilegedThreadFactory().newThread(r1);
  95       thread.setDaemon(true);
  96       return thread;
  97     };
  98   }
  99
 100   /**
 101    * Gets all files.
 102    *
 103    * @param file          the file
 104    * @param recursive     the recursive
 105    * @param onlyDirectory the only directory
 106    * @return the all files
 107    */
 108   public static Collection<File> getAllFiles(File file, boolean recursive, boolean onlyDirectory) {
 109     ArrayList<File> collection = new ArrayList<>();
 110     if (file.isDirectory() && file.exists()) {
 111       File[] files = file.listFiles();
 112       for (File innerFile : files) {
 113         if (innerFile.isFile() && !onlyDirectory) {
 114           collection.add(innerFile);
 115         } else if (innerFile.isDirectory()) {
 116           collection.add(innerFile);
 117           if (recursive) {
 118             collection.addAll(getAllFiles(innerFile, recursive, onlyDirectory));
 119           }
 120         }
 121       }
 122     }
 123     return collection;
 124   }
 125
 126   /**
 127    * Gets comma saperated list.
 128    *
 129    * @param list the list
 130    * @return the comma saperated list
 131    */
 132   public static String getCommaSaperatedList(List list) {
 133     String toReturn = "";
 134
 135     for (Object obj : list) {
 136       if (!toReturn.trim().isEmpty()) {
 137         toReturn += ",";
 138       }
 139       toReturn += obj;
 140     }
 141
 142     return toReturn;
 143   }
 144
 145   /**
 146    * Gets comma saperated list.
 147    *
 148    * @param list the list
 149    * @return the comma saperated list
 150    */
 151   public static String getCommaSaperatedList(String[] list) {
 152     return getCommaSaperatedList(list == null ? Arrays.asList() : Arrays.asList(list));
 153   }
 154
 155   /**
 156    * Gets config type.
 157    *
 158    * @param url the url
 159    * @return the config type
 160    */
 161   public static ConfigurationType getConfigType(URL url) {
 162     return Enum.valueOf(ConfigurationType.class,
 163         url.getFile().substring(url.getFile().lastIndexOf('.') + 1).toUpperCase());
 164   }
 165
 166   /**
 167    * Gets config type.
 168    *
 169    * @param file the file
 170    * @return the config type
 171    */
 172   public static ConfigurationType getConfigType(File file) {
 173     return Enum.valueOf(ConfigurationType.class,
 174         file.getAbsolutePath().substring(file.getAbsolutePath().lastIndexOf('.') + 1)
 175             .toUpperCase());
 176   }
 177
 178   /**
 179    * Is config boolean.
 180    *
 181    * @param url the url
 182    * @return the boolean
 183    */
 184   public static boolean isConfig(URL url) {
 185     return isConfig(url.getFile());
 186   }
 187
 188   /**
 189    * Is config boolean.
 190    *
 191    * @param file the file
 192    * @return the boolean
 193    */
 194   public static boolean isConfig(File file) {
 195     return file != null && file.exists() && isConfig(file.getName());
 196   }
 197
 198   /**
 199    * Is config boolean.
 200    *
 201    * @param file the file
 202    * @return the boolean
 203    */
 204   public static boolean isConfig(String file) {
 205     file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
 206     file = file.substring(file.lastIndexOf('/') + 1);
 207     return file.matches(
 208         "CONFIG(-\\w*){0,1}(-" + "(" + ConfigurationMode.OVERRIDE + "|" + ConfigurationMode.MERGE
 209             + "|" + ConfigurationMode.UNION + ")){0,1}" + "\\.("
 210             + ConfigurationType.PROPERTIES.name() + "|" + ConfigurationType.XML.name() + "|"
 211             + ConfigurationType.JSON.name() + "|" + ConfigurationType.YAML.name() + ")$")
 212         || file.matches("CONFIG(.)*\\.(" + ConfigurationType.PROPERTIES.name() + "|"
 213             + ConfigurationType.XML.name() + "|" + ConfigurationType.JSON.name() + "|"
 214             + ConfigurationType.YAML.name() + ")$");
 215   }
 216
 217   /**
 218    * Gets namespace.
 219    *
 220    * @param url the url
 221    * @return the namespace
 222    */
 223   public static String getNamespace(URL url) {
 224     String namespace = getNamespace(getConfiguration(url));
 225     if (namespace != null) {
 226       return namespace.toUpperCase();
 227     }
 228     return getNamespace(url.getFile().toUpperCase());
 229   }
 230
 231   /**
 232    * Gets namespace.
 233    *
 234    * @param file the file
 235    * @return the namespace
 236    */
 237   public static String getNamespace(File file) {
 238     String namespace = getNamespace(getConfiguration(file));
 239     if (namespace != null) {
 240       return namespace.toUpperCase();
 241     }
 242     return getNamespace(file.getName().toUpperCase());
 243   }
 244
 245   private static String getNamespace(Configuration config) {
 246     return config.getString(Constants.NAMESPACE_KEY) == null ? null
 247         : config.getString(Constants.NAMESPACE_KEY).toUpperCase();
 248   }
 249
 250   /**
 251    * Gets namespace.
 252    *
 253    * @param file the file
 254    * @return the namespace
 255    */
 256   public static String getNamespace(String file) {
 257     file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
 258     file = file.substring(file.lastIndexOf('/') + 1);
 259     Pattern pattern = Pattern.compile(
 260         "CONFIG(-\\w*){0,1}(-" + "(" + ConfigurationMode.OVERRIDE + "|" + ConfigurationMode.MERGE
 261             + "|" + ConfigurationMode.UNION + ")){0,1}" + "\\.("
 262             + ConfigurationType.PROPERTIES.name() + "|" + ConfigurationType.XML.name() + "|"
 263             + ConfigurationType.JSON.name() + "|" + ConfigurationType.YAML.name() + ")$");
 264     Matcher matcher = pattern.matcher(file);
 265     boolean b1 = matcher.matches();
 266     if (b1) {
 267       if (matcher.group(1) != null) {
 268         String moduleName = matcher.group(1).substring(1);
 269         return moduleName.equalsIgnoreCase(ConfigurationMode.OVERRIDE.name())
 270             || moduleName.equalsIgnoreCase(ConfigurationMode.UNION.name())
 271             || moduleName.equalsIgnoreCase(ConfigurationMode.MERGE.name())
 272             ? Constants.DEFAULT_NAMESPACE : moduleName;
 273       } else {
 274         return Constants.DEFAULT_NAMESPACE;
 275       }
 276     } else if (isConfig(file)) {
 277       return Constants.DEFAULT_NAMESPACE;
 278     }
 279
 280     return null;
 281   }
 282
 283   /**
 284    * Gets merge strategy.
 285    *
 286    * @param url the url
 287    * @return the merge strategy
 288    */
 289   public static ConfigurationMode getMergeStrategy(URL url) {
 290     String configMode = getMergeStrategy(getConfiguration(url));
 291     if (configMode != null) {
 292       try {
 293         return Enum.valueOf(ConfigurationMode.class, configMode);
 294       } catch (Exception exception) {
 295         //do nothing
 296       }
 297     }
 298     return getMergeStrategy(url.getFile().toUpperCase());
 299   }
 300
 301   private static String getMergeStrategy(Configuration config) {
 302     return config.getString(Constants.MODE_KEY) == null ? null
 303         : config.getString(Constants.MODE_KEY).toUpperCase();
 304   }
 305
 306   /**
 307    * Gets merge strategy.
 308    *
 309    * @param file the file
 310    * @return the merge strategy
 311    */
 312   public static ConfigurationMode getMergeStrategy(File file) {
 313     String configMode = getMergeStrategy(getConfiguration(file));
 314     if (configMode != null) {
 315       try {
 316         return Enum.valueOf(ConfigurationMode.class, configMode);
 317       } catch (Exception exception) {
 318         //do nothing
 319       }
 320     }
 321     return getMergeStrategy(file.getName().toUpperCase());
 322   }
 323
 324   /**
 325    * Gets merge strategy.
 326    *
 327    * @param file the file
 328    * @return the merge strategy
 329    */
 330   public static ConfigurationMode getMergeStrategy(String file) {
 331     file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
 332     file = file.substring(file.lastIndexOf('/') + 1);
 333     Pattern pattern = Pattern.compile(
 334         "CONFIG(-\\w*){0,1}(-" + "(" + ConfigurationMode.OVERRIDE + "|" + ConfigurationMode.MERGE
 335             + "|" + ConfigurationMode.UNION + ")){0,1}" + "\\.("
 336             + ConfigurationType.PROPERTIES.name() + "|" + ConfigurationType.XML.name() + "|"
 337             + ConfigurationType.JSON.name() + "|" + ConfigurationType.YAML.name() + ")$");
 338     Matcher matcher = pattern.matcher(file);
 339     boolean b1 = matcher.matches();
 340     if (b1) {
 341       for (int i = 1; i <= matcher.groupCount(); i++) {
 342         String modeName = matcher.group(i);
 343         if (modeName != null) {
 344           modeName = modeName.substring(1);
 345         }
 346         try {
 347           return Enum.valueOf(ConfigurationMode.class, modeName);
 348         } catch (Exception exception) {
 349           //do nothing
 350         }
 351       }
 352     }
 353
 354     return null;
 355   }
 356
 357   /**
 358    * Gets configuration.
 359    *
 360    * @param url the url
 361    * @return the configuration
 362    */
 363   public static FileBasedConfiguration getConfiguration(URL url) {
 364     FileBasedConfiguration builder = null;
 365     try {
 366       switch (ConfigurationUtils.getConfigType(url)) {
 367         case PROPERTIES:
 368           builder = new Configurations().fileBased(PropertiesConfiguration.class, url);
 369           break;
 370         case XML:
 371           builder = new Configurations().fileBased(XMLConfiguration.class, url);
 372           break;
 373         case JSON:
 374           builder = new Configurations().fileBased(JsonConfiguration.class, url);
 375           break;
 376         case YAML:
 377           builder = new Configurations().fileBased(YamlConfiguration.class, url);
 378           break;
 379         default:
 380       }
 381     } catch (ConfigurationException exception) {
 382       exception.printStackTrace();
 383     }
 384     return builder;
 385   }
 386
 387   /**
 388    * Gets configuration.
 389    *
 390    * @param url the url
 391    * @return the configuration
 392    */
 393   public static FileBasedConfiguration getConfiguration(File url) {
 394     FileBasedConfiguration builder = null;
 395     try {
 396       switch (ConfigurationUtils.getConfigType(url)) {
 397         case PROPERTIES:
 398           builder = new Configurations().fileBased(PropertiesConfiguration.class, url);
 399           break;
 400         case XML:
 401           builder = new Configurations().fileBased(XMLConfiguration.class, url);
 402           break;
 403         case JSON:
 404           builder = new Configurations().fileBased(JsonConfiguration.class, url);
 405           break;
 406         case YAML:
 407           builder = new Configurations().fileBased(YamlConfiguration.class, url);
 408           break;
 409         default:
 410       }
 411     } catch (ConfigurationException exception) {
 412       exception.printStackTrace();
 413     }
 414     return builder;
 415   }
 416
 417   /**
 418    * Gets collection generic type.
 419    *
 420    * @param field the field
 421    * @return the collection generic type
 422    */
 423   public static Class getCollectionGenericType(Field field) {
 424     Type type = field.getGenericType();
 425
 426     if (type instanceof ParameterizedType) {
 427
 428       ParameterizedType paramType = (ParameterizedType) type;
 429       Type[] arr = paramType.getActualTypeArguments();
 430
 431       for (Type tp : arr) {
 432         Class<?> clzz = (Class<?>) tp;
 433         if (isWrapperClass(clzz)) {
 434           return clzz;
 435         } else {
 436           throw new RuntimeException("Collection of type " + clzz.getName() + " not supported.");
 437         }
 438       }
 439     }
 440     return String[].class;
 441   }
 442
 443   /**
 444    * Gets array class.
 445    *
 446    * @param clazz the clazz
 447    * @return the array class
 448    */
 449   public static Class getArrayClass(Class clazz) {
 450     switch (clazz.getName()) {
 451       case "java.lang.Byte":
 452         return Byte[].class;
 453       case "java.lang.Short":
 454         return Short[].class;
 455       case "java.lang.Integer":
 456         return Integer[].class;
 457       case "java.lang.Long":
 458         return Long[].class;
 459       case "java.lang.Float":
 460         return Float[].class;
 461       case "java.lang.Double":
 462         return Double[].class;
 463       case "java.lang.Boolean":
 464         return Boolean[].class;
 465       case "java.lang.Character":
 466         return Character[].class;
 467       case "java.lang.String":
 468         return String[].class;
 469       default:
 470     }
 471     return null;
 472   }
 473
 474   /**
 475    * Gets all class path resources.
 476    *
 477    * @return the all class path resources
 478    */
 479   public static List<URL> getAllClassPathResources() {
 480     return CPScanner.scanResources(new ResourceFilter());
 481   }
 482
 483   /**
 484    * Execute ddlsql boolean.
 485    *
 486    * @param sql the sql
 487    * @return the boolean
 488    * @throws Exception the exception
 489    */
 490   public static boolean executeDdlSql(String sql) throws Exception {
 491     DataSource datasource = ConfigurationDataSource.lookup();
 492     try (Connection con = datasource.getConnection(); Statement stmt = con.createStatement()) {
 493       stmt.executeQuery(sql);
 494     } catch (Exception exception) {
 495       System.err.println("Datasource initialization error. Configuration management will be using in-memory persistence.");
 496       return false;
 497     }
 498     return true;
 499   }
 500
 501   /**
 502    * Gets configuration builder.
 503    *
 504    * @param url the url
 505    * @return the configuration builder
 506    */
 507   public static BasicConfigurationBuilder<FileBasedConfiguration> getConfigurationBuilder(URL url) {
 508     ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration> builder = null;
 509     switch (ConfigurationUtils.getConfigType(url)) {
 510       case PROPERTIES:
 511         builder = new ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration>(
 512             PropertiesConfiguration.class);
 513         break;
 514       case XML:
 515         builder = new ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration>(
 516             XMLConfiguration.class);
 517         break;
 518       case JSON:
 519         builder = new ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration>(
 520             JsonConfiguration.class);
 521         break;
 522       case YAML:
 523         builder = new ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration>(
 524             YamlConfiguration.class);
 525         break;
 526       default:
 527     }
 528     builder.configure(new Parameters().fileBased().setURL(url)
 529         .setListDelimiterHandler(new DefaultListDelimiterHandler(',')));
 530     return builder;
 531   }
 532
 533   /**
 534    * Gets configuration builder.
 535    *
 536    * @param file     the file
 537    * @param autoSave the auto save
 538    * @return the configuration builder
 539    */
 540   public static BasicConfigurationBuilder<FileBasedConfiguration> getConfigurationBuilder(File file,
 541                                                                                 boolean autoSave) {
 542     ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration> builder = null;
 543     switch (ConfigurationUtils.getConfigType(file)) {
 544       case PROPERTIES:
 545         builder = new ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration>(
 546             PropertiesConfiguration.class);
 547         break;
 548       case XML:
 549         builder = new ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration>(
 550             XMLConfiguration.class);
 551         break;
 552       case JSON:
 553         builder = new ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration>(
 554             JsonConfiguration.class);
 555         break;
 556       case YAML:
 557         builder = new ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration>(
 558             YamlConfiguration.class);
 559         break;
 560       default:
 561     }
 562     builder.configure(new Parameters().fileBased().setFile(file)
 563         .setListDelimiterHandler(new DefaultListDelimiterHandler(',')));
 564     builder.setAutoSave(autoSave);
 565     return builder;
 566   }
 567
 568
 569   /**
 570    * Execute select sql collection.
 571    *
 572    * @param sql    the sql
 573    * @param params the params
 574    * @return the collection
 575    * @throws Exception the exception
 576    */
 577   public static Collection<String> executeSelectSql(String sql, String[] params) throws Exception {
 578     Collection<String> coll = new ArrayList<>();
 579     DataSource datasource = ConfigurationDataSource.lookup();
 580     try (Connection con = datasource.getConnection();
 581          PreparedStatement stmt = con.prepareStatement(sql)) {
 582       if (params != null) {
 583         for (int i = 0; i < params.length; i++) {
 584           stmt.setString(i + 1, params[i]);
 585         }
 586       }
 587       ResultSet rs = stmt.executeQuery();
 588       while (rs.next()) {
 589         coll.add(rs.getString(1));
 590       }
 591     } catch (Exception exception) {
 592       //exception.printStackTrace();
 593       return null;
 594     }
 595     return coll;
 596   }
 597
 598   /**
 599    * Execute insert sql boolean.
 600    *
 601    * @param sql    the sql
 602    * @param params the params
 603    * @return the boolean
 604    * @throws Exception the exception
 605    */
 606   public static boolean executeInsertSql(String sql, Object[] params) throws Exception {
 607     Collection<String> coll = new ArrayList<>();
 608     DataSource datasource = ConfigurationDataSource.lookup();
 609     try (Connection con = datasource.getConnection();
 610          PreparedStatement stmt = con.prepareStatement(sql)) {
 611       if (params != null) {
 612         int counter = 0;
 613         for (Object obj : params) {
 614           if (obj == null) {
 615             obj = "";
 616           }
 617           switch (obj.getClass().getName()) {
 618             case "java.lang.String":
 619               stmt.setString(++counter, obj.toString());
 620               break;
 621             case "java.lang.Integer":
 622               stmt.setInt(++counter, ((Integer) obj).intValue());
 623               break;
 624             case "java.lang.Long":
 625               stmt.setLong(++counter, ((Long) obj).longValue());
 626               break;
 627             default:
 628               stmt.setString(++counter, obj.toString());
 629               break;
 630           }
 631         }
 632       }
 633       stmt.executeUpdate();
 634       return true;
 635     } catch (Exception exception) {
 636       exception.printStackTrace();
 637     }
 638     return false;
 639   }
 640
 641   /**
 642    * Read t.
 643    *
 644    * @param <T>       the type parameter
 645    * @param config    the config
 646    * @param clazz     the clazz
 647    * @param keyPrefix the key prefix
 648    * @return the t
 649    * @throws Exception the exception
 650    */
 651   public static <T> T read(Configuration config, Class<T> clazz, String keyPrefix)
 652       throws Exception {
 653     org.openecomp.config.api.Config confAnnot =
 654         clazz.getAnnotation(org.openecomp.config.api.Config.class);
 655     if (confAnnot != null) {
 656       keyPrefix += (confAnnot.key() + ".");
 657     }
 658     T objToReturn = clazz.newInstance();
 659     for (Field field : clazz.getDeclaredFields()) {
 660       org.openecomp.config.api.Config fieldConfAnnot =
 661           field.getAnnotation(org.openecomp.config.api.Config.class);
 662       if (fieldConfAnnot != null) {
 663         field.setAccessible(true);
 664         field.set(objToReturn, config.getProperty(keyPrefix + fieldConfAnnot.key()));
 665       } else if (field.getType().getAnnotation(org.openecomp.config.api.Config.class) != null) {
 666         field.set(objToReturn, read(config, field.getType(), keyPrefix));
 667       }
 668     }
 669     return objToReturn;
 670   }
 671
 672   /**
 673    * Gets db configuration builder.
 674    *
 675    * @param configName the config name
 676    * @return the db configuration builder
 677    * @throws Exception the exception
 678    */
 679   public static BasicConfigurationBuilder<AgglomerateConfiguration> getDbConfigurationBuilder(
 680       String configName) throws Exception {
 681     Configuration dbConfig = ConfigurationRepository.lookup()
 682         .getConfigurationFor(Constants.DEFAULT_TENANT, Constants.DB_NAMESPACE);
 683     BasicConfigurationBuilder<AgglomerateConfiguration> builder =
 684         new BasicConfigurationBuilder<AgglomerateConfiguration>(AgglomerateConfiguration.class);
 685     builder.configure(
 686         new Parameters().database()
 687             .setDataSource(ConfigurationDataSource.lookup())
 688             .setTable(dbConfig.getString("config.Table"))
 689             .setKeyColumn(dbConfig.getString("configKey"))
 690             .setValueColumn(dbConfig.getString("configValue"))
 691             .setConfigurationNameColumn(dbConfig.getString("configNameColumn"))
 692             .setConfigurationName(configName)
 693             .setAutoCommit(true)
 694     );
 695     return builder;
 696   }
 697
 698   /**
 699    * Gets property.
 700    *
 701    * @param config          the config
 702    * @param key             the key
 703    * @param processingHints the processing hints
 704    * @return the property
 705    */
 706   public static Object getProperty(Configuration config, String key, int processingHints) {
 707     if (!isDirectLookup(processingHints)) {
 708       if (config instanceof AgglomerateConfiguration) {
 709         return ((AgglomerateConfiguration) config).getPropertyValue(key);
 710       } else if (config instanceof CompositeConfiguration) {
 711         CompositeConfiguration conf = (CompositeConfiguration) config;
 712         for (int i = 0; i < conf.getNumberOfConfigurations(); i++) {
 713           if (conf.getConfiguration(i) instanceof AgglomerateConfiguration) {
 714             return ((AgglomerateConfiguration) conf.getConfiguration(i)).getPropertyValue(key);
 715           } else if (isNodeSpecific(processingHints)) {
 716             Object obj = conf.getConfiguration(i).getProperty(key);
 717             if (obj != null) {
 718               return obj;
 719             }
 720           }
 721         }
 722       }
 723     }
 724     return config.getProperty(key);
 725   }
 726
 727   /**
 728    * Gets primitive array.
 729    *
 730    * @param collection the collection
 731    * @param clazz      the clazz
 732    * @return the primitive array
 733    */
 734   public static Object getPrimitiveArray(Collection collection, Class clazz) {
 735
 736     if (clazz == int.class) {
 737       int[] array = new int[collection.size()];
 738       Object[] objArray = collection.toArray();
 739       for (int i = 0; i < collection.size(); i++) {
 740         array[i] = (int) objArray[i];
 741       }
 742       return array;
 743     }
 744     if (clazz == byte.class) {
 745       byte[] array = new byte[collection.size()];
 746       Object[] objArray = collection.toArray();
 747       for (int i = 0; i < collection.size(); i++) {
 748         array[i] = (byte) objArray[i];
 749       }
 750       return array;
 751     }
 752     if (clazz == short.class) {
 753       short[] array = new short[collection.size()];
 754       Object[] objArray = collection.toArray();
 755       for (int i = 0; i < collection.size(); i++) {
 756         array[i] = (short) objArray[i];
 757       }
 758       return array;
 759     }
 760     if (clazz == long.class) {
 761       long[] array = new long[collection.size()];
 762       Object[] objArray = collection.toArray();
 763       for (int i = 0; i < collection.size(); i++) {
 764         array[i] = (long) objArray[i];
 765       }
 766       return array;
 767     }
 768     if (clazz == float.class) {
 769       float[] array = new float[collection.size()];
 770       Object[] objArray = collection.toArray();
 771       for (int i = 0; i < collection.size(); i++) {
 772         array[i] = (float) objArray[i];
 773       }
 774       return array;
 775     }
 776     if (clazz == double.class) {
 777       double[] array = new double[collection.size()];
 778       Object[] objArray = collection.toArray();
 779       for (int i = 0; i < collection.size(); i++) {
 780         array[i] = (double) objArray[i];
 781       }
 782       return array;
 783     }
 784     if (clazz == boolean.class) {
 785       boolean[] array = new boolean[collection.size()];
 786       Object[] objArray = collection.toArray();
 787       for (int i = 0; i < collection.size(); i++) {
 788         array[i] = (boolean) objArray[i];
 789       }
 790       return array;
 791     }
 792     Object obj = null;
 793     return obj;
 794   }
 795
 796   /**
 797    * Is wrapper class boolean.
 798    *
 799    * @param clazz the clazz
 800    * @return the boolean
 801    */
 802   public static boolean isWrapperClass(Class clazz) {
 803     return clazz == String.class || clazz == Boolean.class || clazz == Character.class
 804         || Number.class.isAssignableFrom(clazz);
 805   }
 806
 807   /**
 808    * Gets collection string.
 809    *
 810    * @param input the input
 811    * @return the collection string
 812    */
 813   public static String getCollectionString(String input) {
 814     Pattern pattern = Pattern.compile("^\\[(.*)\\]$");
 815     Matcher matcher = pattern.matcher(input);
 816     if (matcher.matches()) {
 817       input = matcher.group(1);
 818     }
 819     return input;
 820   }
 821
 822   /**
 823    * Is collection boolean.
 824    *
 825    * @param input the input
 826    * @return the boolean
 827    */
 828   public static boolean isCollection(String input) {
 829     Pattern pattern = Pattern.compile("^\\[(.*)\\]$");
 830     Matcher matcher = pattern.matcher(input);
 831     return matcher.matches();
 832   }
 833
 834   /**
 835    * Process variables if present string.
 836    *
 837    * @param tenant    the tenant
 838    * @param namespace the namespace
 839    * @param data      the data
 840    * @return the string
 841    */
 842   public static String processVariablesIfPresent(String tenant, String namespace, String data) {
 843     Pattern pattern = Pattern.compile("^.*\\$\\{(.*)\\}.*");
 844     Matcher matcher = pattern.matcher(data);
 845     if (matcher.matches()) {
 846       String key = matcher.group(1);
 847       if (key.toUpperCase().startsWith("ENV:")) {
 848         String envValue = System.getenv(key.substring(4));
 849         return processVariablesIfPresent(tenant, namespace, data.replaceAll("\\$\\{" + key + "\\}",
 850             envValue == null ? "" : envValue.replace("\\", "\\\\")));
 851       } else if (key.toUpperCase().startsWith("SYS:")) {
 852         String sysValue = System.getProperty(key.substring(4));
 853         return processVariablesIfPresent(tenant, namespace, data.replaceAll("\\$\\{" + key + "\\}",
 854             sysValue == null ? "" : sysValue.replace("\\", "\\\\")));
 855       } else {
 856         String propertyValue = ConfigurationUtils.getCollectionString(
 857             ConfigurationManager.lookup().getAsStringValues(tenant, namespace, key).toString());
 858         return processVariablesIfPresent(tenant, namespace, data.replaceAll("\\$\\{" + key + "\\}",
 859             propertyValue == null ? "" : propertyValue.replace("\\", "\\\\")));
 860       }
 861     } else {
 862       return data;
 863     }
 864   }
 865
 866   /**
 867    * Gets file contents.
 868    *
 869    * @param path the path
 870    * @return the file contents
 871    */
 872   public static String getFileContents(String path) {
 873     try {
 874       if (path != null) {
 875         return IOUtils.toString(new URL(path));
 876       }
 877     } catch (Exception exception) {
 878       exception.printStackTrace();
 879     }
 880     return null;
 881   }
 882
 883   /**
 884    * Gets file contents.
 885    *
 886    * @param path the path
 887    * @return the file contents
 888    */
 889   public static String getFileContents(Path path) {
 890     try {
 891       if (path != null) {
 892         return new String(Files.readAllBytes(path));
 893       }
 894     } catch (Exception exception) {
 895       exception.printStackTrace();
 896     }
 897     return null;
 898   }
 899
 900   /**
 901    * Gets concrete collection.
 902    *
 903    * @param clazz the clazz
 904    * @return the concrete collection
 905    */
 906   public static Collection getConcreteCollection(Class clazz) {
 907     Collection collection = null;
 908
 909     switch (clazz.getName()) {
 910       case "java.util.Collection":
 911       case "java.util.List":
 912         return new ArrayList<>();
 913       case "java.util.Set":
 914         return new HashSet<>();
 915       case "java.util.SortedSet":
 916         return new TreeSet<>();
 917       case "java.util.Queue":
 918         return new ConcurrentLinkedQueue<>();
 919       case "java.util.Deque":
 920         return new ArrayDeque<>();
 921       case "java.util.concurrent.TransferQueue":
 922         return new LinkedTransferQueue<>();
 923       case "java.util.concurrent.BlockingQueue":
 924         return new LinkedBlockingQueue<>();
 925       default:
 926     }
 927
 928     return collection;
 929   }
 930
 931   /**
 932    * Gets default for.
 933    *
 934    * @param clazz the clazz
 935    * @return the default for
 936    */
 937   public static Object getDefaultFor(Class clazz) {
 938     if (byte.class == clazz) {
 939       return new Byte("0");
 940     } else if (short.class == clazz) {
 941       return new Short("0");
 942     } else if (int.class == clazz) {
 943       return new Integer("0");
 944     } else if (float.class == clazz) {
 945       return new Float("0");
 946     } else if (long.class == clazz) {
 947       return new Long("0");
 948     } else if (double.class == clazz) {
 949       return new Double("0");
 950     } else if (boolean.class == clazz) {
 951       return Boolean.FALSE;
 952     }
 953     return new Character((char) 0);
 954   }
 955
 956   /**
 957    * Gets compatible collection for abstract def.
 958    *
 959    * @param clazz the clazz
 960    * @return the compatible collection for abstract def
 961    */
 962   public static Collection getCompatibleCollectionForAbstractDef(Class clazz) {
 963     if (BlockingQueue.class.isAssignableFrom(clazz)) {
 964       return getConcreteCollection(BlockingQueue.class);
 965     }
 966     if (TransferQueue.class.isAssignableFrom(clazz)) {
 967       return getConcreteCollection(TransferQueue.class);
 968     }
 969     if (Deque.class.isAssignableFrom(clazz)) {
 970       return getConcreteCollection(Deque.class);
 971     }
 972     if (Queue.class.isAssignableFrom(clazz)) {
 973       return getConcreteCollection(Queue.class);
 974     }
 975     if (SortedSet.class.isAssignableFrom(clazz)) {
 976       return getConcreteCollection(SortedSet.class);
 977     }
 978     if (Set.class.isAssignableFrom(clazz)) {
 979       return getConcreteCollection(Set.class);
 980     }
 981     if (List.class.isAssignableFrom(clazz)) {
 982       return getConcreteCollection(List.class);
 983     }
 984     return null;
 985   }
 986
 987   /**
 988    * Gets configuration repository key.
 989    *
 990    * @param array the array
 991    * @return the configuration repository key
 992    */
 993   public static String getConfigurationRepositoryKey(String[] array) {
 994     Stack<String> stack = new Stack<>();
 995     stack.push(Constants.DEFAULT_TENANT);
 996     for (String element : array) {
 997       stack.push(element);
 998     }
 999     String toReturn = stack.pop();
1000     return stack.pop() + Constants.KEY_ELEMENTS_DELEMETER + toReturn;
1001   }
1002
1003   /**
1004    * Gets configuration repository key.
1005    *
1006    * @param file the file
1007    * @return the configuration repository key
1008    */
1009   public static String getConfigurationRepositoryKey(File file) {
1010     return getConfigurationRepositoryKey(
1011         ConfigurationUtils.getNamespace(file).split(Constants.TENANT_NAMESPACE_SAPERATOR));
1012   }
1013
1014   /**
1015    * Gets configuration repository key.
1016    *
1017    * @param url the url
1018    * @return the configuration repository key
1019    */
1020   public static String getConfigurationRepositoryKey(URL url) {
1021     return getConfigurationRepositoryKey(
1022         ConfigurationUtils.getNamespace(url).split(Constants.TENANT_NAMESPACE_SAPERATOR));
1023   }
1024
1025   /**
1026    * To map linked hash map.
1027    *
1028    * @param config the config
1029    * @return the linked hash map
1030    */
1031   public static LinkedHashMap toMap(Configuration config) {
1032     Iterator<String> iterator = config.getKeys();
1033     LinkedHashMap<String, String> map = new LinkedHashMap<>();
1034     while (iterator.hasNext()) {
1035       String key = iterator.next();
1036       if (!(key.equals(Constants.MODE_KEY) || key.equals(Constants.NAMESPACE_KEY)
1037           || key.equals(Constants.LOAD_ORDER_KEY))) {
1038         map.put(key, config.getProperty(key).toString());
1039       }
1040     }
1041
1042     return map;
1043   }
1044
1045   /**
1046    * Diff map.
1047    *
1048    * @param orig   the orig
1049    * @param latest the latest
1050    * @return the map
1051    */
1052   public static Map diff(LinkedHashMap orig, LinkedHashMap latest) {
1053     orig = new LinkedHashMap<>(orig);
1054     latest = new LinkedHashMap<>(latest);
1055     List<String> set = new ArrayList(orig.keySet());
1056     for (String key : set) {
1057       if (latest.remove(key, orig.get(key))) {
1058         orig.remove(key);
1059       }
1060     }
1061     Set<String> keys = latest.keySet();
1062     for (String key : keys) {
1063       orig.remove(key);
1064     }
1065     set = new ArrayList(orig.keySet());
1066     for (String key : set) {
1067       latest.put(key, "");
1068     }
1069     return new HashMap<>(latest);
1070   }
1071
1072   /**
1073    * Is array boolean.
1074    *
1075    * @param tenant          the tenant
1076    * @param namespace       the namespace
1077    * @param key             the key
1078    * @param processingHints the processing hints
1079    * @return the boolean
1080    * @throws Exception the exception
1081    */
1082   public static boolean isArray(String tenant, String namespace, String key, int processingHints)
1083       throws Exception {
1084     Object obj = ConfigurationUtils
1085         .getProperty(ConfigurationRepository.lookup().getConfigurationFor(tenant, namespace), key,
1086             processingHints);
1087     return (obj == null) ? false : ConfigurationUtils.isCollection(obj.toString());
1088   }
1089
1090   /**
1091    * Is direct lookup boolean.
1092    *
1093    * @param hints the hints
1094    * @return the boolean
1095    */
1096   public static boolean isDirectLookup(int hints) {
1097     return (hints & LATEST_LOOKUP.value()) == LATEST_LOOKUP.value();
1098   }
1099
1100   /**
1101    * Is external lookup boolean.
1102    *
1103    * @param hints the hints
1104    * @return the boolean
1105    */
1106   public static boolean isExternalLookup(int hints) {
1107     return (hints & EXTERNAL_LOOKUP.value()) == EXTERNAL_LOOKUP.value();
1108   }
1109
1110   /**
1111    * Is node specific boolean.
1112    *
1113    * @param hints the hints
1114    * @return the boolean
1115    */
1116   public static boolean isNodeSpecific(int hints) {
1117     return (hints & NODE_SPECIFIC.value()) == NODE_SPECIFIC.value();
1118   }
1119
1120   public static boolean isZeroLengthArray(Class clazz, Object obj){
1121     if (clazz.isArray() && clazz.getComponentType().isPrimitive()){
1122       if (clazz.getComponentType()==int.class){
1123         return ((int[])obj).length==0;
1124       }else if (clazz.getComponentType()==byte.class){
1125         return ((byte[])obj).length==0;
1126       }else if (clazz.getComponentType()==short.class){
1127         return ((short[])obj).length==0;
1128       }else if (clazz.getComponentType()==float.class){
1129         return ((float[])obj).length==0;
1130       }else if (clazz.getComponentType()==boolean.class){
1131         return ((boolean[])obj).length==0;
1132       }else if (clazz.getComponentType()==double.class){
1133         return ((double[])obj).length==0;
1134       }else if (clazz.getComponentType()==long.class){
1135         return ((long[])obj).length==0;
1136       }else{
1137         return ((Object[])obj).length==0;
1138       }
1139     }
1140
1141     return false;
1142   }
1143
1144   /**
1145    * Checks if value is blank
1146    * @param value
1147    * @return
1148    */
1149   public static boolean isBlank(String value){
1150     return value==null || value.trim().length()==0;
1151   }
1152 }