diff options
Diffstat (limited to 'common/onap-common-configuration-management')
3 files changed, 574 insertions, 357 deletions
diff --git a/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/ConfigurationUtils.java b/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/ConfigurationUtils.java index 17e9ef048f..85698e89de 100644 --- a/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/ConfigurationUtils.java +++ b/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/ConfigurationUtils.java @@ -45,6 +45,7 @@ import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; +import java.lang.reflect.Array; import java.lang.reflect.Field; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; @@ -77,6 +78,7 @@ import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.LinkedTransferQueue; import java.util.concurrent.TransferQueue; +import java.util.function.Predicate; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; @@ -92,14 +94,14 @@ public class ConfigurationUtils { private static final String CONFIGURATION_TYPE_NOT_SUPPORTED = "Configuration type not supported:"; - private static final Map<Class, Class> ARRAY_CLASS_MAP; + private static final Map<Class<?>, Class<?>> ARRAY_CLASS_MAP; private static final String CONFIG_REGEX_TPL_OPT_1 = "CONFIG(-\\w*){0,1}(-(%s|%s|%s)){0,1}\\.(%s|%s|%s|%s)$"; private static final String CONFIG_REGEX_TPL_OPT_2 = "CONFIG(.)*\\.(%s|%s|%s|%s)$"; static { - Map<Class, Class> arrayTypes = new HashMap<>(); + Map<Class<?>, Class<?>> arrayTypes = new HashMap<>(); arrayTypes.put(Byte.class, Byte[].class); arrayTypes.put(Short.class, Short[].class); arrayTypes.put(Integer.class, Integer[].class); @@ -307,7 +309,7 @@ public class ConfigurationUtils { return Optional.ofNullable(configurationMode); } - public static Class getCollectionGenericType(Field field) { + public static Class<?> getCollectionGenericType(Field field) { Type type = field.getGenericType(); if (type instanceof ParameterizedType) { @@ -327,12 +329,74 @@ public class ConfigurationUtils { return String[].class; } - public static boolean isWrapperClass(Class clazz) { - return clazz == String.class || clazz == Boolean.class || clazz == Character.class - || Number.class.isAssignableFrom(clazz); + public static boolean isWrapperClass(Class<?> clazz) { + Predicate<Class<?>> predicateWrapper = type -> type == String.class || type == Boolean.class || type == Character.class + || Number.class.isAssignableFrom(type); + return isA(predicateWrapper, clazz); } - public static Class getArrayClass(Class clazz) { + public static boolean isAPrimitive(Class<?> clazz) { + return isA(Class::isPrimitive, clazz); + } + + /** + * Check if clazz implementing Map iface + */ + public static boolean isAMap(Class<?> clazz) { + Predicate<Class<?>> predicateMap = Map.class::isAssignableFrom; + return isA(predicateMap, clazz); + } + + /** + * Check if clazz implementing Collection iface + */ + public static boolean isACollection(Class<?> clazz) { + Predicate<Class<?>> predicateCollection = Collection.class::isAssignableFrom; + return isA(predicateCollection, clazz); + } + + /** + * Check if clazz is a primitive or primitive wrapper + */ + public static boolean isAPrimitiveOrWrapper(Class<?> clazz) { + Predicate<Class<?>> predicatePrimitive = Class::isPrimitive; + Predicate<Class<?>> predicateWrapper = ConfigurationUtils::isWrapperClass; + return isA(predicatePrimitive.or(predicateWrapper), clazz); + } + + /** + * Check if clazz is array of primitives or array of primitives wrappers + */ + public static boolean isAPrimitivesOrWrappersArray(Class<?> clazz) { + Predicate<Class<?>> predicatePrimitivesOrWrappersArray = + type -> ConfigurationUtils.isAWrappersArray(type) || ConfigurationUtils.isAPrimitivesArray(type); + return isA(predicatePrimitivesOrWrappersArray, clazz); + + } + + /** + * Check is clazz is array of primitives + */ + public static boolean isAPrimitivesArray(Class<?> clazz) { + Predicate<Class<?>> predicateArray = Class::isArray; + Predicate<Class<?>> predicateComponentPrimitive = type -> type.getComponentType().isPrimitive(); + return isA(predicateArray.and(predicateComponentPrimitive), clazz); + } + + /** + * Check is clazz is array of primitives wrappers + */ + public static boolean isAWrappersArray(Class<?> clazz) { + Predicate<Class<?>> predicateArray = Class::isArray; + Predicate<Class<?>> predicateComponentWrapper = type -> isWrapperClass(type.getComponentType()); + return isA(predicateArray.and(predicateComponentWrapper), clazz); + } + + private static boolean isA(Predicate<Class<?>> predicate, Class<?> clazz) { + return predicate.test(clazz); + } + + public static Class<?> getArrayClass(Class<?> clazz) { return ARRAY_CLASS_MAP.getOrDefault(clazz, null); } @@ -399,7 +463,7 @@ public class ConfigurationUtils { return objToReturn; } - public static Object getPrimitiveArray(Collection collection, Class clazz) { + public static Object getPrimitiveArray(Collection<?> collection, Class<?> clazz) { switch (clazz.getName()) { case "int": return getIntsPrimitiveArray(collection); @@ -415,11 +479,24 @@ public class ConfigurationUtils { return getDoublesPrimitiveArray(collection); case "boolean": return getBooleansPrimitiveArray(collection); + case "char": + return getCharsPrimitiveArray(collection); default: return null; } } + public static Object getWrappersArray(Collection<?> collection, Class<?> clazz) { + Object array = null; + if (isWrapperClass(clazz)){ + int collectionSize = collection.size(); + array = Array.newInstance(clazz, collection.size()); + Object[] objArray = collection.toArray(); + System.arraycopy(objArray, 0, array, 0, collectionSize); + } + return array; + } + public static String getCollectionString(String input) { Pattern pattern = Pattern.compile("^\\[(.*)\\]$"); Matcher matcher = pattern.matcher(input); @@ -473,7 +550,7 @@ public class ConfigurationUtils { return null; } - public static Object getDefaultFor(Class clazz) { + public static Object getDefaultFor(Class<?> clazz) { if (byte.class == clazz) { return new Byte("0"); } else if (short.class == clazz) { @@ -492,7 +569,7 @@ public class ConfigurationUtils { return (char) 0; } - public static Collection getCompatibleCollectionForAbstractDef(Class clazz) { + public static Collection getCompatibleCollectionForAbstractDef(Class<?> clazz) { if (TransferQueue.class.isAssignableFrom(clazz)) { return getConcreteCollection(TransferQueue.class); } @@ -518,7 +595,7 @@ public class ConfigurationUtils { + "assignable from TransferQueue, BlockingQueue, Deque, Queue, SortedSet, Set, List class"); } - public static Collection getConcreteCollection(Class clazz) { + public static Collection getConcreteCollection(Class<?> clazz) { switch (clazz.getName()) { case "java.util.Collection": case "java.util.List": @@ -639,8 +716,8 @@ public class ConfigurationUtils { return (hints & EXTERNAL_LOOKUP.value()) == EXTERNAL_LOOKUP.value(); } - public static boolean isZeroLengthArray(Class clazz, Object obj) { - if (clazz.isArray() && clazz.getComponentType().isPrimitive()) { + public static boolean isZeroLengthArray(Class<?> clazz, Object obj) { + if (isAPrimitivesArray(clazz)) { if (clazz.getComponentType() == int.class) { return ((int[]) obj).length == 0; } else if (clazz.getComponentType() == byte.class) { @@ -669,7 +746,7 @@ public class ConfigurationUtils { // private methods section starts here - private static int[] getIntsPrimitiveArray(Collection collection) { + private static int[] getIntsPrimitiveArray(Collection<?> collection) { int collectionSize = collection.size(); int[] array = new int[collectionSize]; Object[] objArray = collection.toArray(); @@ -679,7 +756,7 @@ public class ConfigurationUtils { return array; } - private static byte[] getBytesPrimitiveArray(Collection collection) { + private static byte[] getBytesPrimitiveArray(Collection<?> collection) { int collectionSize = collection.size(); byte[] array = new byte[collectionSize]; Object[] objArray = collection.toArray(); @@ -689,7 +766,7 @@ public class ConfigurationUtils { return array; } - private static short[] getShortsPrimitiveArray(Collection collection) { + private static short[] getShortsPrimitiveArray(Collection<?> collection) { int collectionSize = collection.size(); short[] array = new short[collectionSize]; Object[] objArray = collection.toArray(); @@ -699,7 +776,7 @@ public class ConfigurationUtils { return array; } - private static long[] getLongsPrimitiveArray(Collection collection) { + private static long[] getLongsPrimitiveArray(Collection<?> collection) { int collectionSize = collection.size(); long[] array = new long[collectionSize]; Object[] objArray = collection.toArray(); @@ -709,7 +786,7 @@ public class ConfigurationUtils { return array; } - private static float[] getFloatsPrimitiveArray(Collection collection) { + private static float[] getFloatsPrimitiveArray(Collection<?> collection) { int collectionSize = collection.size(); float[] array = new float[collectionSize]; Object[] objArray = collection.toArray(); @@ -719,7 +796,7 @@ public class ConfigurationUtils { return array; } - private static double[] getDoublesPrimitiveArray(Collection collection) { + private static double[] getDoublesPrimitiveArray(Collection<?> collection) { int collectionSize = collection.size(); double[] array = new double[collectionSize]; Object[] objArray = collection.toArray(); @@ -729,7 +806,7 @@ public class ConfigurationUtils { return array; } - private static boolean[] getBooleansPrimitiveArray(Collection collection) { + private static boolean[] getBooleansPrimitiveArray(Collection<?> collection) { int collectionSize = collection.size(); boolean[] array = new boolean[collectionSize]; Object[] objArray = collection.toArray(); @@ -738,4 +815,15 @@ public class ConfigurationUtils { } return array; } + + private static char[] getCharsPrimitiveArray(Collection<?> collection) { + int collectionSize = collection.size(); + char[] array = new char[collectionSize]; + Object[] objArray = collection.toArray(); + for (int i = 0; i < collectionSize; i++) { + array[i] = (char) objArray[i]; + } + return array; + } + } diff --git a/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/ConfigurationImpl.java b/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/ConfigurationImpl.java index d13d5f7b92..0a5a141f09 100644 --- a/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/ConfigurationImpl.java +++ b/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/ConfigurationImpl.java @@ -27,12 +27,16 @@ import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.concurrent.atomic.AtomicReference; import java.util.function.Predicate; +import java.util.stream.Collectors; + import org.apache.commons.configuration2.ex.ConfigurationException; import org.onap.config.ConfigurationUtils; import org.onap.config.Constants; @@ -47,116 +51,21 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { private static final Logger LOGGER = LoggerFactory.getLogger(ConfigurationImpl.class); private static final String KEY_CANNOT_BE_NULL = "Key can't be null."; - private static final NonConfigResource NON_CONFIG_RESOURCE = new NonConfigResource(); + private static final Map<String, AggregateConfiguration> MODULE_CONFIG_STORE = new HashMap<>(); static { - - try { - init(); - } catch (ConfigurationException e) { - throw new IllegalStateException("Failed to initialize configuration", e); - } - } - - private static void init() throws ConfigurationException { - - Map<String, AggregateConfiguration> moduleConfigStore = new HashMap<>(); - List<URL> classpathResources = ConfigurationUtils.getAllClassPathResources(); - Predicate<URL> predicate = ConfigurationUtils::isConfig; - for (URL url : classpathResources) { - if (predicate.test(url)) { - String moduleName = ConfigurationUtils.getConfigurationRepositoryKey(url); - AggregateConfiguration moduleConfig = moduleConfigStore.get(moduleName); - if (moduleConfig == null) { - moduleConfig = new AggregateConfiguration(); - moduleConfigStore.put(moduleName, moduleConfig); - } - moduleConfig.addConfig(url); - } else { - NON_CONFIG_RESOURCE.add(url); - } - } - String configLocation = System.getProperty("config.location"); - if (!isBlank(configLocation)) { - File root = new File(configLocation); - Collection<File> filesystemResources = ConfigurationUtils.getAllFiles(root, true, false); - Predicate<File> filePredicate = ConfigurationUtils::isConfig; - for (File file : filesystemResources) { - if (filePredicate.test(file)) { - String moduleName = ConfigurationUtils.getConfigurationRepositoryKey(file); - AggregateConfiguration moduleConfig = moduleConfigStore.get(moduleName); - if (moduleConfig == null) { - moduleConfig = new AggregateConfiguration(); - moduleConfigStore.put(moduleName, moduleConfig); - } - moduleConfig.addConfig(file); - } else { - NON_CONFIG_RESOURCE.add(file); - } - } - } - String tenantConfigLocation = System.getProperty("tenant.config.location"); - if (!isBlank(tenantConfigLocation)) { - File root = new File(tenantConfigLocation); - Collection<File> tenantsRoot = ConfigurationUtils.getAllFiles(root, false, true); - Collection<File> filesystemResources = ConfigurationUtils.getAllFiles(root, true, false); - Predicate<File> filePredicate = ConfigurationUtils::isConfig; - for (File file : filesystemResources) { - if (filePredicate.test(file)) { - String moduleName = ConfigurationUtils.getNamespace(file); - for (File tenantFileRoot : tenantsRoot) { - if (file.getAbsolutePath().startsWith(tenantFileRoot.getAbsolutePath())) { - moduleName = ConfigurationUtils.getConfigurationRepositoryKey( - (tenantFileRoot.getName().toUpperCase() + Constants.TENANT_NAMESPACE_SEPARATOR - + moduleName).split(Constants.TENANT_NAMESPACE_SEPARATOR)); - } - } - AggregateConfiguration moduleConfig = moduleConfigStore.get(moduleName); - if (moduleConfig == null) { - moduleConfig = new AggregateConfiguration(); - moduleConfigStore.put(moduleName, moduleConfig); - } - moduleConfig.addConfig(file); - } - } - } - - populateFinalConfigurationIncrementally(moduleConfigStore); - String nodeConfigLocation = System.getProperty("node.config.location"); - if (!isBlank(nodeConfigLocation)) { - File root = new File(nodeConfigLocation); - Collection<File> filesystemResources = ConfigurationUtils.getAllFiles(root, true, false); - Predicate<File> filePredicate = ConfigurationUtils::isConfig; - for (File file : filesystemResources) { - if (filePredicate.test(file)) { - ConfigurationRepository.lookup().populateOverrideConfiguration( - ConfigurationUtils.getConfigurationRepositoryKey( - ConfigurationUtils.getNamespace(file).split(Constants.TENANT_NAMESPACE_SEPARATOR)), - file); - } - } - } - } - - private static void populateFinalConfigurationIncrementally(Map<String, AggregateConfiguration> configs) { - - if (configs.get(Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + Constants.DB_NAMESPACE) != null) { - ConfigurationRepository.lookup().populateConfiguration( - Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + Constants.DB_NAMESPACE, - configs.remove(Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + Constants.DB_NAMESPACE) - .getFinalConfiguration()); - } - - Set<String> modules = configs.keySet(); - for (String module : modules) { - ConfigurationRepository.lookup().populateConfiguration(module, configs.get(module).getFinalConfiguration()); + if (!loadClassPathConfigurationsAndResources() + || !loadAdditionalConfigurationsAndResources() + || !loadTenantConfigurations()) { + throw new IllegalStateException("Failed to initialize configuration"); } + populateFinalConfigurationIncrementally(MODULE_CONFIG_STORE); + loadNodeSpecificConfigurations(); } @Override public <T> T get(String tenant, String namespace, String key, Class<T> clazz, Hint... hints) { - String[] tenantNamespaceArray; if (tenant == null && namespace != null) { tenantNamespaceArray = namespace.split(Constants.TENANT_NAMESPACE_SEPARATOR); @@ -166,57 +75,46 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { } } - tenant = ConfigurationRepository.lookup().isValidTenant(tenant) ? tenant.toUpperCase() - : Constants.DEFAULT_TENANT; - namespace = ConfigurationRepository.lookup().isValidNamespace(namespace) ? namespace.toUpperCase() - : Constants.DEFAULT_NAMESPACE; + tenant = ConfigurationRepository.lookup().isValidTenant(tenant) ? tenant.toUpperCase() : Constants.DEFAULT_TENANT; + namespace = ConfigurationRepository.lookup().isValidNamespace(namespace) ? namespace.toUpperCase() : Constants.DEFAULT_NAMESPACE; + hints = hints == null || hints.length == 0 ? new Hint[]{Hint.EXTERNAL_LOOKUP, Hint.NODE_SPECIFIC} : hints; T returnValue; - returnValue = (T) getInternal(tenant, namespace, key, clazz.isPrimitive() ? getWrapperClass(clazz) : clazz, - hints == null || hints.length == 0 ? new Hint[] {Hint.EXTERNAL_LOOKUP, Hint.NODE_SPECIFIC} : hints); + returnValue = getInternal(tenant, namespace, key, clazz, hints); if ((returnValue == null || ConfigurationUtils.isZeroLengthArray(clazz, returnValue)) - && !Constants.DEFAULT_TENANT.equals(tenant)) { - returnValue = (T) getInternal(Constants.DEFAULT_TENANT, namespace, key, - clazz.isPrimitive() ? getWrapperClass(clazz) : clazz, - hints == null || hints.length == 0 ? new Hint[] {Hint.EXTERNAL_LOOKUP, Hint.NODE_SPECIFIC} : hints); + && !Constants.DEFAULT_TENANT.equals(tenant)) { + returnValue = getInternal(Constants.DEFAULT_TENANT, namespace, key, clazz, hints); } if ((returnValue == null || ConfigurationUtils.isZeroLengthArray(clazz, returnValue)) - && !Constants.DEFAULT_NAMESPACE.equals(namespace)) { - returnValue = (T) getInternal(tenant, Constants.DEFAULT_NAMESPACE, key, - clazz.isPrimitive() ? getWrapperClass(clazz) : clazz, - hints == null || hints.length == 0 ? new Hint[] {Hint.EXTERNAL_LOOKUP, Hint.NODE_SPECIFIC} : hints); + && !Constants.DEFAULT_NAMESPACE.equals(namespace)) { + returnValue = getInternal(tenant, Constants.DEFAULT_NAMESPACE, key, clazz, hints); } if ((returnValue == null || ConfigurationUtils.isZeroLengthArray(clazz, returnValue)) - && !Constants.DEFAULT_NAMESPACE.equals(namespace) && !Constants.DEFAULT_TENANT.equals(tenant)) { - returnValue = (T) getInternal(Constants.DEFAULT_TENANT, Constants.DEFAULT_NAMESPACE, key, - clazz.isPrimitive() ? getWrapperClass(clazz) : clazz, - hints == null || hints.length == 0 ? new Hint[] {Hint.EXTERNAL_LOOKUP, Hint.NODE_SPECIFIC} : hints); + && !Constants.DEFAULT_NAMESPACE.equals(namespace) && !Constants.DEFAULT_TENANT.equals(tenant)) { + returnValue = getInternal(Constants.DEFAULT_TENANT, Constants.DEFAULT_NAMESPACE, key, clazz, hints); } - if (returnValue == null && clazz.isPrimitive()) { - return (T) ConfigurationUtils.getDefaultFor(clazz); - } else { - return returnValue; + if (returnValue == null && ConfigurationUtils.isAPrimitive(clazz)) { + returnValue = (T) ConfigurationUtils.getDefaultFor(clazz); } + return returnValue; } @Override public <T> Map<String, T> populateMap(String tenantId, String namespace, String key, Class<T> clazz) { - - tenantId = calculateTenant(tenantId); - namespace = calculateNamespace(namespace); + final String calculatedTenantId = calculateTenant(tenantId); + final String calculatedNamespace = calculateNamespace(namespace); Map<String, T> map = new HashMap<>(); Iterator<String> keys; try { - keys = ConfigurationRepository.lookup().getConfigurationFor(tenantId, namespace).getKeys(key); - while (keys.hasNext()) { - String k = keys.next(); + keys = ConfigurationRepository.lookup().getConfigurationFor(calculatedTenantId, calculatedNamespace).getKeys(key); + keys.forEachRemaining(k -> { if (k.startsWith(key + ".")) { k = k.substring(key.length() + 1); String subkey = k.substring(0, k.indexOf('.')); if (!map.containsKey(subkey)) { - map.put(subkey, get(tenantId, namespace, key + "." + subkey, clazz)); + map.put(subkey, get(calculatedTenantId, calculatedNamespace, key + "." + subkey, clazz)); } } - } + }); } catch (Exception e) { LOGGER.warn( "Couldn't populate map fot tenant: {}, namespace: {}, key: {}, type: {}", @@ -231,47 +129,23 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { } @Override - public Map generateMap(String tenantId, String namespace, String key) { - - tenantId = calculateTenant(tenantId); - namespace = calculateNamespace(namespace); - - Map map; - Map parentMap = new HashMap<>(); - Iterator<String> keys; + public Map<Object, Object> generateMap(String tenantId, String namespace, String key) { + final String calculatedTenantId = calculateTenant(tenantId); + final String calculatedNamespace = calculateNamespace(namespace); + Map<Object, Object> parentMap = new HashMap<>(); + Iterator<String> configKeys; try { if (isBlank(key)) { - keys = ConfigurationRepository.lookup().getConfigurationFor(tenantId, namespace).getKeys(); + configKeys = ConfigurationRepository.lookup().getConfigurationFor(calculatedTenantId, calculatedNamespace).getKeys(); } else { - keys = ConfigurationRepository.lookup().getConfigurationFor(tenantId, namespace).getKeys(key); + configKeys = ConfigurationRepository.lookup().getConfigurationFor(calculatedTenantId, calculatedNamespace).getKeys(key); } - while (keys.hasNext()) { - map = parentMap; - String k = keys.next(); - - if (!isBlank(key) && !k.startsWith(key + ".")) { - continue; - } - String value = getAsString(tenantId, namespace, k); - if (!isBlank(key) && k.startsWith(key + ".")) { - k = k.substring(key.trim().length() + 1); + configKeys.forEachRemaining(subKey -> { + if (!isBlank(key) && !subKey.startsWith(key + ".")) { + configKeys.remove(); } - - while (k.contains(".")) { - if (k.contains(".")) { - String subkey = k.substring(0, k.indexOf('.')); - k = k.substring(k.indexOf('.') + 1); - if (!map.containsKey(subkey)) { - Map tmp = new HashMap(); - map.put(subkey, tmp); - map = tmp; - } else { - map = (Map) map.get(subkey); - } - } - } - map.put(k, value); - } + parseConfigSubKeys(subKey, key, calculatedTenantId, calculatedNamespace, parentMap); + }); } catch (Exception e) { LOGGER.warn( "Couldn't generate map fot tenant: {}, namespace: {}, key: {}", @@ -284,6 +158,159 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { return parentMap; } + private static boolean loadClassPathConfigurationsAndResources() { + List<URL> classpathResources = ConfigurationUtils.getAllClassPathResources(); + Predicate<URL> predicate = ConfigurationUtils::isConfig; + Map<Boolean, List<URL>> resources = classpathResources.stream().collect(Collectors.partitioningBy(predicate)); + List<URL> configResources = resources.get(true); + List<URL> nonConfigResources = resources.get(false); + AtomicReference<Boolean> successFlagHolder = new AtomicReference<>(true); + + configResources.forEach(url -> successFlagHolder.set(setUpdateModuleConfigStore(url))); + + nonConfigResources.forEach(NON_CONFIG_RESOURCE::add); + + return successFlagHolder.get(); + } + + private static boolean loadAdditionalConfigurationsAndResources() { + String configLocation = System.getProperty("config.location"); + AtomicReference<Boolean> successFlagHolder = new AtomicReference<>(true); + if (!isBlank(configLocation)) { + File root = new File(configLocation); + Collection<File> filesystemResources = ConfigurationUtils.getAllFiles(root, true, false); + Predicate<File> filePredicate = ConfigurationUtils::isConfig; + Map<Boolean, List<File>> resources = filesystemResources.stream().collect(Collectors.partitioningBy(filePredicate)); + List<File> configResources = resources.get(true); + List<File> nonConfigResources = resources.get(false); + + configResources.forEach(file -> successFlagHolder.set(setUpdateModuleConfigStore(file))); + + nonConfigResources.forEach(NON_CONFIG_RESOURCE::add); + } + return successFlagHolder.get(); + } + + private static boolean loadTenantConfigurations() { + String tenantConfigLocation = System.getProperty("tenant.config.location"); + AtomicReference<Boolean> successFlagHolder = new AtomicReference<>(true); + if (!isBlank(tenantConfigLocation)) { + File root = new File(tenantConfigLocation); + Collection<File> tenantsRoot = ConfigurationUtils.getAllFiles(root, false, true); + Collection<File> filesystemResources = ConfigurationUtils.getAllFiles(root, true, false); + + Map<Boolean, List<File>> resources = filesystemResources.stream().collect(Collectors.partitioningBy(ConfigurationUtils::isConfig)); + Collection<File> tenantResources = resources.get(true); + + tenantResources.forEach(configFile -> { + AtomicReference<String> moduleNameHolder = new AtomicReference<>(ConfigurationUtils.getNamespace(configFile)); + Predicate<File> startsWithRootPredicate = tenantRoot -> configFile.getAbsolutePath().startsWith(tenantRoot.getAbsolutePath()); + Collection<File> matchesTenantRoot = tenantsRoot.stream().filter(startsWithRootPredicate).collect(Collectors.toCollection(ArrayList::new)); + AtomicReference<String[]> altResource = new AtomicReference<>(); + matchesTenantRoot.forEach(file -> altResource.set( + (file.getName().toUpperCase() + Constants.TENANT_NAMESPACE_SEPARATOR + moduleNameHolder.get()) + .split(Constants.TENANT_NAMESPACE_SEPARATOR) + ) + ); + successFlagHolder.set(setUpdateModuleConfigStore(configFile, altResource.get())); + }); + } + return successFlagHolder.get(); + } + + private static void loadNodeSpecificConfigurations() { + String nodeConfigLocation = System.getProperty("node.config.location"); + if (!isBlank(nodeConfigLocation)) { + File root = new File(nodeConfigLocation); + Collection<File> filesystemResources = ConfigurationUtils.getAllFiles(root, true, false); + filesystemResources.stream().filter(ConfigurationUtils::isConfig).forEach( + file -> ConfigurationRepository.lookup().populateOverrideConfiguration( + ConfigurationUtils.getConfigurationRepositoryKey( + ConfigurationUtils.getNamespace(file).split(Constants.TENANT_NAMESPACE_SEPARATOR)), file) + ); + } + } + + private static void populateFinalConfigurationIncrementally(Map<String, AggregateConfiguration> configs) { + if (configs.get(Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + Constants.DB_NAMESPACE) != null) { + ConfigurationRepository.lookup().populateConfiguration( + Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + Constants.DB_NAMESPACE, + configs.remove(Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + Constants.DB_NAMESPACE) + .getFinalConfiguration()); + } + Set<String> modules = configs.keySet(); + modules.forEach( + m -> ConfigurationRepository.lookup().populateConfiguration(m, configs.get(m).getFinalConfiguration()) + ); + } + + private static <T> boolean setUpdateModuleConfigStore(T resource, String... namedResources) { + boolean success = true; + String moduleName; + try { + if (namedResources == null || namedResources.length == 0) { + moduleName = getConfigurationRepositoryKeyWrapper(resource); + } else { + moduleName = getConfigurationRepositoryKeyWrapper(namedResources); + } + moduleAddConfigWrapper(moduleName, resource); + } catch (Exception e) { + success = false; + LOGGER.error("Error occurred while processing config resource {}", resource, e); + } + return success; + } + + private static <T> String getConfigurationRepositoryKeyWrapper(T resource) throws ConfigurationException { + switch (resource.getClass().getSimpleName()) { + case "URL": + return ConfigurationUtils.getConfigurationRepositoryKey((URL) resource); + case "File": + return ConfigurationUtils.getConfigurationRepositoryKey((File) resource); + case "String[]": + return ConfigurationUtils.getConfigurationRepositoryKey((String[]) resource); + default: + throw new ConfigurationException("Unsupported resource type."); + } + } + + private static <T> void moduleAddConfigWrapper(String moduleName, T resource) throws ConfigurationException { + AggregateConfiguration moduleConfig = MODULE_CONFIG_STORE.get(moduleName); + if (moduleConfig == null) { + moduleConfig = new AggregateConfiguration(); + MODULE_CONFIG_STORE.put(moduleName, moduleConfig); + } + switch (resource.getClass().getSimpleName()) { + case "URL": + moduleConfig.addConfig((URL) resource); + break; + case "File": + moduleConfig.addConfig((File) resource); + break; + default: + throw new ConfigurationException("Unsupported resource type."); + } + } + + private void parseConfigSubKeys(String subKey, String keyPrefix, String tenantId, String namespace, Map<Object, Object> targetMap) { + String value = getAsString(tenantId, namespace, subKey); + if (!isBlank(keyPrefix) && subKey.startsWith(keyPrefix + ".")) { + subKey = subKey.substring(keyPrefix.trim().length() + 1); + } + while (subKey.contains(".")) { + String subSubKey = subKey.substring(0, subKey.indexOf('.')); + subKey = subKey.substring(subKey.indexOf('.') + 1); + if (!targetMap.containsKey(subSubKey)) { + Map<Object, Object> subMap = new HashMap<>(); + targetMap.put(subSubKey, subMap); + targetMap = subMap; + } else { + targetMap = (Map<Object, Object>) targetMap.get(subSubKey); + } + } + targetMap.put(subKey, value); + } + protected <T> T getInternal(String tenant, String namespace, String key, Class<T> clazz, Hint... hints) { int processingHints = Hint.DEFAULT.value(); if (hints != null) { @@ -303,50 +330,16 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { throw new IllegalArgumentException("clazz is null."); } - if (clazz.isPrimitive()) { + if (ConfigurationUtils.isAPrimitive(clazz)) { clazz = getWrapperClass(clazz); } try { - if (ConfigurationUtils.isWrapperClass(clazz) || clazz.isPrimitive()) { - Object obj = ConfigurationUtils.getProperty( - ConfigurationRepository.lookup().getConfigurationFor(tenant, namespace), key, processingHints); - if (obj != null) { - if (ConfigurationUtils.isCollection(obj.toString())) { - obj = ConfigurationUtils.getCollectionString(obj.toString()); - } - String value = obj.toString().split(",")[0]; - value = ConfigurationUtils.processVariablesIfPresent(tenant, namespace, value); - return (T) getValue(value, clazz.isPrimitive() ? getWrapperClass(clazz) : clazz, processingHints); - } else { - return null; - } - } else if (clazz.isArray() && (clazz.getComponentType().isPrimitive() || ConfigurationUtils.isWrapperClass( - clazz.getComponentType()))) { - Object obj = ConfigurationUtils.getProperty( - ConfigurationRepository.lookup().getConfigurationFor(tenant, namespace), key, processingHints); - if (obj != null) { - Class componentClass = clazz.getComponentType(); - if (clazz.getComponentType().isPrimitive()) { - componentClass = getWrapperClass(clazz.getComponentType()); - } - String collString = ConfigurationUtils.getCollectionString(obj.toString()); - ArrayList<String> tempCollection = new ArrayList<>(); - for (String itemValue : collString.split(",")) { - tempCollection.add(ConfigurationUtils.processVariablesIfPresent(tenant, namespace, itemValue)); - } - Collection<T> collection = - convert(ConfigurationUtils.getCollectionString(Arrays.toString(tempCollection.toArray())), - componentClass, processingHints); - if (clazz.getComponentType().isPrimitive()) { - return (T) ConfigurationUtils.getPrimitiveArray(collection, clazz.getComponentType()); - } else { - return (T) collection.toArray(getZeroLengthArrayFor(getWrapperClass(clazz.getComponentType()))); - } - } else { - return null; - } + if (ConfigurationUtils.isWrapperClass(clazz)) { + return getWrapperTypeValue(tenant, namespace, key, clazz, processingHints); + } else if (ConfigurationUtils.isAPrimitivesOrWrappersArray(clazz)) { + return getArrayTypeValue(tenant, namespace, key, clazz, processingHints); } else if (clazz.isAnnotationPresent(Config.class)) { - return read(tenant, namespace, clazz, isBlank(key) ? "" : (key + "."), hints); + return getAnnotatedTypeValue(tenant, namespace, clazz, isBlank(key) ? "" : (key + "."), hints); } else { throw new IllegalArgumentException( "Only primitive classes, wrapper classes, corresponding array classes and any " @@ -365,6 +358,51 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { return null; } + private <T> T getWrapperTypeValue(String tenant, String namespace, String key, Class<T> clazz, int processingHints) throws Exception { + Object obj = ConfigurationUtils.getProperty( + ConfigurationRepository.lookup().getConfigurationFor(tenant, namespace), key, processingHints); + if (obj != null) { + if (ConfigurationUtils.isCollection(obj.toString())) { + obj = ConfigurationUtils.getCollectionString(obj.toString()); + } + String value = ConfigurationUtils.processVariablesIfPresent( + tenant, + namespace, + obj.toString().split(",")[0] + ); + return (T) getTypeValue(value, clazz, processingHints); + } + return null; + } + + private <T> T getArrayTypeValue(String tenant, String namespace, String key, Class<T> clazz, int processingHints) throws Exception { + Object obj = ConfigurationUtils.getProperty( + ConfigurationRepository.lookup().getConfigurationFor(tenant, namespace), key, processingHints); + if (obj != null) { + Class componentType = clazz.getComponentType(); + if (ConfigurationUtils.isAPrimitivesArray(clazz)) { + componentType = getWrapperClass(componentType); + } + String collString = ConfigurationUtils.getCollectionString(obj.toString()); + ArrayList<String> tempCollection = new ArrayList<>(); + for (String itemValue : collString.split(",")) { + tempCollection.add(ConfigurationUtils.processVariablesIfPresent(tenant, namespace, itemValue)); + } + Collection<T> collection = convert( + ConfigurationUtils.getCollectionString(Arrays.toString(tempCollection.toArray())), + (Class<T>) componentType, + processingHints + ); + if (ConfigurationUtils.isAPrimitivesArray(clazz)) { + return (T) ConfigurationUtils.getPrimitiveArray(collection, componentType); + } else { + return (T) collection.toArray(getZeroLengthArrayFor(getWrapperClass(componentType))); + } + } else { + return null; + } + } + private static String calculateNamespace(String namespace) { if (isBlank(namespace)) { @@ -383,7 +421,7 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { return tenant.toUpperCase(); } - private <T> T read(String tenant, String namespace, Class<T> clazz, String keyPrefix, Hint... hints) + private <T> T getAnnotatedTypeValue(String tenant, String namespace, Class<T> clazz, String keyPrefix, Hint... hints) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { Config confAnnotation = clazz.getAnnotation(Config.class); @@ -396,53 +434,72 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Config fieldConfAnnotation = field.getAnnotation(Config.class); + Class<?> fieldType = field.getType(); if (fieldConfAnnotation != null) { - if (field.getType().isPrimitive() || ConfigurationUtils.isWrapperClass(field.getType()) || ( - field.getType().isArray() && (field.getType().getComponentType().isPrimitive() - || ConfigurationUtils.isWrapperClass( - field.getType().getComponentType()))) - || field.getType().getAnnotation(Config.class) != null) { - field.set(objToReturn, - get(tenant, namespace, keyPrefix + fieldConfAnnotation.key(), field.getType(), hints)); - } else if (Collection.class.isAssignableFrom(field.getType())) { - Object obj = get(tenant, namespace, keyPrefix + fieldConfAnnotation.key(), - ConfigurationUtils.getArrayClass(ConfigurationUtils.getCollectionGenericType(field)), - hints); - if (obj != null) { - List list = Arrays.asList((Object[]) obj); - Class clazzToInstantiate; - if (field.getType().isInterface()) { - clazzToInstantiate = ConfigurationUtils.getConcreteCollection(field.getType()).getClass(); - } else if (Modifier.isAbstract(field.getType().getModifiers())) { - clazzToInstantiate = - ConfigurationUtils.getCompatibleCollectionForAbstractDef(field.getType()) - .getClass(); - } else { - clazzToInstantiate = field.getType(); - } - Constructor construct = getConstructorWithArguments(clazzToInstantiate, Collection.class); - - if (construct != null) { - construct.setAccessible(true); - field.set(objToReturn, construct.newInstance(list)); - } else { - construct = getConstructorWithArguments(clazzToInstantiate, Integer.class, - Boolean.class, Collection.class); - if (construct != null) { - construct.setAccessible(true); - field.set(objToReturn, construct.newInstance(list.size(), true, list)); - } - } - } - } else if (Map.class.isAssignableFrom(field.getType())) { - field.set(objToReturn, generateMap(tenant, namespace, keyPrefix + fieldConfAnnotation.key())); + if (ConfigurationUtils.isAPrimitiveOrWrapper(fieldType) || + ConfigurationUtils.isAPrimitivesOrWrappersArray(fieldType)) { + setPrimitiveField(field, objToReturn, tenant, namespace, keyPrefix, hints); + } + if (ConfigurationUtils.isACollection(fieldType)) { + setCollectionField(field, objToReturn, tenant, namespace, keyPrefix, hints); + } + if (ConfigurationUtils.isAMap(fieldType)) { + setMapField(field, objToReturn, tenant, namespace, keyPrefix); } } } return objToReturn; } - private Constructor getConstructorWithArguments(Class clazz, Class... classes) { + private void setPrimitiveField(Field field, Object objToReturn, String tenant, String namespace, String keyPrefix, Hint[] hints) + throws IllegalAccessException { + String fieldConfAnnotationKey = field.getAnnotation(Config.class).key(); + Class<?> fieldType = field.getType(); + field.set(objToReturn, get(tenant, namespace, keyPrefix + fieldConfAnnotationKey, fieldType, hints)); + } + + private void setMapField(Field field, Object objToReturn, String tenant, String namespace, String keyPrefix) + throws IllegalAccessException { + String fieldConfAnnotationKey = field.getAnnotation(Config.class).key(); + field.set(objToReturn, generateMap(tenant, namespace, keyPrefix + fieldConfAnnotationKey)); + } + + private void setCollectionField(Field field, Object objToReturn, String tenant, String namespace, String keyPrefix, Hint[] hints) + throws IllegalAccessException, InvocationTargetException, InstantiationException { + String fieldConfAnnotationKey = field.getAnnotation(Config.class).key(); + Class<?> fieldType = field.getType(); + Object obj = get(tenant, namespace, keyPrefix + fieldConfAnnotationKey, + ConfigurationUtils.getArrayClass(ConfigurationUtils.getCollectionGenericType(field)), + hints); + if (obj != null) { + List<Object> list = Arrays.asList((Object[]) obj); + Class clazzToInstantiate; + if (fieldType.isInterface()) { + clazzToInstantiate = ConfigurationUtils.getConcreteCollection(fieldType).getClass(); + } else if (Modifier.isAbstract(fieldType.getModifiers())) { + clazzToInstantiate = + ConfigurationUtils.getCompatibleCollectionForAbstractDef(fieldType) + .getClass(); + } else { + clazzToInstantiate = fieldType; + } + Constructor construct = getConstructorWithArguments(clazzToInstantiate, Collection.class); + + if (construct != null) { + construct.setAccessible(true); + field.set(objToReturn, construct.newInstance(list)); + } else { + construct = getConstructorWithArguments(clazzToInstantiate, Integer.class, + Boolean.class, Collection.class); + if (construct != null) { + construct.setAccessible(true); + field.set(objToReturn, construct.newInstance(list.size(), true, list)); + } + } + } + } + + private Constructor getConstructorWithArguments(Class<?> clazz, Class<?>... classes) { try { return clazz.getDeclaredConstructor(classes); } catch (Exception exception) { @@ -451,7 +508,7 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { } } - private Class getWrapperClass(Class clazz) { + private Class getWrapperClass(Class<?> clazz) { if (byte.class == clazz) { return Byte.class; } else if (short.class == clazz) { @@ -472,101 +529,82 @@ public class ConfigurationImpl implements org.onap.config.api.Configuration { return clazz; } - private <T> T getValue(Object obj, Class<T> clazz, int processingHint) { - + private <T> T getTypeValue(Object obj, Class<T> clazz, int processingHint) { if (obj == null || obj.toString().trim().length() == 0) { return null; } else { obj = obj.toString().trim(); } - if (String.class.equals(clazz)) { - if (obj.toString().startsWith("@") && ConfigurationUtils.isExternalLookup(processingHint)) { - String contents = ConfigurationUtils.getFileContents( - NON_CONFIG_RESOURCE.locate(obj.toString().substring(1).trim())); - if (contents == null) { - contents = ConfigurationUtils.getFileContents(obj.toString().substring(1).trim()); - } - if (contents != null) { - obj = contents; - } - } - return (T) obj.toString(); - } else if (Number.class.isAssignableFrom(clazz)) { - Double doubleValue = Double.valueOf(obj.toString()); - switch (clazz.getName()) { - case "java.lang.Byte": - Byte byteVal = doubleValue.byteValue(); - return (T) byteVal; - case "java.lang.Short": - Short shortVal = doubleValue.shortValue(); - return (T) shortVal; - case "java.lang.Integer": - Integer intVal = doubleValue.intValue(); - return (T) intVal; - case "java.lang.Long": - Long longVal = doubleValue.longValue(); - return (T) longVal; - case "java.lang.Float": - Float floatVal = doubleValue.floatValue(); - return (T) floatVal; - case "java.lang.Double": - return (T) doubleValue; - default: - } - } else if (Boolean.class.equals(clazz)) { + return getValueForStringType(obj, processingHint); + } + if (Number.class.isAssignableFrom(clazz)) { + return getValueForNumbersType(obj, clazz); + } + if (Boolean.class.equals(clazz)) { return (T) Boolean.valueOf(obj.toString()); - } else if (Character.class.equals(clazz)) { + } + if (Character.class.equals(clazz)) { return (T) Character.valueOf(obj.toString().charAt(0)); } return null; } + private <T> T getValueForStringType(Object obj, int processingHint) { + if (obj.toString().startsWith("@") && ConfigurationUtils.isExternalLookup(processingHint)) { + String subString = obj.toString().substring(1).trim(); + String contents = ConfigurationUtils.getFileContents( + NON_CONFIG_RESOURCE.locate(subString)); + if (contents == null) { + contents = ConfigurationUtils.getFileContents(subString); + } + if (contents != null) { + obj = contents; + } + } + return (T) obj.toString(); + } + + private <T> T getValueForNumbersType(Object obj, Class<T> clazz) { + Double doubleValue = Double.valueOf(obj.toString()); + switch (clazz.getName()) { + case "java.lang.Byte": + Byte byteVal = doubleValue.byteValue(); + return (T) byteVal; + case "java.lang.Short": + Short shortVal = doubleValue.shortValue(); + return (T) shortVal; + case "java.lang.Integer": + Integer intVal = doubleValue.intValue(); + return (T) intVal; + case "java.lang.Long": + Long longVal = doubleValue.longValue(); + return (T) longVal; + case "java.lang.Float": + Float floatVal = doubleValue.floatValue(); + return (T) floatVal; + case "java.lang.Double": + return (T) doubleValue; + default: + return null; + } + } + private <T> T[] getZeroLengthArrayFor(Class<T> clazz) { - Object obj = null; - if (clazz == int.class) { - obj = new int[] {}; - } else if (clazz == byte.class) { - obj = new byte[] {}; - } else if (clazz == short.class) { - obj = new short[] {}; - } else if (clazz == long.class) { - obj = new long[] {}; - } else if (clazz == float.class) { - obj = new float[] {}; - } else if (clazz == double.class) { - obj = new double[] {}; - } else if (clazz == boolean.class) { - obj = new boolean[] {}; - } else if (clazz == char.class) { - obj = new char[] {}; - } else if (clazz == Byte.class) { - obj = new Byte[] {}; - } else if (clazz == Short.class) { - obj = new Short[] {}; - } else if (clazz == Integer.class) { - obj = new Integer[] {}; - } else if (clazz == Long.class) { - obj = new Long[] {}; - } else if (clazz == Float.class) { - obj = new Float[] {}; - } else if (clazz == Double.class) { - obj = new Double[] {}; - } else if (clazz == Boolean.class) { - obj = new Boolean[] {}; - } else if (clazz == Character.class) { - obj = new Character[] {}; - } else if (clazz == String.class) { - obj = new String[] {}; - } - return (T[]) obj; + Object objToReturn = null; + if (ConfigurationUtils.isAPrimitive(clazz)) { + objToReturn = ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), clazz); + } else if (ConfigurationUtils.isWrapperClass(clazz)) { + objToReturn = ConfigurationUtils.getWrappersArray(Collections.emptyList(), clazz); + } + return (T[]) objToReturn; } private <T> Collection<T> convert(String commaSeparatedValues, Class<T> clazz, int processingHints) { ArrayList<T> collection = new ArrayList<>(); for (String value : commaSeparatedValues.split(",")) { try { - T type1 = getValue(value, clazz, processingHints); + T type1 = getTypeValue(value, clazz, processingHints); if (type1 != null) { collection.add(type1); } diff --git a/common/onap-common-configuration-management/onap-configuration-management-core/src/test/java/org/onap/config/ConfigurationUtilsTest.java b/common/onap-common-configuration-management/onap-configuration-management-core/src/test/java/org/onap/config/ConfigurationUtilsTest.java index dab8946883..cfb27d53db 100644 --- a/common/onap-common-configuration-management/onap-configuration-management-core/src/test/java/org/onap/config/ConfigurationUtilsTest.java +++ b/common/onap-common-configuration-management/onap-configuration-management-core/src/test/java/org/onap/config/ConfigurationUtilsTest.java @@ -20,6 +20,7 @@ package org.onap.config; import static java.util.stream.Collectors.toList; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertNotNull; @@ -36,7 +37,9 @@ import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Collections; import java.util.Deque; +import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; @@ -77,7 +80,7 @@ public class ConfigurationUtilsTest { @Test public void testCommaListWithNullAndEmptyStrings() { - List list = Arrays.asList(null, "", " "); + List<String> list = Arrays.asList(null, "", " "); String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list); assertTrue(commaSeparatedList.isEmpty()); } @@ -101,12 +104,12 @@ public class ConfigurationUtilsTest { @Test public void testCastingArray() { int arraySize = 2; - final Class[] primitiveType = new Class[]{boolean.class, byte.class, + final Class<?>[] primitiveType = new Class[]{boolean.class, byte.class, double.class, float.class, int.class, long.class, short.class}; - for (Class clazz: primitiveType) { - Class expectedResultClass = Array.newInstance(clazz, 0).getClass(); - List defaultCollection = IntStream.range(0, arraySize).mapToObj(i -> + for (Class<?> clazz : primitiveType) { + Class<?> expectedResultClass = Array.newInstance(clazz, 0).getClass(); + List<?> defaultCollection = IntStream.range(0, arraySize).mapToObj(i -> ConfigurationUtils.getDefaultFor(clazz)).collect(toList()); Object resultArray = ConfigurationUtils.getPrimitiveArray(defaultCollection, clazz); @@ -119,7 +122,7 @@ public class ConfigurationUtilsTest { @Test(expected = IllegalArgumentException.class) public void testGetCompatibleCollection() { - final Map<Class, Class> testClasses = Stream.of(new Class[][] { + final Map<Class<?>, Class<?>> testClasses = Stream.of(new Class<?>[][]{ {BlockingQueue.class, LinkedBlockingQueue.class}, {TransferQueue.class, LinkedTransferQueue.class}, {Deque.class, ArrayDeque.class}, @@ -130,9 +133,9 @@ public class ConfigurationUtilsTest { }).collect(Collectors.toMap(data -> data[0], data -> data[1])); testClasses.forEach((entryClass, expResultClass) -> { - Class resultClass = ConfigurationUtils.getCompatibleCollectionForAbstractDef(entryClass).getClass(); - assertEquals(expResultClass, resultClass); - } + Class<?> resultClass = ConfigurationUtils.getCompatibleCollectionForAbstractDef(entryClass).getClass(); + assertEquals(expResultClass, resultClass); + } ); ConfigurationUtils.getCompatibleCollectionForAbstractDef(Collection.class); @@ -140,6 +143,54 @@ public class ConfigurationUtilsTest { } @Test + public void testGetPrimitivesArrayZeroLength() { + assertArrayEquals(new int[0], (int[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), int.class)); + assertArrayEquals(new byte[0], (byte[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), byte.class)); + assertArrayEquals(new short[0], (short[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), short.class)); + assertArrayEquals(new long[0], (long[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), long.class)); + assertArrayEquals(new double[0], (double[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), double.class), 0); + assertArrayEquals(new float[0], (float[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), float.class), 0); + assertArrayEquals(new boolean[0], (boolean[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), boolean.class)); + assertArrayEquals(new char[0], (char[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), char.class)); + assertNull(ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), Integer.class)); + } + + @Test + public void testGetWrappersArrayZeroLength() { + assertArrayEquals(new Integer[0], (Integer[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Integer.class)); + assertArrayEquals(new Byte[0], (Byte[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Byte.class)); + assertArrayEquals(new Short[0], (Short[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Short.class)); + assertArrayEquals(new Long[0], (Long[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Long.class)); + assertArrayEquals(new Double[0], (Double[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Double.class)); + assertArrayEquals(new Float[0], (Float[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Float.class)); + assertArrayEquals(new Boolean[0], (Boolean[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Boolean.class)); + assertArrayEquals(new Character[0], (Character[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Character.class)); + assertNull(ConfigurationUtils.getWrappersArray(Collections.emptyList(), boolean.class)); + } + + @Test + public void testPrimitivesArrayNonZeroLength() { + List<Integer> list = new ArrayList<>(); + list.add(1); + list.add(2); + list.add(3); + list.add(4); + list.add(5); + assertArrayEquals(new int[]{1, 2, 3, 4, 5}, (int[]) ConfigurationUtils.getPrimitiveArray(list, int.class)); + } + + @Test + public void testWrappersArrayNonZeroLength() { + List<Integer> list = new ArrayList<>(); + list.add(1); + list.add(2); + list.add(3); + list.add(4); + list.add(5); + assertArrayEquals(new Integer[]{1, 2, 3, 4, 5}, (Integer[]) ConfigurationUtils.getWrappersArray(list, Integer.class)); + } + + @Test public void testGetAllFilesRecursiveIncludeAll() throws IOException { Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX); Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), true, false); @@ -207,6 +258,46 @@ public class ConfigurationUtilsTest { assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.NODE_SPECIFIC.value())); } + @Test + public void testIsAMap() { + assertTrue(ConfigurationUtils.isAMap(HashMap.class)); + assertFalse(ConfigurationUtils.isAMap(ArrayList.class)); + } + + @Test + public void testIsACollection() { + assertTrue(ConfigurationUtils.isACollection(ArrayList.class)); + assertFalse(ConfigurationUtils.isACollection(HashMap.class)); + } + + @Test + public void testIsAPrimitiveOrWrapper() { + assertTrue(ConfigurationUtils.isAPrimitiveOrWrapper(int.class)); + assertTrue(ConfigurationUtils.isAPrimitiveOrWrapper(Integer.class)); + assertFalse(ConfigurationUtils.isAPrimitiveOrWrapper(HashMap.class)); + } + + @Test + public void testIsAPrimitivesArray() { + assertTrue(ConfigurationUtils.isAPrimitivesArray(int[].class)); + assertFalse(ConfigurationUtils.isAPrimitivesArray(Integer[].class)); + assertFalse(ConfigurationUtils.isAPrimitivesArray(HashMap[].class)); + } + + @Test + public void testIsAWrapperArray() { + assertTrue(ConfigurationUtils.isAWrappersArray(Integer[].class)); + assertFalse(ConfigurationUtils.isAWrappersArray(int[].class)); + assertFalse(ConfigurationUtils.isAWrappersArray(HashMap[].class)); + } + + @Test + public void testIsAPrimitivesOrWrapperArray() { + assertTrue(ConfigurationUtils.isAPrimitivesOrWrappersArray(int[].class)); + assertTrue(ConfigurationUtils.isAPrimitivesOrWrappersArray(Integer[].class)); + assertFalse(ConfigurationUtils.isAPrimitivesOrWrappersArray(HashMap[].class)); + } + private ConfigurationRepository populateTestBaseConfig() { BaseConfiguration inputConfig = new PropertiesConfiguration(); inputConfig.setProperty(Constants.NAMESPACE_KEY, TEST_NAME_SPACE); @@ -220,8 +311,8 @@ public class ConfigurationUtilsTest { private ConfigurationRepository populateTestCompositeConfig() { CompositeConfiguration inputCompositeConfig = new CompositeConfiguration(); - Configuration inputConfig1= new BaseConfiguration(); - Configuration inputConfig2= new BaseConfiguration(); + Configuration inputConfig1 = new BaseConfiguration(); + Configuration inputConfig2 = new BaseConfiguration(); inputConfig1.setProperty(Constants.NAMESPACE_KEY, TEST_NAME_SPACE); inputCompositeConfig.addConfiguration(inputConfig1); inputCompositeConfig.addConfigurationFirst(inputConfig2); |