common/src/main/java/org/commscope/tr069adapter/common/scheduler/impl/QuartzSchedulerManager.java

   1 /*\r
   2  * ============LICENSE_START========================================================================\r
   3  * ONAP : tr-069-adapter\r
   4  * =================================================================================================\r
   5  * Copyright (C) 2020 CommScope Inc Intellectual Property.\r
   6  * =================================================================================================\r
   7  * This tr-069-adapter software file is distributed by CommScope Inc under the Apache License,\r
   8  * Version 2.0 (the "License"); you may not use this file except in compliance with the License. You\r
   9  * may obtain a copy of the License at\r
  10  *\r
  11  * http://www.apache.org/licenses/LICENSE-2.0\r
  12  *\r
  13  * This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\r
  14  * either express or implied. See the License for the specific language governing permissions and\r
  15  * limitations under the License.\r
  16  * ===============LICENSE_END=======================================================================\r
  17  */\r
  18 \r
  19 \r
  20 package org.commscope.tr069adapter.common.scheduler.impl;\r
  21 \r
  22 import static org.commscope.tr069adapter.common.scheduler.impl.QuartzSchedulerConstants.END_TIME_APPENDER;\r
  23 import static org.commscope.tr069adapter.common.scheduler.impl.QuartzSchedulerConstants.JOB_APPENDER;\r
  24 import static org.commscope.tr069adapter.common.scheduler.impl.QuartzSchedulerConstants.TRIGGER_APPENDER;\r
  25 \r
  26 import java.util.ArrayList;\r
  27 import java.util.HashMap;\r
  28 import java.util.List;\r
  29 import java.util.Map;\r
  30 import java.util.Map.Entry;\r
  31 import java.util.Set;\r
  32 \r
  33 import javax.annotation.PostConstruct;\r
  34 import javax.annotation.PreDestroy;\r
  35 \r
  36 import org.apache.commons.logging.Log;\r
  37 import org.apache.commons.logging.LogFactory;\r
  38 import org.commscope.tr069adapter.common.scheduler.ExecutionContext;\r
  39 import org.commscope.tr069adapter.common.scheduler.JobInfo;\r
  40 import org.commscope.tr069adapter.common.scheduler.SchedulerError;\r
  41 import org.commscope.tr069adapter.common.scheduler.SchedulerException;\r
  42 import org.commscope.tr069adapter.common.scheduler.SchedulerManager;\r
  43 import org.commscope.tr069adapter.common.scheduler.TriggerInfo;\r
  44 import org.quartz.JobDetail;\r
  45 import org.quartz.JobExecutionException;\r
  46 import org.quartz.JobKey;\r
  47 import org.quartz.JobPersistenceException;\r
  48 import org.quartz.Scheduler;\r
  49 import org.quartz.SchedulerConfigException;\r
  50 import org.quartz.Trigger;\r
  51 import org.quartz.Trigger.TriggerState;\r
  52 import org.quartz.TriggerKey;\r
  53 import org.quartz.UnableToInterruptJobException;\r
  54 import org.springframework.beans.factory.annotation.Autowired;\r
  55 import org.springframework.stereotype.Component;\r
  56 \r
  57 @Component\r
  58 public class QuartzSchedulerManager implements SchedulerManager {\r
  59 \r
  60   private static final String EXCEPTION_WHILE_GETTING_GET_JOB_INFO =\r
  61       "Exception while getting getJobInfo : ";\r
  62 \r
  63   private static final String ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB =\r
  64       "enableJob : Disable schedule for job ";\r
  65 \r
  66   private static final String METHOD_STARTED = " method started";\r
  67 \r
  68   private static final String EXCEPTION_WHILE_DISABLING_JOB = "Exception while disabling job : ";\r
  69 \r
  70   private static final String EXCEPTION_WHILE_CHECKING_JOB_ENABLE_STATE =\r
  71       "Exception while checking job enable state : ";\r
  72 \r
  73   private static final String ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB =\r
  74       "enableJob : Enable schedule for job ";\r
  75 \r
  76   private static final String EXCEPTION_WHILE_GETTING_JOB_LIST =\r
  77       "Exception while getting JobList : ";\r
  78 \r
  79   private static final String GET_JOB_LIST_METHOD_ENDED = "getJobList : method ended";\r
  80 \r
  81   private static final String EXCEPTION_WHILE_MODIFYING_SCHEDULE =\r
  82       "Exception while modifying schedule : ";\r
  83 \r
  84   private static final String MODIFY_SCHEDULE_MODIFY_SCHEDULE_FOR_JOB =\r
  85       "modifySchedule : Modify schedule for job ";\r
  86 \r
  87   private static final String EXCEPTION_WHILE_DELETING_SCHEDULE =\r
  88       "Exception while deleting schedule : ";\r
  89 \r
  90   private static final String DELETE_SCHEDULE_DELETING_SCHEDULE_FOR_JOB =\r
  91       "deleteSchedule : Deleting schedule for job ";\r
  92 \r
  93   private static final String EXCEPTION_WHILE_SCHEDULING_JOB_EXCEPTION =\r
  94       "Exception while scheduling job. Exception : ";\r
  95 \r
  96   private static final String SUCCESSFULLY_COMPLETED = " successfully completed";\r
  97 \r
  98   private static final String STARTED = " started";\r
  99 \r
 100   private static final String SCHEDULE_JOB_SCHEDUING_JOB = "scheduleJob : Scheduing job ";\r
 101 \r
 102   private static final String QUATZ_SCHEUDLER_FAILED_TO_START_CAUGHT_EXCEPTION =\r
 103       "Quatz scheudler failed to start: Caught Exception: ";\r
 104 \r
 105   @Autowired\r
 106   private Scheduler quartzScheduler;\r
 107 \r
 108   @Autowired\r
 109   QuartzSchedulerProducer quartzSchedulerProducer;\r
 110 \r
 111   private static final Log logger = LogFactory.getLog(QuartzSchedulerManager.class);\r
 112 \r
 113   public void setScheduler(Scheduler scheduler) {\r
 114     this.quartzScheduler = scheduler;\r
 115   }\r
 116 \r
 117   @Autowired\r
 118   QuartzSchedulerUtil schdulerUtil;\r
 119 \r
 120   public void setSchedulerUtil(QuartzSchedulerUtil schedulerUtil) {\r
 121     this.schdulerUtil = schedulerUtil;\r
 122   }\r
 123 \r
 124   @PostConstruct\r
 125   public void init() throws org.quartz.SchedulerException {\r
 126     logger.debug("init started");\r
 127     try {\r
 128       if (!quartzScheduler.isStarted()) {\r
 129         logger.debug("Running on active server; hence marking quartz as active service");\r
 130         quartzScheduler.start();\r
 131       }\r
 132     } catch (org.quartz.SchedulerException e) {\r
 133       logger.error(QUATZ_SCHEUDLER_FAILED_TO_START_CAUGHT_EXCEPTION + e.getMessage());\r
 134       throw e;\r
 135     }\r
 136 \r
 137     logger.debug("init complete");\r
 138   }\r
 139 \r
 140   @PreDestroy\r
 141   public void shutDown() throws org.quartz.SchedulerException {\r
 142     try {\r
 143       if (!quartzScheduler.isShutdown()) {\r
 144         quartzScheduler.shutdown();\r
 145       }\r
 146 \r
 147     } catch (org.quartz.SchedulerException e) {\r
 148       logger.debug("Quatz scheudler failed to stop: Caught Exception: " + e.getMessage());\r
 149       throw e;\r
 150     }\r
 151   }\r
 152 \r
 153   @Override\r
 154   public void scheduleJob(String jobName, TriggerInfo triggerInfo, ExecutionContext jobContext)\r
 155       throws SchedulerException {\r
 156 \r
 157     logger.debug(SCHEDULE_JOB_SCHEDUING_JOB + jobName + STARTED);\r
 158     Trigger trigger = this.getTrigger(jobName);\r
 159     if (null != trigger)\r
 160       throw new SchedulerException(SchedulerError.SCHEDULE_EXIST_ALREADY);\r
 161     try {\r
 162       if (quartzScheduler.isInStandbyMode()) {\r
 163         logger.debug(\r
 164             "scheduleJob : Server running on stand by mode; hence ignore Scheduing job " + jobName);\r
 165         return;\r
 166       }\r
 167 \r
 168       JobDetail jobDetail = schdulerUtil.getJobDetail(jobContext, jobName);\r
 169       trigger = schdulerUtil.createTrigger(triggerInfo, jobName);\r
 170       quartzScheduler.scheduleJob(jobDetail, trigger);\r
 171       logger.debug(SCHEDULE_JOB_SCHEDUING_JOB + jobName + SUCCESSFULLY_COMPLETED);\r
 172     } catch (org.quartz.SchedulerException exception) {\r
 173       SchedulerException scheduleExcep = resolveError(exception);\r
 174       logger.error(EXCEPTION_WHILE_SCHEDULING_JOB_EXCEPTION + exception.getMessage());\r
 175       throw scheduleExcep;\r
 176     }\r
 177   }\r
 178 \r
 179   @Override\r
 180   public void scheduleJob(String jobName, String jobGroup, TriggerInfo triggerInfo,\r
 181       ExecutionContext jobContext) throws SchedulerException {\r
 182 \r
 183     logger.debug(SCHEDULE_JOB_SCHEDUING_JOB + jobName + STARTED);\r
 184     Trigger trigger = this.getTrigger(jobName, jobGroup);\r
 185     if (null != trigger)\r
 186       throw new SchedulerException(SchedulerError.SCHEDULE_EXIST_ALREADY);\r
 187     try {\r
 188       if (quartzScheduler.isInStandbyMode()) {\r
 189         logger.debug("scheduleJob : Server is running on stand by mode; hence ignore Scheduing job "\r
 190             + jobName);\r
 191         return;\r
 192       }\r
 193 \r
 194       JobDetail jobDetail = schdulerUtil.getJobDetail(jobContext, jobName, jobGroup);\r
 195       trigger = schdulerUtil.createTrigger(triggerInfo, jobName, jobGroup);\r
 196       quartzScheduler.scheduleJob(jobDetail, trigger);\r
 197       logger.debug(SCHEDULE_JOB_SCHEDUING_JOB + jobName + SUCCESSFULLY_COMPLETED);\r
 198     } catch (org.quartz.SchedulerException exception) {\r
 199       SchedulerException scheduleExcep = resolveError(exception);\r
 200       logger.error(EXCEPTION_WHILE_SCHEDULING_JOB_EXCEPTION + exception.getMessage());\r
 201       throw scheduleExcep;\r
 202     }\r
 203   }\r
 204 \r
 205   @Override\r
 206   public void scheduleJob(String jobName, String jobGroup, TriggerInfo triggerInfo,\r
 207       ExecutionContext jobContext, TriggerInfo expiredTriggerInfo,\r
 208       ExecutionContext expiredExecutionContext) throws SchedulerException {\r
 209 \r
 210     logger.debug(SCHEDULE_JOB_SCHEDUING_JOB + jobName + STARTED);\r
 211     Trigger trigger = this.getTrigger(jobName);\r
 212     if (null != trigger)\r
 213       throw new SchedulerException(SchedulerError.SCHEDULE_EXIST_ALREADY);\r
 214     try {\r
 215       if (quartzScheduler.isInStandbyMode()) {\r
 216         logger.debug("scheduleJob : Server is running on stand by mode; hence ignore Scheduing job "\r
 217             + jobName);\r
 218         return;\r
 219       }\r
 220 \r
 221       JobDetail jobDetail = schdulerUtil.getJobDetail(jobContext, jobName, jobGroup);\r
 222       trigger = schdulerUtil.createTrigger(triggerInfo, jobName, jobGroup);\r
 223       quartzScheduler.scheduleJob(jobDetail, trigger);\r
 224       if (expiredTriggerInfo != null && expiredExecutionContext != null) {\r
 225         if (isJobScheduleExist(jobName + END_TIME_APPENDER, jobGroup)) {\r
 226           deleteSchedule(jobName + END_TIME_APPENDER, jobGroup);\r
 227         }\r
 228         JobDetail expiredJobDetail = schdulerUtil.getJobDetail(expiredExecutionContext,\r
 229             jobName + END_TIME_APPENDER, jobGroup);\r
 230         Trigger expiredTrigger =\r
 231             schdulerUtil.createTrigger(expiredTriggerInfo, jobName + END_TIME_APPENDER, jobGroup);\r
 232         quartzScheduler.scheduleJob(expiredJobDetail, expiredTrigger);\r
 233       }\r
 234       logger.debug(SCHEDULE_JOB_SCHEDUING_JOB + jobName + SUCCESSFULLY_COMPLETED);\r
 235     } catch (org.quartz.SchedulerException exception) {\r
 236       SchedulerException scheduleExcep = resolveError(exception);\r
 237       logger.error(EXCEPTION_WHILE_SCHEDULING_JOB_EXCEPTION + exception.getMessage());\r
 238       throw scheduleExcep;\r
 239     }\r
 240   }\r
 241 \r
 242   @Override\r
 243   public void deleteSchedule(String jobName) throws SchedulerException {\r
 244     try {\r
 245       logger.debug(DELETE_SCHEDULE_DELETING_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 246       Trigger trigger = this.getTrigger(jobName);\r
 247       if (null == trigger)\r
 248         throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 249       quartzScheduler.unscheduleJob(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName));\r
 250       logger.debug(DELETE_SCHEDULE_DELETING_SCHEDULE_FOR_JOB + jobName + SUCCESSFULLY_COMPLETED);\r
 251     } catch (org.quartz.SchedulerException exception) {\r
 252       SchedulerException scheduleExcep = resolveError(exception);\r
 253       if (scheduleExcep.getScheduleError() == SchedulerError.UNKNOWN_ERROR)\r
 254         scheduleExcep = new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 255       logger.error(EXCEPTION_WHILE_DELETING_SCHEDULE + exception.getMessage());\r
 256       throw scheduleExcep;\r
 257     }\r
 258   }\r
 259 \r
 260   @Override\r
 261   public void modifySchedule(String jobName, TriggerInfo triggerInfo) throws SchedulerException {\r
 262 \r
 263     logger.debug(MODIFY_SCHEDULE_MODIFY_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 264     Trigger trigger = this.getTrigger(jobName);\r
 265     if (null == trigger)\r
 266       throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 267     trigger = schdulerUtil.createTrigger(triggerInfo, jobName);\r
 268     try {\r
 269       if (quartzScheduler.isInStandbyMode()) {\r
 270         logger.debug(\r
 271             "modifySchedule : Server is running on stand by mode; hence ignore modifySchedule job "\r
 272                 + jobName);\r
 273       }\r
 274 \r
 275       quartzScheduler.rescheduleJob(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName),\r
 276           trigger);\r
 277       logger.debug(MODIFY_SCHEDULE_MODIFY_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 278     } catch (org.quartz.SchedulerException exception) {\r
 279       SchedulerException scheduleExcep = resolveError(exception);\r
 280       logger.error(EXCEPTION_WHILE_MODIFYING_SCHEDULE + exception.getMessage());\r
 281       throw scheduleExcep;\r
 282     }\r
 283   }\r
 284 \r
 285   @Override\r
 286   public void modifySchedule(String jobName, String jobGroup, TriggerInfo triggerInfo,\r
 287       TriggerInfo expiredTriggerInfo, ExecutionContext expiredExecutionContext)\r
 288       throws SchedulerException {\r
 289 \r
 290     logger.debug(MODIFY_SCHEDULE_MODIFY_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 291     Trigger trigger = this.getTrigger(jobName, jobGroup);\r
 292     if (null == trigger)\r
 293       throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 294     trigger = schdulerUtil.createTrigger(triggerInfo, jobName, jobGroup);\r
 295     try {\r
 296       quartzScheduler.rescheduleJob(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup),\r
 297           trigger);\r
 298       Trigger previousExpiredTrig = this.getTrigger(jobName + END_TIME_APPENDER, jobGroup);\r
 299       Trigger curExpiredTrigger =\r
 300           schdulerUtil.createTrigger(expiredTriggerInfo, jobName + END_TIME_APPENDER, jobGroup);\r
 301 \r
 302       if (previousExpiredTrig != null && expiredTriggerInfo != null) {\r
 303         quartzScheduler.rescheduleJob(\r
 304             TriggerKey.triggerKey(jobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup),\r
 305             curExpiredTrigger);\r
 306       } else if (previousExpiredTrig != null) {\r
 307         quartzScheduler.unscheduleJob(\r
 308             TriggerKey.triggerKey(jobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup));\r
 309       } else if (expiredTriggerInfo != null) {\r
 310         JobDetail expiredJobDetail = schdulerUtil.getJobDetail(expiredExecutionContext,\r
 311             jobName + END_TIME_APPENDER, jobGroup);\r
 312         quartzScheduler.scheduleJob(expiredJobDetail, curExpiredTrigger);\r
 313       }\r
 314 \r
 315       logger.debug(MODIFY_SCHEDULE_MODIFY_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 316     } catch (org.quartz.SchedulerException exception) {\r
 317       SchedulerException scheduleExcep = resolveError(exception);\r
 318       logger.error(EXCEPTION_WHILE_MODIFYING_SCHEDULE + exception.getMessage());\r
 319       throw scheduleExcep;\r
 320     }\r
 321   }\r
 322 \r
 323   @Override\r
 324   public List<JobInfo> getJobList() {\r
 325     final String methodName = "getJobList";\r
 326     logger.debug(methodName + " : " + METHOD_STARTED);\r
 327     List<String> triggerGroups = null;\r
 328     List<JobInfo> jobInfoList = new ArrayList<>();\r
 329     try {\r
 330       triggerGroups = quartzScheduler.getTriggerGroupNames();\r
 331       for (String triggerGroup : triggerGroups) {\r
 332         Trigger trigger = quartzScheduler\r
 333             .getTrigger(TriggerKey.triggerKey(triggerGroup + TRIGGER_APPENDER, triggerGroup));\r
 334         JobInfo jobInfo = new JobInfo();\r
 335 \r
 336         jobInfo.setEnabled(isJobEnabled(triggerGroup));\r
 337         jobInfo.setJobName(triggerGroup);\r
 338         jobInfo.setTriggerInfo(schdulerUtil.getTriggerInfo(trigger));\r
 339         jobInfoList.add(jobInfo);\r
 340         logger.debug(GET_JOB_LIST_METHOD_ENDED);\r
 341       }\r
 342     } catch (org.quartz.SchedulerException exception) {\r
 343       logger.error(EXCEPTION_WHILE_GETTING_JOB_LIST + exception.getLocalizedMessage());\r
 344     }\r
 345     return jobInfoList;\r
 346   }\r
 347 \r
 348   @Override\r
 349   public JobInfo getJobInfo(String jobId) {\r
 350     final String methodName = "getJobInfo";\r
 351     logger.debug(methodName + " : " + METHOD_STARTED);\r
 352     List<String> triggerGroups = null;\r
 353     try {\r
 354       triggerGroups = quartzScheduler.getTriggerGroupNames();\r
 355       for (String triggerGroup : triggerGroups) {\r
 356         Trigger trigger = quartzScheduler\r
 357             .getTrigger(TriggerKey.triggerKey(triggerGroup + TRIGGER_APPENDER, triggerGroup));\r
 358         JobInfo jobInfo = new JobInfo();\r
 359 \r
 360         jobInfo.setEnabled(isJobEnabled(triggerGroup));\r
 361         jobInfo.setJobName(triggerGroup);\r
 362         jobInfo.setTriggerInfo(schdulerUtil.getTriggerInfo(trigger));\r
 363         if (jobId.equals(triggerGroup)) {\r
 364           logger.debug(methodName + " : " + "method ended");\r
 365           return jobInfo;\r
 366         }\r
 367       }\r
 368     } catch (org.quartz.SchedulerException exception) {\r
 369       logger.error(EXCEPTION_WHILE_GETTING_GET_JOB_INFO + exception.getLocalizedMessage());\r
 370     }\r
 371     logger.debug(methodName + " : " + "method ended");\r
 372     return null;\r
 373   }\r
 374 \r
 375   Trigger getTrigger(String jobName) {\r
 376     Trigger trigger = null;\r
 377     try {\r
 378       trigger =\r
 379           quartzScheduler.getTrigger(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName));\r
 380     } catch (org.quartz.SchedulerException e) {\r
 381       logger.error(e.getLocalizedMessage());\r
 382     }\r
 383     return trigger;\r
 384   }\r
 385 \r
 386   Trigger getTrigger(String jobName, String jobGroup) {\r
 387     Trigger trigger = null;\r
 388     try {\r
 389       trigger =\r
 390           quartzScheduler.getTrigger(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup));\r
 391     } catch (org.quartz.SchedulerException e) {\r
 392       logger.error(e.getLocalizedMessage());\r
 393     }\r
 394     return trigger;\r
 395   }\r
 396 \r
 397   @Override\r
 398   public boolean isJobEnabled(String jobName) {\r
 399     boolean retVal = true;\r
 400 \r
 401     try {\r
 402       Trigger trigger = getTrigger(jobName);\r
 403       if (null == trigger)\r
 404         return false;\r
 405       retVal = quartzScheduler\r
 406           .getTriggerState(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName))\r
 407           .equals(TriggerState.PAUSED);\r
 408     } catch (org.quartz.SchedulerException exception) {\r
 409       logger.error(EXCEPTION_WHILE_CHECKING_JOB_ENABLE_STATE + exception.getMessage());\r
 410     }\r
 411     return !retVal;\r
 412   }\r
 413 \r
 414   @Override\r
 415   public void enableJob(String jobName) throws SchedulerException {\r
 416     logger.debug(ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 417     try {\r
 418       Trigger trigger = getTrigger(jobName);\r
 419       if (null == trigger)\r
 420         throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 421       if (quartzScheduler\r
 422           .getTriggerState(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName))\r
 423           .equals(TriggerState.PAUSED))\r
 424         quartzScheduler.resumeTrigger(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName));\r
 425 \r
 426     } catch (org.quartz.SchedulerException exception) {\r
 427       SchedulerException scheduleExcep = resolveError(exception);\r
 428       if (scheduleExcep.getScheduleError() == SchedulerError.UNKNOWN_ERROR)\r
 429         scheduleExcep = new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 430       logger.error(EXCEPTION_WHILE_DISABLING_JOB + exception.getMessage());\r
 431       throw scheduleExcep;\r
 432     }\r
 433     logger.debug(ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB + jobName + SUCCESSFULLY_COMPLETED);\r
 434   }\r
 435 \r
 436   @Override\r
 437   public void disableJob(String jobName) throws SchedulerException {\r
 438     logger.debug(ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 439     try {\r
 440       Trigger trigger = getTrigger(jobName);\r
 441       if (null == trigger)\r
 442         throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 443       if (!quartzScheduler\r
 444           .getTriggerState(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName))\r
 445           .equals(TriggerState.PAUSED))\r
 446         quartzScheduler.pauseTrigger(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName));\r
 447 \r
 448     } catch (org.quartz.SchedulerException exception) {\r
 449       SchedulerException scheduleExcep = resolveError(exception);\r
 450       if (scheduleExcep.getScheduleError() == SchedulerError.UNKNOWN_ERROR)\r
 451         scheduleExcep = new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 452       logger.error(EXCEPTION_WHILE_DISABLING_JOB + exception.getMessage());\r
 453       throw scheduleExcep;\r
 454     }\r
 455     logger.debug(ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB + jobName + SUCCESSFULLY_COMPLETED);\r
 456   }\r
 457 \r
 458   private SchedulerException resolveError(org.quartz.SchedulerException excep) {\r
 459     SchedulerException schedulerExcep = new SchedulerException(SchedulerError.UNKNOWN_ERROR);\r
 460     try {\r
 461       throw excep;\r
 462     } catch (JobExecutionException jobExec) {\r
 463       logger.error("JobExecutionException : " + jobExec.getMessage());\r
 464       schedulerExcep = new SchedulerException(SchedulerError.JOB_EXECUTION_ERROR);\r
 465     } catch (JobPersistenceException persistenExcep) {\r
 466       schedulerExcep = new SchedulerException(SchedulerError.DATABASE_ERROR);\r
 467     } catch (SchedulerConfigException configExcep) {\r
 468       schedulerExcep = new SchedulerException(SchedulerError.INVALID_CONFIG);\r
 469     } catch (UnableToInterruptJobException interruExcep) {\r
 470       schedulerExcep = new SchedulerException(SchedulerError.INTERRUPT_ERROR);\r
 471     } catch (org.quartz.SchedulerException e) {\r
 472       logger.error("SchedulerException : " + e.getMessage());\r
 473     }\r
 474     return schedulerExcep;\r
 475   }\r
 476 \r
 477   @Override\r
 478   public boolean isJobExist(String jobName) throws SchedulerException {\r
 479     Trigger trigger = this.getTrigger(jobName);\r
 480     return (null != trigger);\r
 481   }\r
 482 \r
 483   @Override\r
 484   public void modifySchedule(String jobName, String jobGroup, TriggerInfo triggerInfo)\r
 485       throws SchedulerException {\r
 486     logger.debug(MODIFY_SCHEDULE_MODIFY_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 487     Trigger trigger = this.getTrigger(jobName, jobGroup);\r
 488     if (null == trigger)\r
 489       throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 490     trigger = schdulerUtil.createTrigger(triggerInfo, jobName, jobGroup);\r
 491     try {\r
 492       quartzScheduler.rescheduleJob(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup),\r
 493           trigger);\r
 494       logger.debug(MODIFY_SCHEDULE_MODIFY_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 495     } catch (org.quartz.SchedulerException exception) {\r
 496       SchedulerException scheduleExcep = resolveError(exception);\r
 497       logger.error(EXCEPTION_WHILE_MODIFYING_SCHEDULE + exception.getMessage());\r
 498       throw scheduleExcep;\r
 499     }\r
 500 \r
 501   }\r
 502 \r
 503   @Override\r
 504   public void deleteSchedule(String jobName, String jobGroup) throws SchedulerException {\r
 505     try {\r
 506       logger.debug(DELETE_SCHEDULE_DELETING_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 507       Trigger trigger = this.getTrigger(jobName, jobGroup);\r
 508       if (null == trigger)\r
 509         throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 510       Trigger endTimeTrigger =\r
 511           this.getTrigger(jobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup);\r
 512       if (null != endTimeTrigger) {\r
 513         quartzScheduler.unscheduleJob(\r
 514             TriggerKey.triggerKey(jobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup));\r
 515       }\r
 516       quartzScheduler.unscheduleJob(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup));\r
 517       logger.debug(DELETE_SCHEDULE_DELETING_SCHEDULE_FOR_JOB + jobName + SUCCESSFULLY_COMPLETED);\r
 518     } catch (org.quartz.SchedulerException exception) {\r
 519       SchedulerException scheduleExcep = resolveError(exception);\r
 520       if (scheduleExcep.getScheduleError() == SchedulerError.UNKNOWN_ERROR)\r
 521         scheduleExcep = new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 522       logger.error(EXCEPTION_WHILE_DELETING_SCHEDULE + exception.getMessage());\r
 523       throw scheduleExcep;\r
 524     }\r
 525   }\r
 526 \r
 527   // Delete all jobs together or nothing.\r
 528   // TODO- This need to be taken care by Container-Managed Transactions later\r
 529 \r
 530   @Override\r
 531   public void deleteSchedule(String startJobName, String endJobName, String monitorJobName,\r
 532       String jobGroup) throws SchedulerException {\r
 533     try {\r
 534       logger.debug(DELETE_SCHEDULE_DELETING_SCHEDULE_FOR_JOB + startJobName + STARTED);\r
 535       Trigger trigger1 = this.getTrigger(startJobName, jobGroup);\r
 536       Trigger trigger2 = this.getTrigger(endJobName, jobGroup);\r
 537       Trigger trigger3 = this.getTrigger(monitorJobName, jobGroup);\r
 538 \r
 539       Trigger endTimeTrigger1 =\r
 540           this.getTrigger(startJobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup);\r
 541       Trigger endTimeTrigger2 =\r
 542           this.getTrigger(endJobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup);\r
 543       Trigger endTimeTrigger3 =\r
 544           this.getTrigger(monitorJobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup);\r
 545 \r
 546       logger.debug(DELETE_SCHEDULE_DELETING_SCHEDULE_FOR_JOB + startJobName + ", " + endJobName\r
 547           + ", " + monitorJobName + SUCCESSFULLY_COMPLETED);\r
 548       if (null != endTimeTrigger1) {\r
 549         quartzScheduler.unscheduleJob(\r
 550             TriggerKey.triggerKey(startJobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup));\r
 551       }\r
 552       if (null != endTimeTrigger2) {\r
 553         quartzScheduler.unscheduleJob(\r
 554             TriggerKey.triggerKey(endJobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup));\r
 555       }\r
 556       if (null != endTimeTrigger3) {\r
 557         quartzScheduler.unscheduleJob(\r
 558             TriggerKey.triggerKey(monitorJobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup));\r
 559       }\r
 560       if (null != trigger1) {\r
 561         quartzScheduler\r
 562             .unscheduleJob(TriggerKey.triggerKey(startJobName + TRIGGER_APPENDER, jobGroup));\r
 563       }\r
 564       if (null != trigger2) {\r
 565         quartzScheduler\r
 566             .unscheduleJob(TriggerKey.triggerKey(endJobName + TRIGGER_APPENDER, jobGroup));\r
 567       }\r
 568       if (null != trigger3) {\r
 569         quartzScheduler\r
 570             .unscheduleJob(TriggerKey.triggerKey(monitorJobName + TRIGGER_APPENDER, jobGroup));\r
 571       }\r
 572 \r
 573     } catch (org.quartz.SchedulerException exception) {\r
 574       SchedulerException scheduleExcep = resolveError(exception);\r
 575       if (scheduleExcep.getScheduleError() == SchedulerError.UNKNOWN_ERROR)\r
 576         scheduleExcep = new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 577       logger.error(EXCEPTION_WHILE_DELETING_SCHEDULE + exception.getMessage());\r
 578       throw scheduleExcep;\r
 579     }\r
 580   }\r
 581 \r
 582   @Override\r
 583   public boolean isJobEnabled(String jobName, String jobGroup) {\r
 584     boolean retVal = true;\r
 585 \r
 586     try {\r
 587       Trigger trigger = getTrigger(jobName, jobGroup);\r
 588       if (null == trigger)\r
 589         return false;\r
 590       retVal = quartzScheduler\r
 591           .getTriggerState(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup))\r
 592           .equals(TriggerState.PAUSED);\r
 593     } catch (org.quartz.SchedulerException exception) {\r
 594       logger.error(EXCEPTION_WHILE_CHECKING_JOB_ENABLE_STATE + exception.getMessage());\r
 595     }\r
 596     return !retVal;\r
 597   }\r
 598 \r
 599   @Override\r
 600   public void enableJob(String jobName, String jobGroup) throws SchedulerException {\r
 601     logger.debug(ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 602     try {\r
 603       Trigger trigger = getTrigger(jobName, jobGroup);\r
 604       if (null == trigger)\r
 605         throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 606       if (quartzScheduler\r
 607           .getTriggerState(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup))\r
 608           .equals(TriggerState.PAUSED))\r
 609         quartzScheduler.resumeTrigger(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup));\r
 610 \r
 611     } catch (org.quartz.SchedulerException exception) {\r
 612       SchedulerException scheduleExcep = resolveError(exception);\r
 613       if (scheduleExcep.getScheduleError() == SchedulerError.UNKNOWN_ERROR)\r
 614         scheduleExcep = new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 615       logger.error(EXCEPTION_WHILE_DISABLING_JOB + exception.getMessage());\r
 616       throw scheduleExcep;\r
 617     }\r
 618     logger.debug(ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB + jobName + SUCCESSFULLY_COMPLETED);\r
 619 \r
 620   }\r
 621 \r
 622   @Override\r
 623   public void disableJob(String jobName, String jobGroup) throws SchedulerException {\r
 624     logger.debug(ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB + jobName + STARTED);\r
 625     try {\r
 626       Trigger trigger = getTrigger(jobName, jobGroup);\r
 627       if (null == trigger)\r
 628         throw new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 629       if (!quartzScheduler\r
 630           .getTriggerState(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup))\r
 631           .equals(TriggerState.PAUSED))\r
 632         quartzScheduler.pauseTrigger(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup));\r
 633 \r
 634     } catch (org.quartz.SchedulerException exception) {\r
 635       SchedulerException scheduleExcep = resolveError(exception);\r
 636       if (scheduleExcep.getScheduleError() == SchedulerError.UNKNOWN_ERROR)\r
 637         scheduleExcep = new SchedulerException(SchedulerError.SCHEDULE_DOES_NOT_EXIST);\r
 638       logger.error(EXCEPTION_WHILE_DISABLING_JOB + exception.getMessage());\r
 639       throw scheduleExcep;\r
 640     }\r
 641     logger.debug(ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB + jobName + " completed");\r
 642 \r
 643   }\r
 644 \r
 645   @Override\r
 646   public boolean isJobExist(String jobName, String jobGroup) throws SchedulerException {\r
 647     Trigger trigger = this.getTrigger(jobName, jobGroup);\r
 648     return (null != trigger);\r
 649   }\r
 650 \r
 651   @Override\r
 652   public JobInfo getJobInfo(String jobId, String jobGroup) {\r
 653     final String methodName = "getJobInfo";\r
 654     logger.debug(methodName + " : " + METHOD_STARTED);\r
 655     try {\r
 656       TriggerKey triggerKey = TriggerKey.triggerKey(jobId + TRIGGER_APPENDER, jobGroup);\r
 657       Trigger trigger = quartzScheduler.getTrigger(triggerKey);\r
 658       if (null != trigger) {\r
 659         JobInfo jobInfo = new JobInfo();\r
 660         TriggerState triggerState = quartzScheduler.getTriggerState(triggerKey);\r
 661         jobInfo.setEnabled(TriggerState.PAUSED.equals(triggerState));\r
 662         jobInfo.setJobName(jobId);\r
 663         jobInfo.setTriggerInfo(schdulerUtil.getTriggerInfo(trigger));\r
 664         logger.debug(methodName + " : method ended");\r
 665         return jobInfo;\r
 666       }\r
 667     } catch (org.quartz.SchedulerException exception) {\r
 668       logger.error(EXCEPTION_WHILE_GETTING_GET_JOB_INFO + exception.getLocalizedMessage());\r
 669     }\r
 670     logger.debug(methodName + " : method ended");\r
 671     return null;\r
 672   }\r
 673 \r
 674   @Override\r
 675   public boolean isJobScheduleExist(String jobName, String jobGroup) throws SchedulerException {\r
 676     Trigger trigger = this.getTrigger(jobName, jobGroup);\r
 677     return null != trigger;\r
 678   }\r
 679 \r
 680   @Override\r
 681   public void updateJobData(String jobName, String jobGroup, Map<String, Object> jobData)\r
 682       throws SchedulerException {\r
 683     try {\r
 684       JobDetail jobDetail =\r
 685           quartzScheduler.getJobDetail(new JobKey(jobName + JOB_APPENDER, jobGroup));\r
 686       if (null != jobDetail) {\r
 687         for (Entry<String, Object> job : jobData.entrySet()) {\r
 688           jobDetail.getJobDataMap().put(job.getKey(), job.getValue());\r
 689         }\r
 690         quartzScheduler.addJob(jobDetail, true, true);\r
 691       }\r
 692 \r
 693     } catch (org.quartz.SchedulerException e) {\r
 694       logger.error("Failed to update job data", e);\r
 695       throw new SchedulerException(SchedulerError.UNKNOWN_ERROR);\r
 696     }\r
 697 \r
 698   }\r
 699 \r
 700   @Override\r
 701   public Map<String, Object> getJobData(String jobName, String jobGroup) throws SchedulerException {\r
 702 \r
 703     Map<String, Object> jobData = new HashMap<>();\r
 704     try {\r
 705       JobDetail jobDetail =\r
 706           quartzScheduler.getJobDetail(new JobKey(jobName + JOB_APPENDER, jobGroup));\r
 707       if (null == jobDetail)\r
 708         return jobData;\r
 709       for (String key : jobDetail.getJobDataMap().keySet()) {\r
 710         jobData.put(key, jobDetail.getJobDataMap().get(key));\r
 711       }\r
 712     } catch (org.quartz.SchedulerException e) {\r
 713       logger.error("Failed to get job data", e);\r
 714       throw new SchedulerException(SchedulerError.UNKNOWN_ERROR);\r
 715     }\r
 716     return jobData;\r
 717   }\r
 718 \r
 719   @Override\r
 720   public void deleteJobData(String jobName, String jobGroup, Set<String> keys)\r
 721       throws SchedulerException {\r
 722     try {\r
 723       JobDetail jobDetail =\r
 724           quartzScheduler.getJobDetail(new JobKey(jobName + JOB_APPENDER, jobGroup));\r
 725       for (String key : keys) {\r
 726         jobDetail.getJobDataMap().remove(key);\r
 727       }\r
 728       quartzScheduler.addJob(jobDetail, true, true);\r
 729     } catch (org.quartz.SchedulerException e) {\r
 730       logger.error("Failed to update job data", e);\r
 731       throw new SchedulerException(SchedulerError.UNKNOWN_ERROR);\r
 732     }\r
 733 \r
 734   }\r
 735 \r
 736   @Override\r
 737   public boolean resumeQuartzSchedulars() throws SchedulerException {\r
 738 \r
 739     try {\r
 740       if (quartzScheduler.isInStandbyMode()) {\r
 741         logger.debug("Server is running on active server; hence marking quartz as active service");\r
 742         quartzScheduler.start();\r
 743       } else if (quartzScheduler.isStarted()) {\r
 744         logger.debug("Server is running on active server and quartz already running;");\r
 745       }\r
 746     } catch (org.quartz.SchedulerException e) {\r
 747       logger.error(QUATZ_SCHEUDLER_FAILED_TO_START_CAUGHT_EXCEPTION + e.getMessage());\r
 748       throw new SchedulerException(SchedulerError.UNKNOWN_ERROR);\r
 749     }\r
 750 \r
 751     return true;\r
 752   }\r
 753 \r
 754   @Override\r
 755   public boolean stopQuartzSchedulars() throws SchedulerException {\r
 756     try {\r
 757 \r
 758       if (quartzScheduler.isStarted()) {\r
 759         logger.debug("DM is running on stand-by server; hence marking quartz as stand-by service");\r
 760         quartzScheduler.standby();\r
 761       } else {\r
 762         logger.debug("DM is running on active server/quartz already running in standby mode;");\r
 763       }\r
 764     } catch (org.quartz.SchedulerException e) {\r
 765       logger.error(QUATZ_SCHEUDLER_FAILED_TO_START_CAUGHT_EXCEPTION + e.getMessage());\r
 766       throw new SchedulerException(SchedulerError.UNKNOWN_ERROR);\r
 767     }\r
 768 \r
 769     return true;\r
 770   }\r
 771 \r
 772   @Override\r
 773   public void switchToStandby() throws SchedulerException {\r
 774     try {\r
 775       if (null != quartzScheduler) {\r
 776         quartzScheduler.shutdown();\r
 777       }\r
 778       quartzScheduler = quartzSchedulerProducer.getStdScheduler();\r
 779       if (null != quartzScheduler)\r
 780         quartzScheduler.standby();\r
 781     } catch (org.quartz.SchedulerException e) {\r
 782       logger.error("while switchToStandby SchedulerException : " + e.getMessage());\r
 783     }\r
 784   }\r
 785 \r
 786   @Override\r
 787   public void switchToActive() throws SchedulerException {\r
 788 \r
 789     try {\r
 790       if (null != quartzScheduler) {\r
 791         quartzScheduler.shutdown();\r
 792       }\r
 793 \r
 794       quartzScheduler = quartzSchedulerProducer.getStdScheduler();\r
 795       if (null != quartzScheduler)\r
 796         quartzScheduler.start();\r
 797     } catch (org.quartz.SchedulerException e) {\r
 798       logger.error("while switchToActive SchedulerException : " + e.getMessage());\r
 799     }\r
 800   }\r
 801 \r
 802   @Override\r
 803   public boolean isQuartzRunninginActiveMode() {\r
 804     try {\r
 805       if (!quartzScheduler.getSchedulerInstanceId().endsWith("_standby")\r
 806           && quartzScheduler.isStarted())\r
 807         return true;\r
 808     } catch (org.quartz.SchedulerException e) {\r
 809       logger.error("Quatz scheudler failed to retrive mode: Caught Exception: " + e.getMessage());\r
 810     }\r
 811     return false;\r
 812   }\r
 813 }\r