sparkybe-onap-service/src/main/java/org/onap/aai/sparky/sync/config/SyncControllerConfig.java

   1 /**
   2  * ============LICENSE_START===================================================
   3  * SPARKY (AAI UI service)
   4  * ============================================================================
   5  * Copyright © 2017 AT&T Intellectual Property.
   6  * Copyright © 2017 Amdocs
   7  * All rights reserved.
   8  * ============================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=====================================================
  21  *
  22  * ECOMP and OpenECOMP are trademarks
  23  * and service marks of AT&T Intellectual Property.
  24  */
  25 package org.onap.aai.sparky.sync.config;
  26
  27 import java.text.DateFormat;
  28 import java.text.ParseException;
  29 import java.text.SimpleDateFormat;
  30 import java.util.Arrays;
  31 import java.util.Calendar;
  32 import java.util.Date;
  33 import java.util.List;
  34 import java.util.TimeZone;
  35 import java.util.regex.Matcher;
  36 import java.util.regex.Pattern;
  37
  38 import org.onap.aai.sparky.sync.SynchronizerConstants;
  39
  40 public class SyncControllerConfig {
  41
  42   private static final String UNKNOWN_CONTROLLER_NAME = "UnknownControllerName";
  43
  44   private String controllerName;
  45   private boolean enabled;
  46   private int syncTaskDelayInMs;
  47   private int syncTaskFrequencyInDays;
  48
  49   private int numSyncControllerWorkers;
  50   private boolean runOnceSyncEnabled;
  51   private boolean periodicSyncEnabled;
  52
  53   private String targetSyncStartTimeStamp;
  54
  55   private int numInternalSyncWorkers;
  56   private int numSyncElasticWorkers;
  57   private int numSyncActiveInventoryWorkers;
  58
  59   /*
  60    * calculated variables based on incoming config
  61    */
  62   private String timeZoneOfSyncStartTimeStamp;
  63   private int syncTaskStartTimeHr;
  64   private int syncTaskStartTimeMin;
  65   private int syncTaskStartTimeSec;
  66
  67
  68
  69   public SyncControllerConfig() {
  70     controllerName = UNKNOWN_CONTROLLER_NAME;
  71     enabled = false;
  72     syncTaskDelayInMs = 0;
  73     syncTaskFrequencyInDays = 365;
  74     numSyncControllerWorkers = 1;
  75     runOnceSyncEnabled = false;
  76     periodicSyncEnabled = false;
  77     targetSyncStartTimeStamp = SynchronizerConstants.DEFAULT_START_TIMESTAMP;
  78     numInternalSyncWorkers = 2;
  79     numSyncElasticWorkers = 5;
  80     numSyncActiveInventoryWorkers = 5;
  81   }
  82
  83   protected void initializeSyncTimeParameters() {
  84
  85     if (syncTaskDelayInMs < 0) {
  86       throw new IllegalArgumentException("syncTaskDelayInMs must >= 0");
  87     }
  88
  89     Pattern pattern = Pattern.compile(SynchronizerConstants.TIMESTAMP24HOURS_PATTERN);
  90     Matcher matcher = pattern.matcher(targetSyncStartTimeStamp);
  91     if (!matcher.matches()) {
  92       throw new IllegalArgumentException("Invalid time format for targetSyncStartTimeStamp");
  93     }
  94
  95     List<String> timestampVal = Arrays.asList(targetSyncStartTimeStamp.split(" "));
  96
  97     if (timestampVal.size() == SynchronizerConstants.COMPONENTS_IN_TIMESTAMP) {
  98
  99       // Need both time and timezone offset
 100       timeZoneOfSyncStartTimeStamp = timestampVal
 101           .get(SynchronizerConstants.IDX_TIMEZONE_IN_TIMESTAMP).replaceAll("UTC", "GMT");
 102
 103       String time = timestampVal.get(SynchronizerConstants.IDX_TIME_IN_TIMESTAMP);
 104       DateFormat format = new SimpleDateFormat("HH:mm:ss");
 105
 106       Date date = null;
 107
 108       try {
 109         date = format.parse(time);
 110       } catch (ParseException parseException) {
 111         throw new IllegalArgumentException(parseException);
 112       }
 113
 114       Calendar calendar = Calendar.getInstance();
 115       calendar.setTime(date);
 116
 117       syncTaskStartTimeHr = calendar.get(Calendar.HOUR_OF_DAY);
 118       syncTaskStartTimeMin = calendar.get(Calendar.MINUTE);
 119       syncTaskStartTimeSec = calendar.get(Calendar.SECOND);
 120     } else {
 121       throw new IllegalArgumentException("Invalid timestamp format from targetSyncStartTimeStamp");
 122     }
 123
 124   }
 125
 126
 127   public int getNumInternalSyncWorkers() {
 128     return numInternalSyncWorkers;
 129   }
 130
 131   public void setNumInternalSyncWorkers(int numInternalSyncWorkers) {
 132     this.numInternalSyncWorkers = numInternalSyncWorkers;
 133   }
 134
 135   public int getNumSyncElasticWorkers() {
 136     return numSyncElasticWorkers;
 137   }
 138
 139   public void setNumSyncElasticWorkers(int numSyncElasticWorkers) {
 140     this.numSyncElasticWorkers = numSyncElasticWorkers;
 141   }
 142
 143   public int getNumSyncActiveInventoryWorkers() {
 144     return numSyncActiveInventoryWorkers;
 145   }
 146
 147   public void setNumSyncActiveInventoryWorkers(int numSyncActiveInventoryWorkers) {
 148     this.numSyncActiveInventoryWorkers = numSyncActiveInventoryWorkers;
 149   }
 150
 151   public String getTargetSyncStartTimeStamp() {
 152     return targetSyncStartTimeStamp;
 153   }
 154
 155   public void setTargetSyncStartTimeStamp(String targetSyncStartTimeStamp) {
 156     this.targetSyncStartTimeStamp = targetSyncStartTimeStamp;
 157     initializeSyncTimeParameters();
 158   }
 159
 160   public String getControllerName() {
 161     return controllerName;
 162   }
 163
 164   public void setControllerName(String controllerName) {
 165     this.controllerName = controllerName;
 166   }
 167
 168   public boolean isEnabled() {
 169     return enabled;
 170   }
 171
 172   public void setEnabled(boolean enabled) {
 173     this.enabled = enabled;
 174   }
 175
 176   public int getSyncTaskDelayInMs() {
 177     return syncTaskDelayInMs;
 178   }
 179
 180   public void setSyncTaskDelayInMs(int syncTaskDelayInMs) {
 181     this.syncTaskDelayInMs = syncTaskDelayInMs;
 182   }
 183
 184   public int getSyncTaskFrequencyInDays() {
 185     return syncTaskFrequencyInDays;
 186   }
 187
 188   public void setSyncTaskFrequencyInDays(int syncTaskFrequencyInDays) {
 189     this.syncTaskFrequencyInDays = syncTaskFrequencyInDays;
 190   }
 191
 192   public int getNumSyncControllerWorkers() {
 193     return numSyncControllerWorkers;
 194   }
 195
 196   public void setNumSyncControllerWorkers(int numSyncControllerWorkers) {
 197     this.numSyncControllerWorkers = numSyncControllerWorkers;
 198   }
 199
 200   public boolean isRunOnceSyncEnabled() {
 201     return runOnceSyncEnabled;
 202   }
 203
 204   public void setRunOnceSyncEnabled(boolean runOnceSyncEnabled) {
 205     this.runOnceSyncEnabled = runOnceSyncEnabled;
 206   }
 207
 208   public boolean isPeriodicSyncEnabled() {
 209     return periodicSyncEnabled;
 210   }
 211
 212   public void setPeriodicSyncEnabled(boolean periodicSyncEnabled) {
 213     this.periodicSyncEnabled = periodicSyncEnabled;
 214   }
 215
 216   public long getSyncFrequencyInMs() {
 217
 218     return (syncTaskFrequencyInDays * SynchronizerConstants.MILLISEC_IN_A_DAY);
 219
 220   }
 221
 222   public Calendar getTargetSyncTime() {
 223
 224     TimeZone tz = TimeZone.getTimeZone(timeZoneOfSyncStartTimeStamp);
 225     Calendar targetSyncTime = Calendar.getInstance(tz);
 226
 227     targetSyncTime.set(Calendar.HOUR_OF_DAY, syncTaskStartTimeHr);
 228     targetSyncTime.set(Calendar.MINUTE, syncTaskStartTimeMin);
 229     targetSyncTime.set(Calendar.SECOND, syncTaskStartTimeSec);
 230
 231     return targetSyncTime;
 232
 233   }
 234
 235
 236   public String getNextSyncTime() {
 237
 238     int taskFrequencyInSeconds = 0;
 239     if (getSyncFrequencyInMs() > 0) {
 240       taskFrequencyInSeconds = (int) (getSyncFrequencyInMs() / 1000);
 241     }
 242
 243     if (taskFrequencyInSeconds < 86400) {
 244
 245       TimeZone tz = TimeZone.getTimeZone(timeZoneOfSyncStartTimeStamp);
 246       Calendar targetSyncTime = Calendar.getInstance(tz);
 247       targetSyncTime.add(Calendar.SECOND, taskFrequencyInSeconds);
 248
 249       return SynchronizerConstants.SIMPLE_DATE_FORMAT.format(targetSyncTime.getTimeInMillis())
 250           .replaceAll(SynchronizerConstants.TIME_STD, SynchronizerConstants.TIME_CONFIG_STD);
 251
 252     } else {
 253
 254       return SynchronizerConstants.SIMPLE_DATE_FORMAT
 255           .format(getNextSyncTime(getTargetSyncTime(), taskFrequencyInSeconds))
 256           .replaceAll(SynchronizerConstants.TIME_STD, SynchronizerConstants.TIME_CONFIG_STD);
 257
 258     }
 259
 260   }
 261
 262   public long getNextSyncTime(Calendar syncTime, int taskFrequencyInSeconds) {
 263
 264     TimeZone tz = TimeZone.getTimeZone(timeZoneOfSyncStartTimeStamp);
 265     Calendar timeNow = Calendar.getInstance(tz);
 266
 267     return getNextSyncTime(syncTime, timeNow.getTimeInMillis(), taskFrequencyInSeconds);
 268   }
 269
 270   /**
 271    * Gets the first sync time.
 272    *
 273    * @param calendar the calendar
 274    * @param timeNow the time now in ms
 275    * @param taskFrequencyInMs task period in ms
 276    * @return the first sync time
 277    */
 278
 279   public long getNextSyncTime(Calendar syncTime, long timeNowInMs, int taskFrequencyInSeconds) {
 280     if (taskFrequencyInSeconds == 0) {
 281       return 0;
 282     } else if (timeNowInMs > syncTime.getTimeInMillis()) {
 283
 284       /*
 285        * If current time is after the scheduled sync start time, then we'll skip ahead to the next
 286        * sync time period
 287        */
 288
 289       syncTime.add(Calendar.SECOND, taskFrequencyInSeconds);
 290     }
 291
 292     return syncTime.getTimeInMillis();
 293   }
 294
 295   public String getTimeZoneOfSyncStartTimeStamp() {
 296     return timeZoneOfSyncStartTimeStamp;
 297   }
 298
 299   public void setTimeZoneOfSyncStartTimeStamp(String timeZoneOfSyncStartTimeStamp) {
 300     this.timeZoneOfSyncStartTimeStamp = timeZoneOfSyncStartTimeStamp;
 301   }
 302
 303
 304
 305 }