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