common/onap-common-configuration-management/onap-configuration-management-core/src/main/java/org/onap/config/impl/CliConfigurationImpl.java

   1 package org.onap.config.impl;
   2
   3 import static org.onap.config.Constants.DB_NAMESPACE;
   4 import static org.onap.config.Constants.DEFAULT_NAMESPACE;
   5 import static org.onap.config.Constants.DEFAULT_TENANT;
   6 import static org.onap.config.Constants.KEY_ELEMENTS_DELEMETER;
   7 import static org.onap.config.Constants.LOAD_ORDER_KEY;
   8 import static org.onap.config.Constants.MBEAN_NAME;
   9 import static org.onap.config.Constants.MODE_KEY;
  10 import static org.onap.config.Constants.NAMESPACE_KEY;
  11
  12 import java.io.File;
  13 import java.io.PrintWriter;
  14 import java.lang.management.ManagementFactory;
  15 import java.lang.reflect.Method;
  16 import java.util.ArrayList;
  17 import java.util.Arrays;
  18 import java.util.Collection;
  19 import java.util.HashMap;
  20 import java.util.HashSet;
  21 import java.util.Iterator;
  22 import java.util.Map;
  23 import java.util.Set;
  24 import javax.management.MBeanServer;
  25 import javax.management.MBeanServerDelegate;
  26 import javax.management.MBeanServerNotification;
  27 import javax.management.Notification;
  28 import javax.management.ObjectName;
  29 import javax.management.StandardMBean;
  30 import org.apache.commons.configuration2.CombinedConfiguration;
  31 import org.apache.commons.configuration2.CompositeConfiguration;
  32 import org.apache.commons.configuration2.Configuration;
  33 import org.apache.commons.configuration2.FileBasedConfiguration;
  34 import org.apache.commons.configuration2.PropertiesConfiguration;
  35 import org.onap.config.ConfigurationUtils;
  36 import org.onap.config.Constants;
  37 import org.onap.config.api.ConfigurationManager;
  38 import org.onap.config.api.Hint;
  39 import org.onap.config.type.ConfigurationQuery;
  40 import org.onap.config.type.ConfigurationUpdate;
  41
  42 /**
  43  * The type Cli configuration.
  44  */
  45 public final class CliConfigurationImpl extends ConfigurationImpl implements ConfigurationManager {
  46
  47     /**
  48      * Instantiates a new Cli configuration.
  49      *
  50      * @throws Exception the exception
  51      */
  52     public CliConfigurationImpl() throws Exception {
  53         MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
  54         ObjectName name = new ObjectName(MBEAN_NAME);
  55         if (mbs.isRegistered(name)) {
  56             mbs.unregisterMBean(name);
  57         }
  58         mbs.registerMBean(new StandardMBean(this, ConfigurationManager.class), name);
  59         mbs.addNotificationListener(MBeanServerDelegate.DELEGATE_NAME,
  60                 (notification, handback) -> handleNotification(notification), null,
  61                 null);
  62     }
  63
  64
  65     /**
  66      * Handle notification.
  67      *
  68      * @param notification the notification
  69      */
  70     public void handleNotification(Notification notification) {
  71         if (notification instanceof MBeanServerNotification) {
  72             MBeanServerNotification mbs = (MBeanServerNotification) notification;
  73             if (MBeanServerNotification.UNREGISTRATION_NOTIFICATION.equals(mbs.getType())) {
  74                 try {
  75                     String mbean =
  76                             ConfigurationRepository.lookup().getConfigurationFor(DEFAULT_TENANT, DB_NAMESPACE)
  77                                     .getString("shutdown.mbean");
  78                     if (mbs.getMBeanName()
  79                                 .equals(mbean == null ? new ObjectName(MBEAN_NAME) : new ObjectName(mbean))) {
  80                         changeNotifier.shutdown();
  81                         ConfigurationDataSource.lookup().close();
  82                     }
  83                 } catch (Exception exception) {
  84                     //do nothing.
  85                 }
  86             } else if (MBeanServerNotification.REGISTRATION_NOTIFICATION.equals(mbs.getType())) {
  87                 mbs.getMBeanName();
  88             }
  89         }
  90     }
  91
  92     public String getConfigurationValue(Map<String, Object> input) {
  93         return getConfigurationValue((ConfigurationQuery) getInput(input));
  94     }
  95
  96     private String getConfigurationValue(ConfigurationQuery queryData) {
  97         try {
  98             if (queryData.isFallback()) {
  99                 return ConfigurationUtils.getCommaSeparatedList(
 100                         get(queryData.getTenant(), queryData.getNamespace(), queryData.getKey(), String[].class,
 101                                 queryData.isLatest() ? Hint.LATEST_LOOKUP : Hint.DEFAULT,
 102                                 queryData.isExternalLookup() ? Hint.EXTERNAL_LOOKUP : Hint.DEFAULT,
 103                                 queryData.isNodeSpecific() ? Hint.NODE_SPECIFIC : Hint.DEFAULT));
 104             } else {
 105                 String[] list =
 106                         getInternal(queryData.getTenant(), queryData.getNamespace(), queryData.getKey(),
 107                                 String[].class, queryData.isLatest() ? Hint.LATEST_LOOKUP : Hint.DEFAULT,
 108                                 queryData.isExternalLookup() ? Hint.EXTERNAL_LOOKUP : Hint.DEFAULT,
 109                                 queryData.isNodeSpecific() ? Hint.NODE_SPECIFIC : Hint.DEFAULT);
 110                 return ConfigurationUtils
 111                                .getCommaSeparatedList(list == null ? Arrays.asList() : Arrays.asList(list));
 112             }
 113         } catch (Exception exception) {
 114             exception.printStackTrace();
 115         }
 116         return null;
 117     }
 118
 119     public void updateConfigurationValue(Map<String, Object> input) {
 120         updateConfigurationValue((ConfigurationUpdate) getInput(input));
 121     }
 122
 123     private void updateConfigurationValue(ConfigurationUpdate updateData) {
 124
 125         try {
 126             if (!ConfigurationRepository.lookup().isValidTenant(updateData.getTenant())) {
 127                 throw new RuntimeException("Invalid tenantId.");
 128             }
 129             if (!ConfigurationRepository.lookup().isValidNamespace(updateData.getNamespace())) {
 130                 throw new RuntimeException("Invalid Namespace.");
 131             }
 132         } catch (NullPointerException e1) {
 133             // TODO Auto-generated catch block
 134             e1.printStackTrace();
 135         }
 136
 137         try {
 138             boolean keyPresent =
 139                     isKeyExists(updateData.getTenant(), updateData.getNamespace(), updateData.getKey());
 140             if (keyPresent) {
 141                 boolean isUpdated = false;
 142                 Object[] paramArray = new Object[]{
 143                         updateData.getTenant() + KEY_ELEMENTS_DELEMETER + updateData.getNamespace(),
 144                         new Long(System.currentTimeMillis()), updateData.getKey(),
 145                         getConfigurationValue(updateData), updateData.getValue()};
 146                 Configuration config = ConfigurationRepository.lookup()
 147                                                .getConfigurationFor(updateData.getTenant(), updateData.getNamespace());
 148                 if (config instanceof AgglomerateConfiguration || config instanceof CombinedConfiguration) {
 149                     CompositeConfiguration cc = new CompositeConfiguration();
 150                     cc.addConfiguration(config);
 151                     config = cc;
 152                 }
 153                 CompositeConfiguration configuration = (CompositeConfiguration) config;
 154                 int overrideIndex = -1;
 155                 for (int i = 0; i < configuration.getNumberOfConfigurations(); i++) {
 156                     if (!updateData.isNodeOverride()
 157                                 && (configuration.getConfiguration(i) instanceof AgglomerateConfiguration
 158                                             || configuration.getConfiguration(i) instanceof CombinedConfiguration)) {
 159                         configuration.getConfiguration(i)
 160                                 .setProperty(updateData.getKey(), updateData.getValue());
 161                         isUpdated = true;
 162                         break;
 163                     } else if (updateData.isNodeOverride()
 164                                        && configuration.getConfiguration(i) instanceof FileBasedConfiguration) {
 165                         configuration.getConfiguration(i)
 166                                 .setProperty(updateData.getKey(), updateData.getValue());
 167                         isUpdated = true;
 168                         overrideIndex = i;
 169                         break;
 170                     }
 171                 }
 172                 if (!isUpdated) {
 173                     if (updateData.isNodeOverride()) {
 174                         PropertiesConfiguration pc = new PropertiesConfiguration();
 175                         pc.setProperty(NAMESPACE_KEY,
 176                                 updateData.getTenant() + Constants.TENANT_NAMESPACE_SAPERATOR
 177                                         + updateData.getNamespace());
 178                         pc.setProperty(MODE_KEY, "OVERRIDE");
 179                         pc.setProperty(updateData.getKey(), updateData.getValue());
 180                         if (System.getProperty("node.config.location") != null
 181                                     && System.getProperty("node.config.location").trim().length() > 0) {
 182                             File file = new File(System.getProperty("node.config.location"),
 183                                     updateData.getTenant() + File.separator + updateData.getNamespace()
 184                                             + File.separator + "config.properties");
 185                             file.getParentFile().mkdirs();
 186                             PrintWriter out = new PrintWriter(file);
 187                             pc.write(out);
 188                             out.close();
 189                             ConfigurationRepository.lookup().populateOverrideConfigurtaion(
 190                                     updateData.getTenant() + KEY_ELEMENTS_DELEMETER + updateData.getNamespace(),
 191                                     file);
 192                         }
 193                     } else {
 194                         configuration.getConfiguration(0)
 195                                 .setProperty(updateData.getKey(), updateData.getValue());
 196                     }
 197                 }
 198                 if (!updateData.isNodeOverride()) {
 199                     ConfigurationUtils.executeInsertSql(
 200                             ConfigurationRepository.lookup().getConfigurationFor(DEFAULT_TENANT, DB_NAMESPACE)
 201                                     .getString("insertconfigurationchangecql"), paramArray);
 202                 } else {
 203                     ConfigurationRepository.lookup().refreshOverrideConfigurtaionFor(
 204                             updateData.getTenant() + KEY_ELEMENTS_DELEMETER + updateData.getNamespace(),
 205                             overrideIndex);
 206                 }
 207             }
 208         } catch (Exception exception) {
 209             exception.printStackTrace();
 210         }
 211     }
 212
 213     private boolean isKeyExists(String tenant, String namespace, String key) {
 214         boolean keyExist = false;
 215         try {
 216             keyExist =
 217                     ConfigurationRepository.lookup().getConfigurationFor(tenant, namespace).containsKey(key);
 218             if (!keyExist && !DEFAULT_TENANT.equals(tenant)) {
 219                 keyExist = ConfigurationRepository.lookup().getConfigurationFor(DEFAULT_TENANT, namespace)
 220                                    .containsKey(key);
 221             }
 222             if (!keyExist && !DEFAULT_NAMESPACE.equals(namespace)) {
 223                 keyExist = ConfigurationRepository.lookup().getConfigurationFor(tenant, DEFAULT_NAMESPACE)
 224                                    .containsKey(key);
 225             }
 226             if (!keyExist && !DEFAULT_TENANT.equals(tenant) && !DEFAULT_NAMESPACE.equals(namespace)) {
 227                 keyExist =
 228                         ConfigurationRepository.lookup().getConfigurationFor(DEFAULT_TENANT, DEFAULT_NAMESPACE)
 229                                 .containsKey(key);
 230             }
 231         } catch (Exception exception) {
 232             exception.printStackTrace();
 233         }
 234         return keyExist;
 235     }
 236
 237     public Map<String, String> listConfiguration(Map<String, Object> input) {
 238         return listConfiguration((ConfigurationQuery) getInput(input));
 239     }
 240
 241     private Map<String, String> listConfiguration(ConfigurationQuery query) {
 242         Map<String, String> map = new HashMap<>();
 243         try {
 244             Collection<String> keys = getKeys(query.getTenant(), query.getNamespace());
 245             for (String key : keys) {
 246                 map.put(key, getConfigurationValue(query.key(key)));
 247             }
 248         } catch (Exception exception) {
 249             exception.printStackTrace();
 250             return null;
 251         }
 252         return map;
 253     }
 254
 255     @Override
 256     public boolean updateConfigurationValues(String tenant, String namespace,
 257             Map configKeyValueStore) {
 258         boolean valueToReturn = true;
 259         Iterator<String> keys = configKeyValueStore.keySet().iterator();
 260         while (keys.hasNext()) {
 261             try {
 262                 String key = keys.next();
 263                 ConfigurationUpdate updateData = new ConfigurationUpdate();
 264                 updateData.tenant(tenant).namespace(namespace).key(key);
 265                 updateData.value(configKeyValueStore.get(key).toString());
 266                 updateConfigurationValue(updateData);
 267             } catch (Exception exception) {
 268                 exception.printStackTrace();
 269                 valueToReturn = false;
 270             }
 271         }
 272         return valueToReturn;
 273     }
 274
 275     private Object getInput(Map<String, Object> input) {
 276         Object toReturn = null;
 277         try {
 278             toReturn = Class.forName(input.get("ImplClass").toString()).newInstance();
 279             Method[] methods = toReturn.getClass().getMethods();
 280             for (Method method : methods) {
 281                 if (input.containsKey(method.getName())) {
 282                     method.invoke(toReturn, input.get(method.getName()));
 283                 }
 284             }
 285         } catch (Exception exception) {
 286             exception.printStackTrace();
 287         }
 288
 289         return toReturn;
 290     }
 291
 292     @Override
 293     public Collection<String> getTenants() {
 294         return ConfigurationRepository.lookup().getTenants();
 295     }
 296
 297     @Override
 298     public Collection<String> getNamespaces() {
 299         return ConfigurationRepository.lookup().getNamespaces();
 300     }
 301
 302     private ArrayList<String> getInMemoryKeys(String tenant, String namespace) {
 303         ArrayList<String> keys = new ArrayList<>();
 304
 305         try {
 306             Iterator<String> iter =
 307                     ConfigurationRepository.lookup().getConfigurationFor(tenant, namespace).getKeys();
 308             while (iter.hasNext()) {
 309                 String key = iter.next();
 310                 if (!(key.equals(NAMESPACE_KEY) || key.equals(MODE_KEY)
 311                               || key.equals(LOAD_ORDER_KEY))) {
 312                     keys.add(key);
 313                 }
 314             }
 315         } catch (Exception exception) {
 316             //do nothing
 317         }
 318
 319         return keys;
 320     }
 321
 322     @Override
 323     public Collection<String> getKeys(String tenant, String namespace) {
 324         Set<String> keyCollection = new HashSet<>();
 325         try {
 326             keyCollection.addAll(ConfigurationUtils.executeSelectSql(
 327                     ConfigurationRepository.lookup().getConfigurationFor(DEFAULT_TENANT, DB_NAMESPACE)
 328                             .getString("fetchkeysql"),
 329                     new String[]{tenant + KEY_ELEMENTS_DELEMETER + DEFAULT_NAMESPACE}));
 330             keyCollection.addAll(ConfigurationUtils.executeSelectSql(
 331                     ConfigurationRepository.lookup().getConfigurationFor(DEFAULT_TENANT, DB_NAMESPACE)
 332                             .getString("fetchkeysql"),
 333                     new String[]{tenant + KEY_ELEMENTS_DELEMETER + namespace}));
 334             keyCollection.addAll(ConfigurationUtils.executeSelectSql(
 335                     ConfigurationRepository.lookup().getConfigurationFor(DEFAULT_TENANT, DB_NAMESPACE)
 336                             .getString("fetchkeysql"),
 337                     new String[]{DEFAULT_TENANT + KEY_ELEMENTS_DELEMETER + namespace}));
 338             keyCollection.addAll(ConfigurationUtils.executeSelectSql(
 339                     ConfigurationRepository.lookup().getConfigurationFor(DEFAULT_TENANT, DB_NAMESPACE)
 340                             .getString("fetchkeysql"),
 341                     new String[]{DEFAULT_TENANT + KEY_ELEMENTS_DELEMETER + DEFAULT_NAMESPACE}));
 342         } catch (Exception exception) {
 343             exception.printStackTrace();
 344             keyCollection.addAll(getInMemoryKeys(tenant, DEFAULT_NAMESPACE));
 345             keyCollection.addAll(getInMemoryKeys(tenant, namespace));
 346             keyCollection.addAll(getInMemoryKeys(DEFAULT_TENANT, namespace));
 347             keyCollection.addAll(getInMemoryKeys(DEFAULT_TENANT, DEFAULT_NAMESPACE));
 348         }
 349         return keyCollection;
 350     }
 351 }