src/main/java/org/onap/aai/sparky/synchronizer/config/SynchronizerConfiguration.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * Copyright © 2017 Amdocs
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *       http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  *
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  */
  23 package org.onap.aai.sparky.synchronizer.config;
  24
  25 import java.text.DateFormat;
  26 import java.text.SimpleDateFormat;
  27 import java.util.Arrays;
  28 import java.util.Calendar;
  29 import java.util.Date;
  30 import java.util.List;
  31 import java.util.Properties;
  32 import java.util.TimeZone;
  33 import java.util.regex.Matcher;
  34 import java.util.regex.Pattern;
  35
  36 import org.onap.aai.sparky.logging.AaiUiMsgs;
  37 import org.onap.aai.sparky.util.ConfigHelper;
  38 import org.onap.aai.sparky.viewandinspect.config.TierSupportUiConstants;
  39 import org.onap.aai.cl.api.Logger;
  40 import org.onap.aai.cl.eelf.LoggerFactory;
  41
  42
  43 /**
  44  * The Class SynchronizerConfiguration.
  45  */
  46 public class SynchronizerConfiguration {
  47
  48   private static final Logger LOG = LoggerFactory.getInstance().getLogger(SynchronizerConfiguration.class);
  49
  50   public static final String CONFIG_FILE =
  51       TierSupportUiConstants.DYNAMIC_CONFIG_APP_LOCATION + "synchronizer.properties";
  52
  53   private static SynchronizerConfiguration instance;
  54
  55   public static final String DEPTH_MODIFIER = "?depth=0";
  56   public static final String DEPTH_ALL_MODIFIER = "?depth=all";
  57   public static final String DEPTH_AND_NODES_ONLY_MODIFIER = "?depth=0&nodes-only";
  58   public static final String NODES_ONLY_MODIFIER = "?nodes-only";
  59
  60   public static SynchronizerConfiguration getConfig() throws Exception {
  61
  62     if (instance == null) {
  63       instance = new SynchronizerConfiguration();
  64     }
  65
  66     return instance;
  67   }
  68
  69   /**
  70    * Instantiates a new synchronizer configuration.
  71    */
  72         public SynchronizerConfiguration() throws Exception {
  73                 Properties props = ConfigHelper.loadConfigFromExplicitPath(CONFIG_FILE);
  74                 initialize(props);
  75         }
  76
  77         public SynchronizerConfiguration(Properties props) throws Exception {
  78                 initialize(props);
  79         }
  80   /**
  81    * Initialize.
  82    *
  83    * @throws Exception the exception
  84    */
  85   protected void initialize(Properties props) throws Exception {
  86
  87     // parse config for startup sync
  88     try {
  89       syncTaskInitialDelayInMs =
  90           Integer.parseInt(props.getProperty("synchronizer.syncTask.initialDelayInMs",
  91               SynchronizerConstants.DEFAULT_INITIAL_DELAY_IN_MS));
  92       if (syncTaskInitialDelayInMs < 0) {
  93         throw new Exception();
  94       }
  95     } catch (Exception exc) {
  96       this.setConfigOkForStartupSync(false);
  97       syncTaskInitialDelayInMs = SynchronizerConstants.DEFAULT_CONFIG_ERROR_INT_VALUE;
  98       String message = "Invalid configuration for synchronizer parameter:"
  99           + " 'synchronizer.syncTask.initialDelayInMs'";
 100       LOG.error(AaiUiMsgs.SYNC_INVALID_CONFIG_PARAM, message);
 101     }
 102
 103     // parse config for periodic sync
 104     try {
 105       syncTaskFrequencyInDay =
 106           Integer.parseInt(props.getProperty("synchronizer.syncTask.taskFrequencyInDay",
 107               SynchronizerConstants.DEFAULT_TASK_FREQUENCY_IN_DAY));
 108       if (syncTaskFrequencyInDay < 0) {
 109         throw new Exception();
 110       }
 111     } catch (Exception exc) {
 112       this.setConfigOkForPeriodicSync(false);
 113       syncTaskFrequencyInDay = SynchronizerConstants.DEFAULT_CONFIG_ERROR_INT_VALUE;
 114       String message = "Invalid configuration for synchronizer parameter:"
 115           + " 'synchronizer.syncTask.taskFrequencyInDay'";
 116       LOG.error(AaiUiMsgs.SYNC_INVALID_CONFIG_PARAM, message);
 117     }
 118
 119     try {
 120       syncTaskStartTime = props.getProperty("synchronizer.syncTask.startTimestamp",
 121           SynchronizerConstants.DEFAULT_START_TIMESTAMP); // Default 05:00:00 UTC
 122       Pattern pattern = Pattern.compile(SynchronizerConstants.TIMESTAMP24HOURS_PATTERN);
 123       Matcher matcher = pattern.matcher(syncTaskStartTime);
 124       if (!matcher.matches()) {
 125         throw new Exception();
 126       }
 127
 128       List<String> timestampVal = Arrays.asList(syncTaskStartTime.split(" "));
 129
 130       if (timestampVal.size() == SynchronizerConstants.COMPONENTS_IN_TIMESTAMP) {
 131         // Need both time and timezone offset
 132         syncTaskStartTimeTimeZone = timestampVal
 133             .get(SynchronizerConstants.IDX_TIMEZONE_IN_TIMESTAMP).replaceAll("UTC", "GMT");
 134
 135         String time = timestampVal.get(SynchronizerConstants.IDX_TIME_IN_TIMESTAMP);
 136         DateFormat format = new SimpleDateFormat("HH:mm:ss");
 137         Date date = format.parse(time);
 138         Calendar calendar = Calendar.getInstance();
 139         calendar.setTime(date);
 140
 141         syncTaskStartTimeHr = calendar.get(Calendar.HOUR_OF_DAY);
 142         syncTaskStartTimeMin = calendar.get(Calendar.MINUTE);
 143         syncTaskStartTimeSec = calendar.get(Calendar.SECOND);
 144       } else {
 145         LOG.info(AaiUiMsgs.SYNC_START_TIME);
 146       }
 147     } catch (Exception exc) {
 148       this.setConfigOkForPeriodicSync(false);
 149       String message = "Invalid configuration for synchronizer parameter:"
 150           + " 'synchronizer.syncTask.startTimestamp'";
 151       LOG.error(AaiUiMsgs.SYNC_INVALID_CONFIG_PARAM, message);
 152     }
 153
 154     scrollContextTimeToLiveInMinutes =
 155         Integer.parseInt(props.getProperty("synchronizer.scrollContextTimeToLiveInMinutes", "5"));
 156     numScrollContextItemsToRetrievePerRequest = Integer.parseInt(
 157         props.getProperty("synchronizer.numScrollContextItemsToRetrievePerRequest", "5000"));
 158
 159     resolverProgressLogFrequencyInMs = Long
 160         .parseLong(props.getProperty("synchronizer.resolver.progressLogFrequencyInMs", "60000"));
 161     resolverQueueMonitorFrequencyInMs = Long
 162         .parseLong(props.getProperty("synchronizer.resolver.queueMonitorFrequencyInMs", "1000"));
 163
 164     indexIntegrityValidatorEnabled = Boolean
 165         .parseBoolean(props.getProperty("synchronizer.indexIntegrityValidator.enabled", "false"));
 166     indexIntegrityValidatorFrequencyInMs = Long.parseLong(
 167         props.getProperty("synchronizer.indexIntegrityValidatorFrequencyInMs", "300000"));
 168
 169     displayVerboseQueueManagerStats = Boolean
 170         .parseBoolean(props.getProperty("synchronizer.resolver.displayVerboseQueueManagerStats"));
 171
 172     resourceNotFoundErrorsSupressed =
 173         Boolean.parseBoolean(props.getProperty("synchronizer.suppressResourceNotFoundErrors"));
 174
 175     nodesOnlyModifierEnabled =
 176         Boolean.parseBoolean(props.getProperty("synchronizer.applyNodesOnlyModifier"));
 177
 178     autosuggestSynchronizationEnabled = Boolean
 179         .parseBoolean(props.getProperty("synchronizer.autosuggestSynchronizationEnabled", "true"));
 180
 181     if (LOG.isDebugEnabled()) {
 182       LOG.debug(AaiUiMsgs.DEBUG_GENERIC, this.toString());
 183     }
 184   }
 185
 186   public boolean isNodesOnlyModifierEnabled() {
 187     return nodesOnlyModifierEnabled;
 188   }
 189
 190   public void setNodesOnlyModifierEnabled(boolean nodesOnlyModifierEnabled) {
 191     this.nodesOnlyModifierEnabled = nodesOnlyModifierEnabled;
 192   }
 193
 194   public int getSyncTaskInitialDelayInMs() {
 195     return syncTaskInitialDelayInMs;
 196   }
 197
 198   public void setSyncTaskInitialDelayInMs(int syncTaskInitialDelayInMs) {
 199     this.syncTaskInitialDelayInMs = syncTaskInitialDelayInMs;
 200   }
 201
 202   public boolean isDisplayVerboseQueueManagerStats() {
 203     return displayVerboseQueueManagerStats;
 204   }
 205
 206   public void setDisplayVerboseQueueManagerStats(boolean displayVerboseQueueManagerStats) {
 207     this.displayVerboseQueueManagerStats = displayVerboseQueueManagerStats;
 208   }
 209
 210   private int syncTaskInitialDelayInMs;
 211
 212   private int syncTaskFrequencyInMs;
 213
 214   private int scrollContextTimeToLiveInMinutes;
 215
 216   private int numScrollContextItemsToRetrievePerRequest;
 217
 218   private long resolverProgressLogFrequencyInMs;
 219
 220   private long resolverQueueMonitorFrequencyInMs;
 221
 222   private boolean indexIntegrityValidatorEnabled;
 223
 224   private long indexIntegrityValidatorFrequencyInMs;
 225
 226   private int syncTaskFrequencyInDay;
 227
 228   private String syncTaskStartTime;
 229
 230   private int syncTaskStartTimeHr = 5; // for default sync start time
 231
 232   private int syncTaskStartTimeMin;
 233
 234   private int syncTaskStartTimeSec;
 235
 236   private String syncTaskStartTimeTimeZone;
 237
 238   private boolean displayVerboseQueueManagerStats;
 239
 240   private boolean resourceNotFoundErrorsSupressed;
 241
 242   private boolean nodesOnlyModifierEnabled;
 243
 244   private boolean  autosuggestSynchronizationEnabled;
 245
 246   private boolean configOkForStartupSync = true;
 247
 248   private boolean configOkForPeriodicSync = true;
 249
 250   public boolean isResourceNotFoundErrorsSupressed() {
 251     return resourceNotFoundErrorsSupressed;
 252   }
 253
 254   public void setResourceNotFoundErrorsSupressed(boolean resourceNotFoundErrorsSupressed) {
 255     this.resourceNotFoundErrorsSupressed = resourceNotFoundErrorsSupressed;
 256   }
 257
 258   public int getScrollContextTimeToLiveInMinutes() {
 259     return scrollContextTimeToLiveInMinutes;
 260   }
 261
 262   public void setScrollContextTimeToLiveInMinutes(int scrollContextTimeToLiveInMinutes) {
 263     this.scrollContextTimeToLiveInMinutes = scrollContextTimeToLiveInMinutes;
 264   }
 265
 266   public int getNumScrollContextItemsToRetrievePerRequest() {
 267     return numScrollContextItemsToRetrievePerRequest;
 268   }
 269
 270   public void setNumScrollContextItemsToRetrievePerRequest(
 271       int numScrollContextItemsToRetrievePerRequest) {
 272     this.numScrollContextItemsToRetrievePerRequest = numScrollContextItemsToRetrievePerRequest;
 273   }
 274
 275   public int getSyncTaskFrequencyInDay() {
 276     return syncTaskFrequencyInDay;
 277   }
 278
 279   public void setSyncTaskFrequencyInDay(int syncTaskFrequencyInDay) {
 280     this.syncTaskFrequencyInDay = syncTaskFrequencyInDay;
 281   }
 282
 283   public String getSyncTaskStartTime() {
 284     return syncTaskStartTime;
 285   }
 286
 287   public void setSyncTaskStartTime(String syncTaskStartTime) {
 288     this.syncTaskStartTime = syncTaskStartTime;
 289   }
 290
 291   public int getSyncTaskStartTimeHr() {
 292     return syncTaskStartTimeHr;
 293   }
 294
 295   public void setSyncTaskStartTimeHr(int syncTaskStartTimeHr) {
 296     this.syncTaskStartTimeHr = syncTaskStartTimeHr;
 297   }
 298
 299   public int getSyncTaskStartTimeMin() {
 300     return syncTaskStartTimeMin;
 301   }
 302
 303   public void setSyncTaskStartTimeMin(int syncTaskStartTimeMin) {
 304     this.syncTaskStartTimeMin = syncTaskStartTimeMin;
 305   }
 306
 307   public int getSyncTaskStartTimeSec() {
 308     return syncTaskStartTimeSec;
 309   }
 310
 311   public void setSyncTaskStartTimeSec(int syncTaskStartTimeSec) {
 312     this.syncTaskStartTimeSec = syncTaskStartTimeSec;
 313   }
 314
 315   public String getSyncTaskStartTimeTimeZone() {
 316     return syncTaskStartTimeTimeZone;
 317   }
 318
 319   public void setSyncTaskStartTimeTimeZone(String syncTaskStartTimeTimeZone) {
 320     this.syncTaskStartTimeTimeZone = syncTaskStartTimeTimeZone;
 321   }
 322
 323   public int getSyncTaskFrequencyInMs() {
 324     return syncTaskFrequencyInMs;
 325   }
 326
 327   public void setSyncTaskFrequencyInMs(int syncTaskFrequencyInMs) {
 328     this.syncTaskFrequencyInMs = syncTaskFrequencyInMs;
 329   }
 330
 331   public long getResolverProgressLogFrequencyInMs() {
 332     return resolverProgressLogFrequencyInMs;
 333   }
 334
 335   public void setResolverProgressLogFrequencyInMs(long resolverProgressLogFrequencyInMs) {
 336     this.resolverProgressLogFrequencyInMs = resolverProgressLogFrequencyInMs;
 337   }
 338
 339   public long getResolverQueueMonitorFrequencyInMs() {
 340     return resolverQueueMonitorFrequencyInMs;
 341   }
 342
 343   public void setResolverQueueMonitorFrequencyInMs(long resolverQueueMonitorFrequencyInMs) {
 344     this.resolverQueueMonitorFrequencyInMs = resolverQueueMonitorFrequencyInMs;
 345   }
 346
 347   public boolean isIndexIntegrityValidatorEnabled() {
 348     return indexIntegrityValidatorEnabled;
 349   }
 350
 351   public void setIndexIntegrityValidatorEnabled(boolean indexIntegrityValidatorEnabled) {
 352     this.indexIntegrityValidatorEnabled = indexIntegrityValidatorEnabled;
 353   }
 354
 355   public long getIndexIntegrityValidatorFrequencyInMs() {
 356     return indexIntegrityValidatorFrequencyInMs;
 357   }
 358
 359   public void setIndexIntegrityValidatorFrequencyInMs(long indexIntegrityValidatorFrequencyInMs) {
 360     this.indexIntegrityValidatorFrequencyInMs = indexIntegrityValidatorFrequencyInMs;
 361   }
 362
 363   public boolean isConfigOkForStartupSync() {
 364     return configOkForStartupSync;
 365   }
 366
 367   public void setConfigOkForStartupSync(boolean configOkForStartupSync) {
 368     this.configOkForStartupSync = configOkForStartupSync;
 369   }
 370
 371   public boolean isConfigOkForPeriodicSync() {
 372     return configOkForPeriodicSync;
 373   }
 374
 375   public void setConfigOkForPeriodicSync(boolean configOkForPeriodicSync) {
 376     this.configOkForPeriodicSync = configOkForPeriodicSync;
 377   }
 378
 379   public boolean isConfigDisabledForInitialSync() {
 380     return syncTaskInitialDelayInMs == SynchronizerConstants.DELAY_NO_STARTUP_SYNC_IN_MS;
 381   }
 382
 383   public boolean isAutosuggestSynchronizationEnabled() {
 384     return autosuggestSynchronizationEnabled;
 385   }
 386
 387   public void setAutosuggestSynchronizationEnabled(boolean autosuggestSynchronizationEnabled) {
 388     this.autosuggestSynchronizationEnabled = autosuggestSynchronizationEnabled;
 389   }
 390
 391         public Calendar getTargetSyncTime() {
 392
 393                 TimeZone tz = TimeZone.getTimeZone(getSyncTaskStartTimeTimeZone());
 394                 Calendar targetSyncTime = Calendar.getInstance(tz);
 395
 396                 targetSyncTime.set(Calendar.HOUR_OF_DAY, getSyncTaskStartTimeHr());
 397                 targetSyncTime.set(Calendar.MINUTE, getSyncTaskStartTimeMin());
 398                 targetSyncTime.set(Calendar.SECOND, getSyncTaskStartTimeSec());
 399
 400                 return targetSyncTime;
 401
 402         }
 403
 404         public long getDefaultInitialSyncDelayInMs(Calendar timeNow) {
 405
 406                 int taskFrequencyInDays = getSyncTaskFrequencyInDay();
 407
 408                 long nextSyncTimeInMs = getNextSyncTime(getTargetSyncTime(), timeNow.getTimeInMillis(),
 409                                 taskFrequencyInDays * 86400);
 410
 411                 /*
 412                  * If the the current time is after the scheduled start time, then delay
 413                  * by the initial task delay configuration value
 414                  */
 415                 long delayUntilNextSyncInMs = Math.max(getSyncTaskInitialDelayInMs(),
 416                                 nextSyncTimeInMs - timeNow.getTimeInMillis());
 417
 418                 return delayUntilNextSyncInMs;
 419
 420         }
 421
 422         public long getNextSyncTime(Calendar syncTime, int taskFrequencyInSeconds) {
 423
 424                 TimeZone tz = TimeZone.getTimeZone(getSyncTaskStartTimeTimeZone());
 425                 Calendar timeNow = Calendar.getInstance(tz);
 426
 427                 return getNextSyncTime(syncTime, timeNow.getTimeInMillis(), taskFrequencyInSeconds);
 428         }
 429
 430         /**
 431          * Gets the first sync time.
 432          *
 433          * @param calendar
 434          *            the calendar
 435          * @param timeNow
 436          *            the time now in ms
 437          * @param taskFrequencyInMs
 438          *            task period in ms
 439          * @return the first sync time
 440          */
 441         public long getNextSyncTime(Calendar syncTime, long timeNowInMs, int taskFrequencyInSeconds) {
 442                 if (taskFrequencyInSeconds == 0) {
 443                         return 0;
 444                 } else if (timeNowInMs > syncTime.getTimeInMillis()) {
 445
 446                         /*
 447                          * If current time is after the scheduled sync start time, then
 448                          * we'll skip ahead to the next sync time period
 449                          */
 450
 451                         syncTime.add(Calendar.SECOND, taskFrequencyInSeconds);
 452                 }
 453
 454                 return syncTime.getTimeInMillis();
 455         }
 456   /**
 457    * @return the instance
 458    */
 459   public static SynchronizerConfiguration getInstance() {
 460     return instance;
 461   }
 462
 463   /**
 464    * @param instance the instance to set
 465    */
 466   public static void setInstance(SynchronizerConfiguration instance) {
 467     SynchronizerConfiguration.instance = instance;
 468   }
 469
 470   /**
 471    * @return the log
 472    */
 473   public static Logger getLog() {
 474     return LOG;
 475   }
 476
 477   /**
 478    * @return the configFile
 479    */
 480   public static String getConfigFile() {
 481     return CONFIG_FILE;
 482   }
 483
 484   /**
 485    * @return the depthModifier
 486    */
 487   public static String getDepthModifier() {
 488     return DEPTH_MODIFIER;
 489   }
 490
 491   /**
 492    * @return the depthAllModifier
 493    */
 494   public static String getDepthAllModifier() {
 495     return DEPTH_ALL_MODIFIER;
 496   }
 497
 498   /**
 499    * @return the depthAndNodesOnlyModifier
 500    */
 501   public static String getDepthAndNodesOnlyModifier() {
 502     return DEPTH_AND_NODES_ONLY_MODIFIER;
 503   }
 504
 505   /**
 506    * @return the nodesOnlyModifier
 507    */
 508   public static String getNodesOnlyModifier() {
 509     return NODES_ONLY_MODIFIER;
 510   }
 511
 512   /* (non-Javadoc)
 513    * @see java.lang.Object#toString()
 514    */
 515   @Override
 516   public String toString() {
 517     return "SynchronizerConfiguration [syncTaskInitialDelayInMs=" + syncTaskInitialDelayInMs
 518         + ", syncTaskFrequencyInMs=" + syncTaskFrequencyInMs + ", scrollContextTimeToLiveInMinutes="
 519         + scrollContextTimeToLiveInMinutes + ", numScrollContextItemsToRetrievePerRequest="
 520         + numScrollContextItemsToRetrievePerRequest + ", resolverProgressLogFrequencyInMs="
 521         + resolverProgressLogFrequencyInMs + ", resolverQueueMonitorFrequencyInMs="
 522         + resolverQueueMonitorFrequencyInMs + ", indexIntegrityValidatorEnabled="
 523         + indexIntegrityValidatorEnabled + ", indexIntegrityValidatorFrequencyInMs="
 524         + indexIntegrityValidatorFrequencyInMs + ", ssyncTaskFrequencyInDay="
 525         + syncTaskFrequencyInDay + ", syncTaskStartTime=" + syncTaskStartTime
 526         + ", syncTaskStartTimeHr=" + syncTaskStartTimeHr + ", syncTaskStartTimeMin="
 527         + syncTaskStartTimeMin + ", syncTaskStartTimeSec=" + syncTaskStartTimeSec
 528         + ", syncTaskStartTimeTimeZone=" + syncTaskStartTimeTimeZone
 529         + ", displayVerboseQueueManagerStats=" + displayVerboseQueueManagerStats
 530         + ", resourceNotFoundErrorsSupressed=" + resourceNotFoundErrorsSupressed
 531         + ", nodesOnlyModifierEnabled=" + nodesOnlyModifierEnabled + ", configOKForStartupSync="
 532         + configOkForStartupSync + ", configOKForPeriodicSync=" + configOkForPeriodicSync
 533         + ", autosuggestSynchronizationEnabled=" + autosuggestSynchronizationEnabled + "]";
 534   }
 535
 536 }