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