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