diff options
Diffstat (limited to 'openecomp-be/lib/openecomp-core-lib')
7 files changed, 203 insertions, 246 deletions
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-api/src/main/java/org/openecomp/core/factory/impl/AbstractFactoryBase.java b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-api/src/main/java/org/openecomp/core/factory/impl/AbstractFactoryBase.java index 9d25a09758..3a117ef063 100644 --- a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-api/src/main/java/org/openecomp/core/factory/impl/AbstractFactoryBase.java +++ b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-api/src/main/java/org/openecomp/core/factory/impl/AbstractFactoryBase.java @@ -16,170 +16,17 @@ package org.openecomp.core.factory.impl; -import static org.openecomp.core.utilities.CommonMethods.newInstance; - -import java.util.Collection; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; - -import org.apache.commons.lang3.StringUtils; -import org.openecomp.sdc.common.errors.CoreException; -import org.openecomp.sdc.common.errors.ErrorCategory; -import org.openecomp.sdc.common.errors.ErrorCode; - public abstract class AbstractFactoryBase { - /** - * Temporary registry of default implementations. The map keeps class names rather then class - * types to allow unloading of those classes from memory by garbage collector if factory is not - * actually used. - */ - private static final Map<String, String> REGISTRY = new ConcurrentHashMap<>(); - - /** - * Cached factory instances. - */ - private static final Map<String, AbstractFactoryBase> FACTORY_MAP = new ConcurrentHashMap<>(); - public static final String E0001 = "E0001"; - - /** - * Registers implementor for an abstract factory. The method accepts Java classes rather then - * class names to ensure type safety at compilation time. - * - * @param <I> Java interface type instantiated by abstract factory - * @param <F> Type specific abstract factory for concrete Java interface - * @param factory Java class of a type specific abstract factory - * @param impl Java class of type specific factory implementor - */ - public static <I, F extends AbstractFactoryBase> void registerFactory(Class<F> factory, - Class<? extends F> impl) { - if (factory == null) { - throw new CoreException( - new ErrorCode.ErrorCodeBuilder().withId(E0001).withMessage("Mandatory input factory.") - .withCategory(ErrorCategory.SYSTEM).build()); - } - - if (impl == null) { - throw new CoreException( - new ErrorCode.ErrorCodeBuilder().withId(E0001).withMessage("Mandatory input impl.") - .withCategory(ErrorCategory.SYSTEM).build()); - } - if (FACTORY_MAP.containsKey(factory.getName())) { - FACTORY_MAP.remove(factory.getName()); - } - REGISTRY.put(factory.getName(), impl.getName()); - } // registerFactory - - // TODO: Remove - protected static void registerFactory(String factoryName, String implName) { - REGISTRY.put(factoryName, implName); - } // registerFactory - - /** - * Unregister factory. - * - * @param <F> the type parameter - * @param factory the factory - */ - public static <F extends AbstractFactoryBase> void unregisterFactory(Class<F> factory) { - if (factory == null) { - throw new CoreException( - new ErrorCode.ErrorCodeBuilder().withId(E0001).withMessage("Mandatory input factory.") - .withCategory(ErrorCategory.SYSTEM).build()); - } - - FACTORY_MAP.remove(factory.getName()); - } - /** * Instantiates the configured implementation of an abstract factory. * - * @param <I> Java interface type instantiated by abstract factory * @param <F> Type specific abstract factory for concrete Java interface * @param factoryType Java class of type specific abstract factory * @return Instance of implementation class */ - @SuppressWarnings("unchecked") - public static <I, F extends AbstractFactoryBase> F getInstance(Class<F> factoryType) { - if (factoryType == null) { - throw new CoreException( - new ErrorCode.ErrorCodeBuilder().withId(E0001) - .withMessage("Mandatory input factory type.").withCategory(ErrorCategory.SYSTEM) - .build()); - - } - // Pick up factory instance from cache - F factory = (F) FACTORY_MAP.get(factoryType.getName()); - // Check for the first time access - if (factory == null) { - // Synchronize factory instantiation - synchronized (FACTORY_MAP) { - // Re-check the factory instance - factory = (F) FACTORY_MAP.get(factoryType.getName()); - if (factory == null) { - // Get the implementation class name - String implName = REGISTRY.get(factoryType.getName()); - - if (StringUtils.isEmpty(implName)) { - throw new CoreException( - new ErrorCode.ErrorCodeBuilder().withId(E0001) - .withMessage("Mandatory input factory implementation.") - .withCategory(ErrorCategory.SYSTEM).build()); - } - - factory = newInstance(implName, factoryType); - - factory.init(); - - // Cache the instantiated singleton - FACTORY_MAP.put(factoryType.getName(), factory); - } - } - } - - return factory; - - } // getInstance - - - /** - * Is factory registered boolean. - * - * @param <F> the type parameter - * @param factoryType the factory type - * @return the boolean - */ - public static <F extends AbstractFactoryBase> boolean isFactoryRegistered(Class<F> factoryType) { - boolean isFactoryRegistered = false; - if (factoryType == null) { - throw new CoreException( - new ErrorCode.ErrorCodeBuilder().withId(E0001) - .withMessage("Mandatory input factory type.").withCategory(ErrorCategory.SYSTEM) - .build()); - } - // Pick up factory instance from cache - F factory = (F) FACTORY_MAP.get(factoryType.getName()); - // Check for the first time access - if (factory != null) { - isFactoryRegistered = true; - } else { - // Get the implementation class name - String implName = REGISTRY.get(factoryType.getName()); - if (StringUtils.isNotEmpty(implName)) { - isFactoryRegistered = true; - } - } - return isFactoryRegistered; - } - - /** - * Stop all. - */ - public static void stopAll() { - Collection<AbstractFactoryBase> factorylist = FACTORY_MAP.values(); - for (AbstractFactoryBase factory : factorylist) { - factory.stop(); - } + public static <F extends AbstractFactoryBase> F getInstance(Class<F> factoryType) { + return FactoryManager.getInstance().getFactoryInstance(factoryType); } protected void init() { diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-api/src/main/java/org/openecomp/core/factory/impl/FactoryManager.java b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-api/src/main/java/org/openecomp/core/factory/impl/FactoryManager.java new file mode 100644 index 0000000000..ec2d93f35b --- /dev/null +++ b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-api/src/main/java/org/openecomp/core/factory/impl/FactoryManager.java @@ -0,0 +1,150 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2019 Nordix Foundation + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.openecomp.core.factory.impl; + +import com.amdocs.zusammen.utils.facade.impl.FactoryConfig; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import org.apache.commons.lang3.StringUtils; +import org.openecomp.core.utilities.CommonMethods; +import org.openecomp.sdc.common.errors.CoreException; +import org.openecomp.sdc.common.errors.ErrorCategory; +import org.openecomp.sdc.common.errors.ErrorCode; + +public class FactoryManager { + + private static final FactoryManager instance = new FactoryManager(); + private static final String ERROR_CODE_E0001 = "E0001"; + /** + * Temporary registry of default implementations. The map keeps class names rather then class + * types to allow unloading of those classes from memory by garbage collector if factory is not + * actually used. + */ + private final Map<String, String> factoryRegistry = new ConcurrentHashMap<>(); + /** + * Cached factory instances. + */ + private final Map<String, AbstractFactoryBase> factoryInstanceMap = new ConcurrentHashMap<>(); + + + private FactoryManager() { + initializeFactoryRegistry(); + } + + public static synchronized FactoryManager getInstance() { + return instance; + } + + private void initializeFactoryRegistry() { + final Map<String, String> factoryMap = FactoryConfig.getFactoriesMap(); + + for (final Map.Entry<String, String> entry : factoryMap.entrySet()) { + final String abstractClassName = entry.getKey(); + final String concreteTypeName = entry.getValue(); + + if (StringUtils.isEmpty(concreteTypeName)) { + throw new CoreException( + new ErrorCode.ErrorCodeBuilder().withId("E0003") + .withMessage("Missing configuration value:" + concreteTypeName + ".") + .withCategory(ErrorCategory.SYSTEM).build()); + + } + registerFactory(abstractClassName, concreteTypeName); + } + } + + /** + * Instantiates the configured implementation of an abstract factory. + * + * @param <F> Type specific abstract factory for concrete Java interface + * @param factoryType Java class of type specific abstract factory + * @return Instance of implementation class + */ + @SuppressWarnings("unchecked") + public <F extends AbstractFactoryBase> F getFactoryInstance(Class<F> factoryType) { + if (factoryType == null) { + throw new CoreException( + new ErrorCode.ErrorCodeBuilder().withId(ERROR_CODE_E0001) + .withMessage("Mandatory input factory type.").withCategory(ErrorCategory.SYSTEM) + .build()); + + } + final String factoryTypeName = factoryType.getName(); + // Check if the factory is already cached + if (factoryInstanceMap.get(factoryTypeName) == null) { + //if not, create a new one and cache it + // Get the implementation class name + final String implName = factoryRegistry.get(factoryTypeName); + + if (StringUtils.isEmpty(implName)) { + throw new CoreException( + new ErrorCode.ErrorCodeBuilder().withId(ERROR_CODE_E0001) + .withMessage("Mandatory input factory implementation.") + .withCategory(ErrorCategory.SYSTEM).build()); + } + + F factory = CommonMethods.newInstance(implName, factoryType); + factory.init(); + // Cache the instantiated singleton + factoryInstanceMap.putIfAbsent(factoryTypeName, factory); + } + + return (F) factoryInstanceMap.get(factoryTypeName); + } + + public void registerFactory(final String factoryName, final String implName) { + factoryRegistry.put(factoryName, implName); + } + + /** + * Unregister factory and removes the cached instance if any. + * @param factoryName the factory name to unregister + */ + public void unregisterFactory(final String factoryName) { + final String factoryClass = factoryRegistry.get(factoryName); + if (StringUtils.isNotEmpty(factoryClass)) { + factoryInstanceMap.remove(factoryClass); + factoryRegistry.remove(factoryName); + } + } + + /** + * Removes the cached factory instance if any. + * + * @param <F> the type parameter + * @param factory the factory + */ + public <F extends AbstractFactoryBase> void removeFactoryInstance(Class<F> factory) { + if (factory == null) { + throw new CoreException( + new ErrorCode.ErrorCodeBuilder().withId(ERROR_CODE_E0001).withMessage("Mandatory input factory.") + .withCategory(ErrorCategory.SYSTEM).build()); + } + + factoryInstanceMap.remove(factory.getName()); + } + + /** + * Stop all. + */ + public void stopAll() { + factoryInstanceMap.values().forEach(AbstractFactoryBase::stop); + } +} diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/FactoriesConfigImpl.java b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/FactoriesConfigImpl.java index 15b9f8c1c8..31df923bdd 100644 --- a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/FactoriesConfigImpl.java +++ b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/FactoriesConfigImpl.java @@ -31,31 +31,24 @@ import java.util.Map; public final class FactoriesConfigImpl implements FactoriesConfiguration { + private final Map factoryConfigurationMap = new HashMap(); - private static final String FACTORY_CONFIG_FILE_NAME = "factoryConfiguration.json"; - private static final Map FACTORY_MAP = new HashMap(); - private static boolean initialized = false; + public FactoriesConfigImpl() { + init(); + } @SuppressWarnings("unchecked") @Override public Map<String, String> getFactoriesMap() { - synchronized (this) { - if (!initialized) { - init(); - initialized = true; - } - } - return FACTORY_MAP; + return factoryConfigurationMap; } private void init() { - - List<URL> factoryConfigUrlList = FileUtils.getAllLocations(FACTORY_CONFIG_FILE_NAME); - for (URL factoryConfigUrl : factoryConfigUrlList) { - + final List<URL> factoryConfigUrlList = FileUtils.getAllLocations("factoryConfiguration.json"); + for (final URL factoryConfigUrl : factoryConfigUrlList) { try (InputStream stream = factoryConfigUrl.openStream()) { - FACTORY_MAP.putAll(JsonUtil.json2Object(stream, Map.class)); - } catch (IOException e) { + factoryConfigurationMap.putAll(JsonUtil.json2Object(stream, Map.class)); + } catch (final IOException e) { throw new SdcConfigurationException("Failed to initialize Factory from '" + factoryConfigUrl.getPath() +"'", e); } } diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/FactoryConfig.java b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/FactoryConfig.java index 31822b6bdc..7dbf921ebf 100644 --- a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/FactoryConfig.java +++ b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/FactoryConfig.java @@ -20,23 +20,17 @@ package org.openecomp.core.factory; +import java.util.Map; import org.openecomp.core.factory.api.FactoriesConfiguration; import org.openecomp.core.utilities.CommonMethods; -import java.util.Map; - public final class FactoryConfig { - private static final FactoriesConfiguration INSTANCE; + private static final FactoriesConfiguration INSTANCE = CommonMethods.newInstance( + "org.openecomp.core.factory.FactoriesConfigImpl", FactoriesConfiguration.class); - static { + private FactoryConfig() { - try { - INSTANCE = CommonMethods.newInstance( - "org.openecomp.core.factory.FactoriesConfigImpl", FactoriesConfiguration.class); - } catch (Exception exception) { - throw exception; - } } public static Map<String, String> getFactoriesMap() { diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/api/AbstractComponentFactory.java b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/api/AbstractComponentFactory.java index 1ea6fe8d43..3de0d88f43 100644 --- a/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/api/AbstractComponentFactory.java +++ b/openecomp-be/lib/openecomp-core-lib/openecomp-facade-lib/openecomp-facade-core/src/main/java/org/openecomp/core/factory/api/AbstractComponentFactory.java @@ -16,66 +16,5 @@ package org.openecomp.core.factory.api; -import org.apache.commons.lang3.StringUtils; -import org.openecomp.core.factory.FactoryConfig; -import org.openecomp.core.factory.impl.AbstractFactoryBase; -import org.openecomp.sdc.common.errors.CoreException; -import org.openecomp.sdc.common.errors.ErrorCategory; -import org.openecomp.sdc.common.errors.ErrorCode; - -import java.util.Map; - public abstract class AbstractComponentFactory<I> extends AbstractFactory<I> { - - static { - Registry registry = new RegistryImpl(); - InitializationHelper.registerFactoryMapping(registry); - } - - @FunctionalInterface - interface Registry { - void register(String factory, String impl); - } - - private static class RegistryImpl implements Registry { - @Override - public void register(String factory, String impl) { - AbstractFactoryBase.registerFactory(factory, impl); - } - } - - static class InitializationHelper { - - - private static boolean isRegistered = false; - - private InitializationHelper() { - } - - static synchronized void registerFactoryMapping(Registry registry) { - if (!isRegistered) { - registerFactoryMappingImpl(registry); - isRegistered = true; - } - } - - private static void registerFactoryMappingImpl(Registry registry) { - Map<String, String> factoryMap = FactoryConfig.getFactoriesMap(); - - for (Map.Entry<String, String> entry : factoryMap.entrySet()) { - String abstractClassName = entry.getKey(); - String concreteTypeName = entry.getValue(); - - if (StringUtils.isEmpty(concreteTypeName)) { - throw new CoreException( - new ErrorCode.ErrorCodeBuilder().withId("E0003") - .withMessage("Missing configuration value:" + concreteTypeName + ".") - .withCategory(ErrorCategory.SYSTEM).build()); - - } - registry.register(abstractClassName, concreteTypeName); - } - } - } - } diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/CommonMethods.java b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/CommonMethods.java index b2cc289676..0bcdf8ebbf 100644 --- a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/CommonMethods.java +++ b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/CommonMethods.java @@ -17,6 +17,7 @@ package org.openecomp.core.utilities; import java.lang.reflect.Array; +import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -30,6 +31,7 @@ import java.util.UUID; import org.apache.commons.collections4.MapUtils; import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.StringUtils; +import org.openecomp.core.utilities.exception.NewInstanceRuntimeException; /** * This class provides auxiliary static methods. @@ -160,11 +162,12 @@ public class CommonMethods { * @param cls the cls * @return the t */ - public static <T> T newInstance(Class<T> cls) { + public static <T> T newInstance(final Class<T> cls) { try { - return cls.newInstance(); - } catch (InstantiationException | IllegalAccessException exception) { - throw new RuntimeException(exception); + return cls.getDeclaredConstructor().newInstance(); + } catch (final InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException ex) { + throw new NewInstanceRuntimeException(String.format("Could not create instance for '%s'", cls.getName()) + , ex); } } diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/exception/NewInstanceRuntimeException.java b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/exception/NewInstanceRuntimeException.java new file mode 100644 index 0000000000..386486ff9e --- /dev/null +++ b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/exception/NewInstanceRuntimeException.java @@ -0,0 +1,31 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2019 Nordix Foundation + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.openecomp.core.utilities.exception; + +public class NewInstanceRuntimeException extends RuntimeException { + + public NewInstanceRuntimeException(String s) { + super(s); + } + + public NewInstanceRuntimeException(String s, Throwable throwable) { + super(s, throwable); + } +} |