Removed support of dynamic configuration

Configuration framework will not poll configuration
for changes, and will not notify client code of them.
Also minor cleanup, added unit tests.

Change-Id: I428b23f7acb13c6610390f46aae6e011d6b0ee80
Issue-ID: SDC-1867
Signed-off-by: vempo <vitaliy.emporopulo@amdocs.com>

1 files changed, 0 insertions, 393 deletions

diff --git a/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/ConfigurationChangeNotifier.java b/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/ConfigurationChangeNotifier.java
deleted file mode 100644
index cd6481f97b..0000000000
--- a/common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/ConfigurationChangeNotifier.java
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
- * Copyright © 2016-2018 European Support Limited
- *
- * 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.
- */
-
-package org.onap.config.impl;
-
-import java.io.File;
-import java.io.IOException;
-import java.lang.management.ManagementFactory;
-import java.lang.reflect.Method;
-import java.nio.file.ClosedWatchServiceException;
-import java.nio.file.FileSystems;
-import java.nio.file.Path;
-import java.nio.file.StandardWatchEventKinds;
-import java.nio.file.WatchEvent;
-import java.nio.file.WatchKey;
-import java.nio.file.WatchService;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.Vector;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import javax.management.JMX;
-import javax.management.MBeanServerConnection;
-import javax.management.ObjectName;
-import org.onap.config.ConfigurationUtils;
-import org.onap.config.Constants;
-import org.onap.config.api.ConfigurationChangeListener;
-import org.onap.config.api.ConfigurationManager;
-import org.onap.config.api.Hint;
-
-
-public final class ConfigurationChangeNotifier {
-
-    static {
-        if (!Thread.currentThread().getStackTrace()[2].getClassName().equals(ConfigurationImpl.class.getName())) {
-            throw new RuntimeException("Illegal access.");
-        }
-    }
-
-    private final HashMap<String, List<NotificationData>> store = new HashMap<>();
-    private final ScheduledExecutorService executor =
-            Executors.newScheduledThreadPool(5, ConfigurationUtils.getThreadFactory());
-    private final ExecutorService notificationExecutor =
-            Executors.newCachedThreadPool(ConfigurationUtils.getThreadFactory());
-    private final Map<String, WatchService> watchServiceCollection = Collections.synchronizedMap(new HashMap<>());
-
-    public ConfigurationChangeNotifier(Map<String, AggregateConfiguration> inMemoryConfig) {
-        executor.scheduleWithFixedDelay(() -> this.pollFilesystemAndUpdateConfigurationIfRequired(inMemoryConfig,
-                System.getProperty("config.location"), false), 1, 1, TimeUnit.MILLISECONDS);
-        executor.scheduleWithFixedDelay(() -> this.pollFilesystemAndUpdateConfigurationIfRequired(inMemoryConfig,
-                System.getProperty("tenant.config.location"), true), 1, 1, TimeUnit.MILLISECONDS);
-        executor.scheduleWithFixedDelay(() -> this.pollFilesystemAndUpdateNodeSpecificConfigurationIfRequired(
-                System.getProperty("node.config.location")), 1, 1, TimeUnit.MILLISECONDS);
-    }
-
-    public void pollFilesystemAndUpdateConfigurationIfRequired(Map<String, AggregateConfiguration> inMemoryConfig,
-            String location, boolean isTenantLocation) {
-        try {
-            Set<Path> paths = watchForChange(location);
-            if (paths != null) {
-                for (Path path : paths) {
-                    File file = path.toAbsolutePath().toFile();
-                    String repositoryKey = null;
-                    if (ConfigurationUtils.isConfig(file) && file.isFile()) {
-                        if (isTenantLocation) {
-                            Collection<File> tenantsRoot =
-                                    ConfigurationUtils.getAllFiles(new File(location), false, true);
-                            for (File tenantRoot : tenantsRoot) {
-                                if (file.getAbsolutePath().startsWith(tenantRoot.getAbsolutePath())) {
-                                    repositoryKey = ConfigurationUtils.getConfigurationRepositoryKey(
-                                            (tenantRoot.getName() + Constants.TENANT_NAMESPACE_SEPARATOR
-                                                     + ConfigurationUtils.getNamespace(file))
-                                                    .split(Constants.TENANT_NAMESPACE_SEPARATOR));
-                                }
-                            }
-                        } else {
-                            repositoryKey = ConfigurationUtils.getConfigurationRepositoryKey(file);
-                        }
-                        AggregateConfiguration config = inMemoryConfig.get(repositoryKey);
-                        if (config != null) {
-                            LinkedHashMap origConfig = ConfigurationUtils.toMap(config.getFinalConfiguration());
-                            config.addConfig(file);
-                            LinkedHashMap latestConfig = ConfigurationUtils.toMap(config.getFinalConfiguration());
-                            Map map = ConfigurationUtils.diff(origConfig, latestConfig);
-                            String[] tenantNamespaceArray = repositoryKey.split(Constants.KEY_ELEMENTS_DELIMETER);
-                            updateConfigurationValues(tenantNamespaceArray[0], tenantNamespaceArray[1], map);
-                        }
-                    } else {
-                        for (String configKey : inMemoryConfig.keySet()) {
-                            repositoryKey = configKey;
-                            AggregateConfiguration config = inMemoryConfig.get(repositoryKey);
-                            if (config.containsConfig(file)) {
-                                LinkedHashMap origConfig = ConfigurationUtils.toMap(config.getFinalConfiguration());
-                                config.removeConfig(file);
-                                LinkedHashMap latestConfig = ConfigurationUtils.toMap(config.getFinalConfiguration());
-                                Map map = ConfigurationUtils.diff(origConfig, latestConfig);
-                                String[] tenantNamespaceArray = repositoryKey.split(Constants.KEY_ELEMENTS_DELIMETER);
-                                updateConfigurationValues(tenantNamespaceArray[0], tenantNamespaceArray[1], map);
-                            }
-                        }
-                    }
-                }
-            }
-        } catch (ClosedWatchServiceException exception) {
-            // do nothing.
-        } catch (Exception exception) {
-            exception.printStackTrace();
-        }
-    }
-
-    public void pollFilesystemAndUpdateNodeSpecificConfigurationIfRequired(String location) {
-        try {
-            Set<Path> paths = watchForChange(location);
-            if (paths != null) {
-                for (Path path : paths) {
-                    File file = path.toAbsolutePath().toFile();
-
-                    if (ConfigurationUtils.isConfig(file)) {
-                        String repositoryKey = ConfigurationUtils.getConfigurationRepositoryKey(file);
-                        ConfigurationRepository.lookup().populateOverrideConfiguration(repositoryKey, file);
-                    } else {
-                        ConfigurationRepository.lookup().removeOverrideConfiguration(file);
-                    }
-                }
-            }
-        } catch (Exception exception) {
-            exception.printStackTrace();
-        }
-    }
-
-    private Set<Path> watchForChange(String location) throws Exception {
-        if (location == null || location.trim().length() == 0) {
-            return Collections.emptySet();
-        }
-        File file = new File(location);
-        if (!file.exists()) {
-            return Collections.emptySet();
-        }
-        Path path = file.toPath();
-        Set<Path> toReturn = new HashSet<>();
-        try (final WatchService watchService = FileSystems.getDefault().newWatchService()) {
-            watchServiceCollection.put(location, watchService);
-            path.register(watchService, StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_CREATE,
-                    StandardWatchEventKinds.ENTRY_DELETE);
-            for (File dir : ConfigurationUtils.getAllFiles(file, true, true)) {
-                dir.toPath().register(watchService, StandardWatchEventKinds.ENTRY_MODIFY,
-                        StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE);
-            }
-            while (true) {
-                final WatchKey wk = watchService.take();
-                Thread.sleep(ConfigurationRepository.lookup()
-                                     .getConfigurationFor(Constants.DEFAULT_TENANT, Constants.DB_NAMESPACE)
-                                     .getLong("event.fetch.delay"));
-                for (WatchEvent<?> event : wk.pollEvents()) {
-                    Object context = event.context();
-                    if (context instanceof Path) {
-                        File newFile = new File(((Path) wk.watchable()).toFile(), context.toString());
-                        if (event.kind() == StandardWatchEventKinds.ENTRY_CREATE) {
-                            if (newFile.isDirectory()) {
-                                newFile.toPath().register(watchService, StandardWatchEventKinds.ENTRY_MODIFY,
-                                        StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE);
-                                continue;
-                            }
-                        } else if (event.kind() == StandardWatchEventKinds.ENTRY_MODIFY) {
-                            if (newFile.isDirectory()) {
-                                continue;
-                            }
-                        }
-                        toReturn.add(newFile.toPath());
-                    }
-                }
-                if (toReturn.isEmpty()) {
-                    continue;
-                }
-                break;
-            }
-        }
-        return toReturn;
-    }
-
-    private void updateConfigurationValues(String tenant, String namespace, Map map) throws Exception {
-        MBeanServerConnection mbsc = ManagementFactory.getPlatformMBeanServer();
-        ObjectName mbeanName = new ObjectName(Constants.MBEAN_NAME);
-        ConfigurationManager conf = JMX.newMBeanProxy(mbsc, mbeanName, ConfigurationManager.class, true);
-        conf.updateConfigurationValues(tenant, namespace, map);
-    }
-
-    public void shutdown() {
-        for (WatchService watch : watchServiceCollection.values()) {
-            try {
-                watch.close();
-            } catch (IOException exception) {
-                //do nothing
-            }
-        }
-        executor.shutdownNow();
-    }
-
-    public void notifyChangesTowards(String tenant, String component, String key, ConfigurationChangeListener myself)
-            throws Exception {
-        List<NotificationData> notificationList = store.get(tenant + Constants.KEY_ELEMENTS_DELIMETER + component);
-        if (notificationList == null) {
-            notificationList = Collections.synchronizedList(new ArrayList<>());
-            store.put(tenant + Constants.KEY_ELEMENTS_DELIMETER + component, notificationList);
-            executor.scheduleWithFixedDelay(
-                    () -> triggerScanning(tenant + Constants.KEY_ELEMENTS_DELIMETER + component), 1, 30000,
-                    TimeUnit.MILLISECONDS);
-        }
-        notificationList.add(new NotificationData(tenant, component, key, myself));
-    }
-
-    private void triggerScanning(String key) {
-        if (store.get(key) != null) {
-            notificationExecutor.submit(() -> scanForChanges(key));
-        } else {
-            throw new IllegalArgumentException("Notification service for " + key + " is suspended.");
-        }
-    }
-
-    private void scanForChanges(String key) {
-        List<NotificationData> list = store.get(key);
-        if (list != null) {
-            list.stream().filter(NotificationData::isChanged)
-                    .forEach(notificationData -> notificationExecutor.submit(() -> sendNotification(notificationData)));
-        }
-    }
-
-    private void sendNotification(NotificationData notificationData) {
-        try {
-            notificationData.dispatchNotification();
-        } catch (Exception exception) {
-            exception.printStackTrace();
-        }
-    }
-
-    public void stopNotificationTowards(String tenant, String component, String key, ConfigurationChangeListener myself)
-            throws Exception {
-        List<NotificationData> notificationList = store.get(tenant + Constants.KEY_ELEMENTS_DELIMETER + component);
-        if (notificationList != null) {
-            boolean removed = notificationList.remove(new NotificationData(tenant, component, key, myself));
-            if (removed && notificationList.isEmpty()) {
-                store.remove(tenant + Constants.KEY_ELEMENTS_DELIMETER + component);
-            }
-        }
-
-    }
-
-    static class NotificationData {
-
-        final String tenant;
-
-        final String namespace;
-
-        final String key;
-
-        final ConfigurationChangeListener myself;
-
-        Object currentValue;
-
-        boolean isArray;
-
-        public NotificationData(String tenant, String component, String key, ConfigurationChangeListener myself)
-                throws Exception {
-            this.tenant = tenant;
-            this.namespace = component;
-            this.key = key;
-            this.myself = myself;
-            if (!ConfigurationRepository.lookup().getConfigurationFor(tenant, component).containsKey(key)) {
-                throw new RuntimeException("Key[" + key + "] not found.");
-            }
-            isArray = ConfigurationUtils.isArray(tenant, component, key, Hint.DEFAULT.value());
-            if (isArray) {
-                currentValue = ConfigurationManager.lookup().getAsStringValues(tenant, component, key);
-            } else {
-                currentValue = ConfigurationManager.lookup().getAsString(tenant, component, key);
-            }
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(tenant, namespace, key, myself, currentValue, isArray);
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-            if (!(obj instanceof NotificationData)) {
-                return false;
-            }
-            NotificationData nd = (NotificationData) obj;
-            return Objects.equals(tenant, nd.tenant) && Objects.equals(namespace, nd.namespace) && Objects.equals(key,
-                    nd.key) && Objects.equals(myself, nd.myself) && Objects.equals(currentValue, nd.currentValue)
-                           // it's either String or List<String>
-                           && isArray == nd.isArray;
-        }
-
-        public boolean isChanged() {
-            Object latestValue;
-            try {
-                if (isArray) {
-                    latestValue = ConfigurationManager.lookup().getAsStringValues(tenant, namespace, key);
-                } else {
-                    latestValue = ConfigurationManager.lookup().getAsString(tenant, namespace, key);
-                }
-                if (!isArray) {
-                    return !currentValue.equals(latestValue);
-                } else {
-                    Collection<String> oldCollection = (Collection<String>) currentValue;
-                    Collection<String> newCollection = (Collection<String>) latestValue;
-                    for (String val : oldCollection) {
-                        if (!newCollection.remove(val)) {
-                            return true;
-                        }
-                    }
-                    return !newCollection.isEmpty();
-                }
-            } catch (Exception exception) {
-                return false;
-            }
-        }
-
-        public void dispatchNotification() throws Exception {
-            Method method = null;
-            Vector<Object> parameters = null;
-            try {
-                Object latestValue;
-                if (isArray) {
-                    latestValue = ConfigurationManager.lookup().getAsStringValues(tenant, namespace, key);
-                } else {
-                    latestValue = ConfigurationManager.lookup().getAsString(tenant, namespace, key);
-                }
-                Method[] methods = myself.getClass().getDeclaredMethods();
-                if (methods != null && methods.length > 0) {
-                    method = methods[0];
-                    int paramCount = method.getParameterCount();
-                    parameters = new Vector<>();
-                    if (paramCount > 4) {
-                        if (tenant.equals(Constants.DEFAULT_TENANT)) {
-                            parameters.add(null);
-                        } else {
-                            parameters.add(tenant);
-                        }
-                    }
-                    if (paramCount > 3) {
-                        if (namespace.equals(Constants.DEFAULT_NAMESPACE)) {
-                            parameters.add(null);
-                        } else {
-                            parameters.add(namespace);
-                        }
-                    }
-                    parameters.add(key);
-                    parameters.add(currentValue);
-                    parameters.add(latestValue);
-                    method.setAccessible(true);
-                }
-            } catch (Exception exception) {
-                exception.printStackTrace();
-            } finally {
-                isArray = ConfigurationUtils.isArray(tenant, namespace, key, Hint.DEFAULT.value());
-                if (isArray) {
-                    currentValue = ConfigurationManager.lookup().getAsStringValues(tenant, namespace, key);
-                } else {
-                    currentValue = ConfigurationManager.lookup().getAsString(tenant, namespace, key);
-                }
-                if (method != null && parameters != null) {
-                    method.invoke(myself, parameters.toArray());
-                }
-            }
-        }
-    }
-}