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