common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/ConfigurationUtils.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  * Modifications Copyright (c) 2019 Samsung
  17  *
  18  */
  19
  20 package org.onap.config;
  21
  22 import com.virtlink.commons.configuration2.jackson.JsonConfiguration;
  23 import net.sf.corn.cps.CPScanner;
  24 import net.sf.corn.cps.ResourceFilter;
  25 import org.apache.commons.configuration2.Configuration;
  26 import org.apache.commons.configuration2.CompositeConfiguration;
  27 import org.apache.commons.configuration2.FileBasedConfiguration;
  28 import org.apache.commons.configuration2.PropertiesConfiguration;
  29 import org.apache.commons.configuration2.XMLConfiguration;
  30 import org.apache.commons.configuration2.builder.BasicConfigurationBuilder;
  31 import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
  32 import org.apache.commons.configuration2.builder.ReloadingFileBasedConfigurationBuilder;
  33 import org.apache.commons.configuration2.builder.fluent.Configurations;
  34 import org.apache.commons.configuration2.builder.fluent.Parameters;
  35 import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
  36 import org.apache.commons.configuration2.ex.ConfigurationException;
  37 import org.apache.commons.io.IOUtils;
  38 import org.onap.config.api.Config;
  39 import org.onap.config.api.ConfigurationManager;
  40 import org.onap.config.impl.YamlConfiguration;
  41 import org.onap.config.type.ConfigurationMode;
  42 import org.onap.config.type.ConfigurationType;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45
  46 import java.io.File;
  47 import java.io.IOException;
  48 import java.lang.reflect.Array;
  49 import java.lang.reflect.Field;
  50 import java.lang.reflect.ParameterizedType;
  51 import java.lang.reflect.Type;
  52 import java.net.MalformedURLException;
  53 import java.net.URL;
  54 import java.nio.charset.Charset;
  55 import java.nio.file.Files;
  56 import java.nio.file.FileVisitResult;
  57 import java.nio.file.Path;
  58 import java.nio.file.SimpleFileVisitor;
  59 import java.nio.file.attribute.BasicFileAttributes;
  60 import java.util.ArrayDeque;
  61 import java.util.ArrayList;
  62 import java.util.Arrays;
  63 import java.util.Collection;
  64 import java.util.Collections;
  65 import java.util.Deque;
  66 import java.util.HashMap;
  67 import java.util.HashSet;
  68 import java.util.List;
  69 import java.util.Map;
  70 import java.util.Objects;
  71 import java.util.Optional;
  72 import java.util.Queue;
  73 import java.util.Set;
  74 import java.util.SortedSet;
  75 import java.util.TreeSet;
  76 import java.util.concurrent.BlockingQueue;
  77 import java.util.concurrent.ConcurrentLinkedQueue;
  78 import java.util.concurrent.LinkedBlockingQueue;
  79 import java.util.concurrent.LinkedTransferQueue;
  80 import java.util.concurrent.TransferQueue;
  81 import java.util.function.Predicate;
  82 import java.util.regex.Matcher;
  83 import java.util.regex.Pattern;
  84 import java.util.stream.Collectors;
  85
  86 import static java.util.Optional.ofNullable;
  87 import static org.onap.config.api.Hint.EXTERNAL_LOOKUP;
  88 import static org.onap.config.api.Hint.LATEST_LOOKUP;
  89 import static org.onap.config.api.Hint.NODE_SPECIFIC;
  90
  91 public class ConfigurationUtils {
  92
  93     private static final Logger LOGGER = LoggerFactory.getLogger(ConfigurationUtils.class);
  94
  95     private static final String CONFIGURATION_TYPE_NOT_SUPPORTED = "Configuration type not supported:";
  96
  97     private static final Map<Class<?>, Class<?>> ARRAY_CLASS_MAP;
  98
  99     private static final String CONFIG_REGEX_TPL_OPT_1 = "CONFIG(-\\w*){0,1}(-(%s|%s|%s)){0,1}\\.(%s|%s|%s|%s)$";
 100
 101     private static final String CONFIG_REGEX_TPL_OPT_2 = "CONFIG(.)*\\.(%s|%s|%s|%s)$";
 102
 103     static {
 104         Map<Class<?>, Class<?>> arrayTypes = new HashMap<>();
 105         arrayTypes.put(Byte.class, Byte[].class);
 106         arrayTypes.put(Short.class, Short[].class);
 107         arrayTypes.put(Integer.class, Integer[].class);
 108         arrayTypes.put(Long.class, Long[].class);
 109         arrayTypes.put(Float.class, Float[].class);
 110         arrayTypes.put(Double.class, Double[].class);
 111         arrayTypes.put(Boolean.class, Boolean[].class);
 112         arrayTypes.put(Character.class, Character[].class);
 113         arrayTypes.put(String.class, String[].class);
 114         ARRAY_CLASS_MAP = Collections.unmodifiableMap(arrayTypes);
 115     }
 116
 117     private ConfigurationUtils() {
 118         // prevent instantiation
 119     }
 120
 121     public static Collection<File> getAllFiles(File file, boolean recursive, boolean onlyDirectory) {
 122         ArrayList<File> collection = new ArrayList<>();
 123         Path rootPath = file.toPath();
 124         try {
 125             Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
 126                 @Override
 127                 public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
 128                     super.preVisitDirectory(dir,attrs);
 129                     if (rootPath.equals(dir)) {
 130                         return FileVisitResult.CONTINUE;
 131                     }
 132                     collection.add(dir.toFile());
 133                     return recursive? FileVisitResult.CONTINUE : FileVisitResult.SKIP_SUBTREE;
 134                 }
 135
 136                 @Override
 137                 public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
 138                     super.visitFile(file, attrs);
 139                     if (!onlyDirectory) {
 140                         collection.add(file.toFile());
 141                     }
 142                     return FileVisitResult.CONTINUE;
 143                 }
 144             });
 145         } catch (IOException e) {
 146             LOGGER.error("Failed to walk through directories starting from: {}.", file.toString(), e);
 147         }
 148         return collection;
 149     }
 150
 151     public static String getCommaSeparatedList(String[] list) {
 152         return (list == null) || (list.length == 0) ? "" : getCommaSeparatedList(Arrays.asList(list));
 153     }
 154
 155     public static String getCommaSeparatedList(List<?> list) {
 156
 157         if ((list == null) || list.isEmpty()) {
 158             return "";
 159         }
 160
 161         return list.stream().filter(o -> o != null && !o.toString().trim().isEmpty())
 162                 .map(o -> o.toString().trim()).collect(Collectors.joining(","));
 163     }
 164
 165     public static boolean isConfig(URL url) {
 166         return isConfig(url.getFile());
 167     }
 168
 169     public static boolean isConfig(String file) {
 170         file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
 171         file = file.substring(file.lastIndexOf('/') + 1);
 172         return file.matches(
 173                 String.format(
 174                         CONFIG_REGEX_TPL_OPT_1,
 175                         ConfigurationMode.OVERRIDE,
 176                         ConfigurationMode.MERGE,
 177                         ConfigurationMode.UNION,
 178                         ConfigurationType.PROPERTIES.name(),
 179                         ConfigurationType.XML.name(),
 180                         ConfigurationType.JSON.name(),
 181                         ConfigurationType.YAML.name()
 182                 )
 183         ) || file.matches(
 184                 String.format(
 185                         CONFIG_REGEX_TPL_OPT_2,
 186                         ConfigurationType.PROPERTIES.name(),
 187                         ConfigurationType.XML.name(),
 188                         ConfigurationType.JSON.name(),
 189                         ConfigurationType.YAML.name()
 190                 )
 191         );
 192     }
 193
 194     public static boolean isConfig(File file) {
 195         return file != null && file.exists() && isConfig(file.getName());
 196     }
 197
 198     private static Optional<String> readNamespace(Configuration config) {
 199         return ofNullable(config).flatMap(configuration -> ofNullable(configuration.getString(Constants.NAMESPACE_KEY)))
 200                 .map(String::toUpperCase);
 201     }
 202
 203     private static Optional<String> readMergeStrategy(Configuration config) {
 204         return ofNullable(config).flatMap(configuration -> ofNullable(configuration.getString(Constants.MODE_KEY)))
 205                 .map(String::toUpperCase);
 206     }
 207
 208     public static ConfigurationMode getMergeStrategy(File file) {
 209         Optional<ConfigurationMode> configurationMode =
 210                 getConfiguration(file).flatMap(ConfigurationUtils::readMergeStrategy)
 211                         .flatMap(ConfigurationUtils::convertConfigurationMode);
 212         return configurationMode.orElseGet(() -> getMergeStrategy(file.getName().toUpperCase()));
 213     }
 214
 215     public static ConfigurationMode getMergeStrategy(URL url) {
 216         Optional<ConfigurationMode> configurationMode =
 217                 getConfiguration(url).flatMap(ConfigurationUtils::readMergeStrategy)
 218                         .flatMap(ConfigurationUtils::convertConfigurationMode);
 219         return configurationMode.orElseGet(() -> getMergeStrategy(url.getFile().toUpperCase()));
 220     }
 221
 222     public static ConfigurationMode getMergeStrategy(String file) {
 223
 224         file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
 225         file = file.substring(file.lastIndexOf('/') + 1);
 226         Pattern pattern = Pattern.compile(
 227                 String.format(
 228                         CONFIG_REGEX_TPL_OPT_1,
 229                         ConfigurationMode.OVERRIDE,
 230                         ConfigurationMode.MERGE,
 231                         ConfigurationMode.UNION,
 232                         ConfigurationType.PROPERTIES.name(),
 233                         ConfigurationType.XML.name(),
 234                         ConfigurationType.JSON.name(),
 235                         ConfigurationType.YAML.name()
 236                 )
 237         );
 238         Matcher matcher = pattern.matcher(file);
 239         boolean b1 = matcher.matches();
 240         if (b1) {
 241             for (int i = 1; i <= matcher.groupCount(); i++) {
 242                 String modeName = matcher.group(i);
 243                 if (modeName != null) {
 244                     modeName = modeName.substring(1);
 245                 }
 246                 try {
 247                     return Enum.valueOf(ConfigurationMode.class, modeName);
 248                 } catch (Exception exception) {
 249                     LOGGER.debug("Configuration mode for merge strategy '{}' not found", modeName, exception);
 250                 }
 251             }
 252         }
 253
 254         return null;
 255     }
 256
 257     public static Optional<FileBasedConfiguration> getConfiguration(URL url) {
 258
 259         try {
 260
 261             ConfigurationType configType = ConfigurationUtils.getConfigType(url);
 262             switch (configType) {
 263                 case PROPERTIES:
 264                     return Optional.of(new Configurations().fileBased(PropertiesConfiguration.class, url));
 265                 case XML:
 266                     return Optional.of(new Configurations().fileBased(XMLConfiguration.class, url));
 267                 case JSON:
 268                     return Optional.of(new Configurations().fileBased(JsonConfiguration.class, url));
 269                 case YAML:
 270                     return Optional.of(new Configurations().fileBased(YamlConfiguration.class, url));
 271                 default:
 272                     throw new ConfigurationException(CONFIGURATION_TYPE_NOT_SUPPORTED + configType);
 273             }
 274         } catch (ConfigurationException exception) {
 275             LOGGER.error("Error reading configuration at {}.", url.toString(), exception);
 276         }
 277
 278         return Optional.empty();
 279     }
 280
 281     public static Optional<FileBasedConfiguration> getConfiguration(File file) {
 282
 283         try {
 284             return getConfiguration(file.getAbsoluteFile().toURI().toURL());
 285         } catch (MalformedURLException e) {
 286             throw new IllegalStateException("Malformed URL: " + file.getAbsolutePath());
 287         }
 288     }
 289
 290     public static ConfigurationType getConfigType(File file) {
 291         Objects.requireNonNull(file, "File cannot be null");
 292         return Enum.valueOf(ConfigurationType.class,
 293                 file.getAbsolutePath().substring(file.getAbsolutePath().lastIndexOf('.') + 1).toUpperCase());
 294     }
 295
 296     public static ConfigurationType getConfigType(URL url) {
 297         Objects.requireNonNull(url, "URL cannot be null");
 298         return Enum.valueOf(ConfigurationType.class,
 299                 url.getFile().substring(url.getFile().lastIndexOf('.') + 1).toUpperCase());
 300     }
 301
 302     private static Optional<ConfigurationMode> convertConfigurationMode(String configMode) {
 303         ConfigurationMode configurationMode = null;
 304         try {
 305             configurationMode = ConfigurationMode.valueOf(configMode);
 306         } catch (Exception exception) {
 307             LOGGER.error("Could not find convert {} into configuration mode.", configMode, exception);
 308         }
 309         return Optional.ofNullable(configurationMode);
 310     }
 311
 312     public static Class<?> getCollectionGenericType(Field field) {
 313         Type type = field.getGenericType();
 314
 315         if (type instanceof ParameterizedType) {
 316
 317             ParameterizedType paramType = (ParameterizedType) type;
 318             Type[] arr = paramType.getActualTypeArguments();
 319             if (arr.length > 0) {
 320                 Class<?> clazz = (Class<?>) arr[0];
 321                 if (isWrapperClass(clazz)) {
 322                     return clazz;
 323                 } else {
 324                     throw new IllegalArgumentException("Collection of type " + clazz.getName() + " not supported.");
 325                 }
 326             }
 327         }
 328
 329         return String[].class;
 330     }
 331
 332     public static boolean isWrapperClass(Class<?> clazz) {
 333         Predicate<Class<?>> predicateWrapper = type -> type == String.class || type == Boolean.class || type == Character.class
 334                 || Number.class.isAssignableFrom(type);
 335         return isA(predicateWrapper, clazz);
 336     }
 337
 338     public static boolean isAPrimitive(Class<?> clazz) {
 339         return isA(Class::isPrimitive, clazz);
 340     }
 341
 342     /**
 343      * Check if clazz implementing Map iface
 344      */
 345     public static boolean isAMap(Class<?> clazz) {
 346         Predicate<Class<?>> predicateMap = Map.class::isAssignableFrom;
 347         return isA(predicateMap, clazz);
 348     }
 349
 350     /**
 351      * Check if clazz implementing Collection iface
 352      */
 353     public static boolean isACollection(Class<?> clazz) {
 354         Predicate<Class<?>> predicateCollection = Collection.class::isAssignableFrom;
 355         return isA(predicateCollection, clazz);
 356     }
 357
 358     /**
 359      * Check if clazz is a primitive or primitive wrapper
 360      */
 361     public static boolean isAPrimitiveOrWrapper(Class<?> clazz) {
 362         Predicate<Class<?>> predicatePrimitive = Class::isPrimitive;
 363         Predicate<Class<?>> predicateWrapper = ConfigurationUtils::isWrapperClass;
 364         return isA(predicatePrimitive.or(predicateWrapper), clazz);
 365     }
 366
 367     /**
 368      * Check if clazz is array of primitives or array of primitives wrappers
 369      */
 370     public static boolean isAPrimitivesOrWrappersArray(Class<?> clazz) {
 371         Predicate<Class<?>> predicatePrimitivesOrWrappersArray =
 372                 type -> ConfigurationUtils.isAWrappersArray(type) || ConfigurationUtils.isAPrimitivesArray(type);
 373         return isA(predicatePrimitivesOrWrappersArray, clazz);
 374
 375     }
 376
 377     /**
 378      * Check is clazz is array of primitives
 379      */
 380     public static boolean isAPrimitivesArray(Class<?> clazz) {
 381         Predicate<Class<?>> predicateArray = Class::isArray;
 382         Predicate<Class<?>> predicateComponentPrimitive = type -> type.getComponentType().isPrimitive();
 383         return isA(predicateArray.and(predicateComponentPrimitive), clazz);
 384     }
 385
 386     /**
 387      * Check is clazz is array of primitives wrappers
 388      */
 389     public static boolean isAWrappersArray(Class<?> clazz) {
 390         Predicate<Class<?>> predicateArray = Class::isArray;
 391         Predicate<Class<?>> predicateComponentWrapper = type -> isWrapperClass(type.getComponentType());
 392         return isA(predicateArray.and(predicateComponentWrapper), clazz);
 393     }
 394
 395     private static boolean isA(Predicate<Class<?>> predicate, Class<?> clazz) {
 396         return predicate.test(clazz);
 397     }
 398
 399     public static Class<?> getArrayClass(Class<?> clazz) {
 400         return ARRAY_CLASS_MAP.getOrDefault(clazz, null);
 401     }
 402
 403     public static List<URL> getAllClassPathResources() {
 404         return CPScanner.scanResources(new ResourceFilter());
 405     }
 406
 407     public static BasicConfigurationBuilder<FileBasedConfiguration> getConfigurationBuilder(File file) {
 408         FileBasedConfigurationBuilder<FileBasedConfiguration> builder;
 409         ConfigurationType configType = ConfigurationUtils.getConfigType(file);
 410         builder = getFileBasedConfigurationBuilder(configType);
 411         builder.configure(new Parameters().fileBased().setFile(file)
 412                 .setListDelimiterHandler(new DefaultListDelimiterHandler(',')));
 413         return builder;
 414     }
 415
 416     public static BasicConfigurationBuilder<FileBasedConfiguration> getConfigurationBuilder(URL url) {
 417         ConfigurationType configType = ConfigurationUtils.getConfigType(url);
 418         ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration> builder =
 419                 getFileBasedConfigurationBuilder(configType);
 420         builder.configure(
 421                 new Parameters().fileBased().setURL(url).setListDelimiterHandler(new DefaultListDelimiterHandler(',')));
 422         return builder;
 423     }
 424
 425     private static ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration> getFileBasedConfigurationBuilder(
 426             ConfigurationType configType) {
 427
 428         ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration> builder;
 429         switch (configType) {
 430             case PROPERTIES:
 431                 builder = new ReloadingFileBasedConfigurationBuilder<>(PropertiesConfiguration.class);
 432                 break;
 433             case XML:
 434                 builder = new ReloadingFileBasedConfigurationBuilder<>(XMLConfiguration.class);
 435                 break;
 436             case JSON:
 437                 builder = new ReloadingFileBasedConfigurationBuilder<>(JsonConfiguration.class);
 438                 break;
 439             case YAML:
 440                 builder = new ReloadingFileBasedConfigurationBuilder<>(YamlConfiguration.class);
 441                 break;
 442             default:
 443                 throw new IllegalArgumentException(CONFIGURATION_TYPE_NOT_SUPPORTED + configType);
 444         }
 445         return builder;
 446     }
 447
 448     public static <T> T read(Configuration config, Class<T> clazz, String keyPrefix) throws Exception {
 449         Config confAnnotation = clazz.getAnnotation(Config.class);
 450         if (confAnnotation != null) {
 451             keyPrefix += (confAnnotation.key() + ".");
 452         }
 453         T objToReturn = clazz.newInstance();
 454         for (Field field : clazz.getDeclaredFields()) {
 455             Config fieldAnnotation = field.getAnnotation(Config.class);
 456             if (fieldAnnotation != null) {
 457                 field.setAccessible(true);
 458                 field.set(objToReturn, config.getProperty(keyPrefix + fieldAnnotation.key()));
 459             } else if (field.getType().getAnnotation(Config.class) != null) {
 460                 field.set(objToReturn, read(config, field.getType(), keyPrefix));
 461             }
 462         }
 463         return objToReturn;
 464     }
 465
 466     public static Object getPrimitiveArray(Collection<?> collection, Class<?> clazz) {
 467         switch (clazz.getName()) {
 468             case "int":
 469                 return getIntsPrimitiveArray(collection);
 470             case "byte":
 471                 return getBytesPrimitiveArray(collection);
 472             case "short":
 473                 return getShortsPrimitiveArray(collection);
 474             case "long":
 475                 return getLongsPrimitiveArray(collection);
 476             case "float":
 477                 return getFloatsPrimitiveArray(collection);
 478             case "double":
 479                 return getDoublesPrimitiveArray(collection);
 480             case "boolean":
 481                 return getBooleansPrimitiveArray(collection);
 482             case "char":
 483                 return getCharsPrimitiveArray(collection);
 484             default:
 485                 return null;
 486         }
 487     }
 488
 489     public static Object getWrappersArray(Collection<?> collection, Class<?> clazz) {
 490         Object array = null;
 491         if (isWrapperClass(clazz)){
 492             int collectionSize = collection.size();
 493             array = Array.newInstance(clazz, collection.size());
 494             Object[] objArray = collection.toArray();
 495             System.arraycopy(objArray, 0, array, 0, collectionSize);
 496         }
 497         return array;
 498     }
 499
 500     public static String getCollectionString(String input) {
 501         Pattern pattern = Pattern.compile("^\\[(.*)\\]$");
 502         Matcher matcher = pattern.matcher(input);
 503         if (matcher.matches()) {
 504             input = matcher.group(1);
 505         }
 506         return input;
 507     }
 508
 509     public static String processVariablesIfPresent(String tenant, String namespace, String data) {
 510         Pattern pattern = Pattern.compile("^.*\\$\\{(.*)\\}.*");
 511         Matcher matcher = pattern.matcher(data);
 512         if (matcher.matches()) {
 513             final int substringStartIndex = 4;
 514             String key = matcher.group(1);
 515             String value;
 516             if (key.toUpperCase().startsWith("ENV:")) {
 517                 value = System.getenv(key.substring(substringStartIndex));
 518             } else if (key.toUpperCase().startsWith("SYS:")) {
 519                 value = System.getProperty(key.substring(substringStartIndex));
 520             } else {
 521                 value = ConfigurationUtils.getCollectionString(
 522                         ConfigurationManager.lookup().getAsStringValues(tenant, namespace, key).toString());
 523             }
 524             return processVariablesIfPresent(tenant, namespace, data.replaceAll("\\$\\{" + key + "}",
 525                     value == null ? "" : value.replace("\\", "\\\\")));
 526         } else {
 527             return data;
 528         }
 529     }
 530
 531     public static String getFileContents(String path) {
 532         try {
 533             if (path != null) {
 534                 return IOUtils.toString(new URL(path), Charset.defaultCharset());
 535             }
 536         } catch (Exception exception) {
 537             LOGGER.error("Error while getting '{}' content", path, exception);
 538         }
 539         return null;
 540     }
 541
 542     public static String getFileContents(Path path) {
 543         try {
 544             if (path != null) {
 545                 return new String(Files.readAllBytes(path));
 546             }
 547         } catch (Exception exception) {
 548             LOGGER.error("Error while getting '{}' content", path.toString(), exception);
 549         }
 550         return null;
 551     }
 552
 553     public static Object getDefaultFor(Class<?> clazz) {
 554         if (byte.class == clazz) {
 555             return new Byte("0");
 556         } else if (short.class == clazz) {
 557             return new Short("0");
 558         } else if (int.class == clazz) {
 559             return new Integer("0");
 560         } else if (float.class == clazz) {
 561             return new Float("0");
 562         } else if (long.class == clazz) {
 563             return new Long("0");
 564         } else if (double.class == clazz) {
 565             return new Double("0");
 566         } else if (boolean.class == clazz) {
 567             return Boolean.FALSE;
 568         }
 569         return (char) 0;
 570     }
 571
 572     public static Collection getCompatibleCollectionForAbstractDef(Class<?> clazz) {
 573         if (TransferQueue.class.isAssignableFrom(clazz)) {
 574             return getConcreteCollection(TransferQueue.class);
 575         }
 576         if (BlockingQueue.class.isAssignableFrom(clazz)) {
 577             return getConcreteCollection(BlockingQueue.class);
 578         }
 579         if (Deque.class.isAssignableFrom(clazz)) {
 580             return getConcreteCollection(Deque.class);
 581         }
 582         if (Queue.class.isAssignableFrom(clazz)) {
 583             return getConcreteCollection(Queue.class);
 584         }
 585         if (SortedSet.class.isAssignableFrom(clazz)) {
 586             return getConcreteCollection(SortedSet.class);
 587         }
 588         if (Set.class.isAssignableFrom(clazz)) {
 589             return getConcreteCollection(Set.class);
 590         }
 591         if (List.class.isAssignableFrom(clazz)) {
 592             return getConcreteCollection(List.class);
 593         }
 594         throw new IllegalArgumentException("Only corresponding array classes and any are allowed as argument."
 595                 + "assignable from TransferQueue, BlockingQueue, Deque, Queue, SortedSet, Set, List class");
 596     }
 597
 598     public static Collection getConcreteCollection(Class<?> clazz) {
 599         switch (clazz.getName()) {
 600             case "java.util.Collection":
 601             case "java.util.List":
 602                 return new ArrayList<>();
 603             case "java.util.Set":
 604                 return new HashSet<>();
 605             case "java.util.SortedSet":
 606                 return new TreeSet<>();
 607             case "java.util.Queue":
 608                 return new ConcurrentLinkedQueue<>();
 609             case "java.util.Deque":
 610                 return new ArrayDeque<>();
 611             case "java.util.concurrent.TransferQueue":
 612                 return new LinkedTransferQueue<>();
 613             case "java.util.concurrent.BlockingQueue":
 614                 return new LinkedBlockingQueue<>();
 615             default:
 616                 throw new IllegalArgumentException("Only corresponding array classes and any are allowed as argument."
 617                         + "assignable from TransferQueue, BlockingQueue, Deque, Queue, SortedSet, Set, List class");
 618         }
 619     }
 620
 621     public static String getConfigurationRepositoryKey(File file) {
 622         return getConfigurationRepositoryKey(
 623                 ConfigurationUtils.getNamespace(file).split(Constants.TENANT_NAMESPACE_SEPARATOR));
 624     }
 625
 626     public static String getConfigurationRepositoryKey(URL url) {
 627         return getConfigurationRepositoryKey(
 628                 ConfigurationUtils.getNamespace(url).split(Constants.TENANT_NAMESPACE_SEPARATOR));
 629     }
 630
 631     public static String getConfigurationRepositoryKey(String[] array) {
 632         Deque<String> stack = new ArrayDeque<>();
 633         stack.push(Constants.DEFAULT_TENANT);
 634         for (String element : array) {
 635             stack.push(element);
 636         }
 637         String toReturn = stack.pop();
 638         return stack.pop() + Constants.KEY_ELEMENTS_DELIMITER + toReturn;
 639     }
 640
 641     public static String getNamespace(File file) {
 642         Optional<String> namespace =
 643                 getConfiguration(file).flatMap(ConfigurationUtils::readNamespace).map(String::toUpperCase);
 644         return namespace.orElseGet(() -> getNamespace(file.getName().toUpperCase()));
 645     }
 646
 647     public static String getNamespace(String file) {
 648         file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
 649         file = file.substring(file.lastIndexOf('/') + 1);
 650         Pattern pattern = Pattern.compile(
 651                 String.format(
 652                         CONFIG_REGEX_TPL_OPT_1,
 653                         ConfigurationMode.OVERRIDE,
 654                         ConfigurationMode.MERGE,
 655                         ConfigurationMode.UNION,
 656                         ConfigurationType.PROPERTIES.name(),
 657                         ConfigurationType.XML.name(),
 658                         ConfigurationType.JSON.name(),
 659                         ConfigurationType.YAML.name()
 660                 )
 661         );
 662         Matcher matcher = pattern.matcher(file);
 663         boolean b1 = matcher.matches();
 664         if (b1) {
 665             if (matcher.group(1) != null) {
 666                 String moduleName = matcher.group(1).substring(1);
 667                 return moduleName.equalsIgnoreCase(ConfigurationMode.OVERRIDE.name()) || moduleName.equalsIgnoreCase(
 668                         ConfigurationMode.UNION.name()) || moduleName.equalsIgnoreCase(ConfigurationMode.MERGE.name())
 669                         ? Constants.DEFAULT_NAMESPACE : moduleName;
 670             } else {
 671                 return Constants.DEFAULT_NAMESPACE;
 672             }
 673         } else if (isConfig(file)) {
 674             return Constants.DEFAULT_NAMESPACE;
 675         }
 676
 677         return null;
 678     }
 679
 680     public static String getNamespace(URL url) {
 681
 682         Optional<String> namespace =
 683                 getConfiguration(url).flatMap(ConfigurationUtils::readNamespace).map(String::toUpperCase);
 684
 685         return namespace.orElseGet(() -> getNamespace(url.getFile().toUpperCase()));
 686     }
 687
 688     public static Object getProperty(Configuration config, String key, int processingHints) {
 689         if (!isDirectLookup(processingHints) && isNodeSpecific(processingHints) && (config instanceof CompositeConfiguration)) {
 690             CompositeConfiguration conf = (CompositeConfiguration) config;
 691             for (int i = 0; i < conf.getNumberOfConfigurations(); i++) {
 692                 Object obj = conf.getConfiguration(i).getProperty(key);
 693                 if (obj != null) {
 694                     return obj;
 695                 }
 696             }
 697         }
 698         return config.getProperty(key);
 699     }
 700
 701     public static boolean isCollection(String input) {
 702         Pattern pattern = Pattern.compile("^\\[(.*)\\]$");
 703         Matcher matcher = pattern.matcher(input);
 704         return matcher.matches();
 705     }
 706
 707     public static boolean isDirectLookup(int hints) {
 708         return (hints & LATEST_LOOKUP.value()) == LATEST_LOOKUP.value();
 709     }
 710
 711     public static boolean isNodeSpecific(int hints) {
 712         return (hints & NODE_SPECIFIC.value()) == NODE_SPECIFIC.value();
 713     }
 714
 715     public static boolean isExternalLookup(int hints) {
 716         return (hints & EXTERNAL_LOOKUP.value()) == EXTERNAL_LOOKUP.value();
 717     }
 718
 719     public static boolean isZeroLengthArray(Class<?> clazz, Object obj) {
 720         if (isAPrimitivesArray(clazz)) {
 721             if (clazz.getComponentType() == int.class) {
 722                 return ((int[]) obj).length == 0;
 723             } else if (clazz.getComponentType() == byte.class) {
 724                 return ((byte[]) obj).length == 0;
 725             } else if (clazz.getComponentType() == short.class) {
 726                 return ((short[]) obj).length == 0;
 727             } else if (clazz.getComponentType() == float.class) {
 728                 return ((float[]) obj).length == 0;
 729             } else if (clazz.getComponentType() == boolean.class) {
 730                 return ((boolean[]) obj).length == 0;
 731             } else if (clazz.getComponentType() == double.class) {
 732                 return ((double[]) obj).length == 0;
 733             } else if (clazz.getComponentType() == long.class) {
 734                 return ((long[]) obj).length == 0;
 735             } else {
 736                 return ((Object[]) obj).length == 0;
 737             }
 738         }
 739
 740         return false;
 741     }
 742
 743     public static boolean isBlank(String value) {
 744         return value == null || value.trim().isEmpty();
 745     }
 746
 747     // private methods section starts here
 748
 749     private static int[] getIntsPrimitiveArray(Collection<?> collection) {
 750         int collectionSize = collection.size();
 751         int[] array = new int[collectionSize];
 752         Object[] objArray = collection.toArray();
 753         for (int i = 0; i < collectionSize; i++) {
 754             array[i] = (int) objArray[i];
 755         }
 756         return array;
 757     }
 758
 759     private static byte[] getBytesPrimitiveArray(Collection<?> collection) {
 760         int collectionSize = collection.size();
 761         byte[] array = new byte[collectionSize];
 762         Object[] objArray = collection.toArray();
 763         for (int i = 0; i < collectionSize; i++) {
 764             array[i] = (byte) objArray[i];
 765         }
 766         return array;
 767     }
 768
 769     private static short[] getShortsPrimitiveArray(Collection<?> collection) {
 770         int collectionSize = collection.size();
 771         short[] array = new short[collectionSize];
 772         Object[] objArray = collection.toArray();
 773         for (int i = 0; i < collectionSize; i++) {
 774             array[i] = (short) objArray[i];
 775         }
 776         return array;
 777     }
 778
 779     private static long[] getLongsPrimitiveArray(Collection<?> collection) {
 780         int collectionSize = collection.size();
 781         long[] array = new long[collectionSize];
 782         Object[] objArray = collection.toArray();
 783         for (int i = 0; i < collectionSize; i++) {
 784             array[i] = (long) objArray[i];
 785         }
 786         return array;
 787     }
 788
 789     private static float[] getFloatsPrimitiveArray(Collection<?> collection) {
 790         int collectionSize = collection.size();
 791         float[] array = new float[collectionSize];
 792         Object[] objArray = collection.toArray();
 793         for (int i = 0; i < collectionSize; i++) {
 794             array[i] = (float) objArray[i];
 795         }
 796         return array;
 797     }
 798
 799     private static double[] getDoublesPrimitiveArray(Collection<?> collection) {
 800         int collectionSize = collection.size();
 801         double[] array = new double[collectionSize];
 802         Object[] objArray = collection.toArray();
 803         for (int i = 0; i < collectionSize; i++) {
 804             array[i] = (double) objArray[i];
 805         }
 806         return array;
 807     }
 808
 809     private static boolean[] getBooleansPrimitiveArray(Collection<?> collection) {
 810         int collectionSize = collection.size();
 811         boolean[] array = new boolean[collectionSize];
 812         Object[] objArray = collection.toArray();
 813         for (int i = 0; i < collectionSize; i++) {
 814             array[i] = (boolean) objArray[i];
 815         }
 816         return array;
 817     }
 818
 819     private static char[] getCharsPrimitiveArray(Collection<?> collection) {
 820         int collectionSize = collection.size();
 821         char[] array = new char[collectionSize];
 822         Object[] objArray = collection.toArray();
 823         for (int i = 0; i < collectionSize; i++) {
 824             array[i] = (char) objArray[i];
 825         }
 826         return array;
 827     }
 828
 829 }