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
11 * http://www.apache.org/licenses/LICENSE-2.0
\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
20 package org.commscope.tr069adapter.common.scheduler.impl;
\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
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
33 import javax.annotation.PostConstruct;
\r
34 import javax.annotation.PreDestroy;
\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
58 public class QuartzSchedulerManager implements SchedulerManager {
\r
60 private static final String EXCEPTION_WHILE_GETTING_GET_JOB_INFO =
\r
61 "Exception while getting getJobInfo : ";
\r
63 private static final String ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB =
\r
64 "enableJob : Disable schedule for job ";
\r
66 private static final String METHOD_STARTED = " method started";
\r
68 private static final String EXCEPTION_WHILE_DISABLING_JOB = "Exception while disabling job : ";
\r
70 private static final String EXCEPTION_WHILE_CHECKING_JOB_ENABLE_STATE =
\r
71 "Exception while checking job enable state : ";
\r
73 private static final String ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB =
\r
74 "enableJob : Enable schedule for job ";
\r
76 private static final String EXCEPTION_WHILE_GETTING_JOB_LIST =
\r
77 "Exception while getting JobList : ";
\r
79 private static final String GET_JOB_LIST_METHOD_ENDED = "getJobList : method ended";
\r
81 private static final String EXCEPTION_WHILE_MODIFYING_SCHEDULE =
\r
82 "Exception while modifying schedule : ";
\r
84 private static final String MODIFY_SCHEDULE_MODIFY_SCHEDULE_FOR_JOB =
\r
85 "modifySchedule : Modify schedule for job ";
\r
87 private static final String EXCEPTION_WHILE_DELETING_SCHEDULE =
\r
88 "Exception while deleting schedule : ";
\r
90 private static final String DELETE_SCHEDULE_DELETING_SCHEDULE_FOR_JOB =
\r
91 "deleteSchedule : Deleting schedule for job ";
\r
93 private static final String EXCEPTION_WHILE_SCHEDULING_JOB_EXCEPTION =
\r
94 "Exception while scheduling job. Exception : ";
\r
96 private static final String SUCCESSFULLY_COMPLETED = " successfully completed";
\r
98 private static final String STARTED = " started";
\r
100 private static final String SCHEDULE_JOB_SCHEDUING_JOB = "scheduleJob : Scheduing job ";
\r
102 private static final String QUATZ_SCHEUDLER_FAILED_TO_START_CAUGHT_EXCEPTION =
\r
103 "Quatz scheudler failed to start: Caught Exception: ";
\r
106 private Scheduler quartzScheduler;
\r
109 QuartzSchedulerProducer quartzSchedulerProducer;
\r
111 private static final Log logger = LogFactory.getLog(QuartzSchedulerManager.class);
\r
113 public void setScheduler(Scheduler scheduler) {
\r
114 this.quartzScheduler = scheduler;
\r
118 QuartzSchedulerUtil schdulerUtil;
\r
120 public void setSchedulerUtil(QuartzSchedulerUtil schedulerUtil) {
\r
121 this.schdulerUtil = schedulerUtil;
\r
125 public void init() throws org.quartz.SchedulerException {
\r
126 logger.debug("init started");
\r
128 if (!quartzScheduler.isStarted()) {
\r
129 logger.debug("Running on active server; hence marking quartz as active service");
\r
130 quartzScheduler.start();
\r
132 } catch (org.quartz.SchedulerException e) {
\r
133 logger.error(QUATZ_SCHEUDLER_FAILED_TO_START_CAUGHT_EXCEPTION + e.getMessage());
\r
137 logger.debug("init complete");
\r
141 public void shutDown() throws org.quartz.SchedulerException {
\r
143 if (!quartzScheduler.isShutdown()) {
\r
144 quartzScheduler.shutdown();
\r
147 } catch (org.quartz.SchedulerException e) {
\r
148 logger.debug("Quatz scheudler failed to stop: Caught Exception: " + e.getMessage());
\r
154 public void scheduleJob(String jobName, TriggerInfo triggerInfo, ExecutionContext jobContext)
\r
155 throws SchedulerException {
\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
162 if (quartzScheduler.isInStandbyMode()) {
\r
164 "scheduleJob : Server running on stand by mode; hence ignore Scheduing job " + jobName);
\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
180 public void scheduleJob(String jobName, String jobGroup, TriggerInfo triggerInfo,
\r
181 ExecutionContext jobContext) throws SchedulerException {
\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
188 if (quartzScheduler.isInStandbyMode()) {
\r
189 logger.debug("scheduleJob : Server is running on stand by mode; hence ignore Scheduing job "
\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
206 public void scheduleJob(String jobName, String jobGroup, TriggerInfo triggerInfo,
\r
207 ExecutionContext jobContext, TriggerInfo expiredTriggerInfo,
\r
208 ExecutionContext expiredExecutionContext) throws SchedulerException {
\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
215 if (quartzScheduler.isInStandbyMode()) {
\r
216 logger.debug("scheduleJob : Server is running on stand by mode; hence ignore Scheduing job "
\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
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
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
243 public void deleteSchedule(String jobName) throws SchedulerException {
\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
261 public void modifySchedule(String jobName, TriggerInfo triggerInfo) throws SchedulerException {
\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
269 if (quartzScheduler.isInStandbyMode()) {
\r
271 "modifySchedule : Server is running on stand by mode; hence ignore modifySchedule job "
\r
275 quartzScheduler.rescheduleJob(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName),
\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
286 public void modifySchedule(String jobName, String jobGroup, TriggerInfo triggerInfo,
\r
287 TriggerInfo expiredTriggerInfo, ExecutionContext expiredExecutionContext)
\r
288 throws SchedulerException {
\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
296 quartzScheduler.rescheduleJob(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup),
\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
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
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
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
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
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
342 } catch (org.quartz.SchedulerException exception) {
\r
343 logger.error(EXCEPTION_WHILE_GETTING_JOB_LIST + exception.getLocalizedMessage());
\r
345 return jobInfoList;
\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
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
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
368 } catch (org.quartz.SchedulerException exception) {
\r
369 logger.error(EXCEPTION_WHILE_GETTING_GET_JOB_INFO + exception.getLocalizedMessage());
\r
371 logger.debug(methodName + " : " + "method ended");
\r
375 Trigger getTrigger(String jobName) {
\r
376 Trigger trigger = null;
\r
379 quartzScheduler.getTrigger(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobName));
\r
380 } catch (org.quartz.SchedulerException e) {
\r
381 logger.error(e.getLocalizedMessage());
\r
386 Trigger getTrigger(String jobName, String jobGroup) {
\r
387 Trigger trigger = null;
\r
390 quartzScheduler.getTrigger(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup));
\r
391 } catch (org.quartz.SchedulerException e) {
\r
392 logger.error(e.getLocalizedMessage());
\r
398 public boolean isJobEnabled(String jobName) {
\r
399 boolean retVal = true;
\r
402 Trigger trigger = getTrigger(jobName);
\r
403 if (null == trigger)
\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
415 public void enableJob(String jobName) throws SchedulerException {
\r
416 logger.debug(ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB + jobName + STARTED);
\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
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
433 logger.debug(ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB + jobName + SUCCESSFULLY_COMPLETED);
\r
437 public void disableJob(String jobName) throws SchedulerException {
\r
438 logger.debug(ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB + jobName + STARTED);
\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
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
455 logger.debug(ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB + jobName + SUCCESSFULLY_COMPLETED);
\r
458 private SchedulerException resolveError(org.quartz.SchedulerException excep) {
\r
459 SchedulerException schedulerExcep = new SchedulerException(SchedulerError.UNKNOWN_ERROR);
\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
474 return schedulerExcep;
\r
478 public boolean isJobExist(String jobName) throws SchedulerException {
\r
479 Trigger trigger = this.getTrigger(jobName);
\r
480 return (null != trigger);
\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
492 quartzScheduler.rescheduleJob(TriggerKey.triggerKey(jobName + TRIGGER_APPENDER, jobGroup),
\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
504 public void deleteSchedule(String jobName, String jobGroup) throws SchedulerException {
\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
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
527 // Delete all jobs together or nothing.
\r
528 // TODO- This need to be taken care by Container-Managed Transactions later
\r
531 public void deleteSchedule(String startJobName, String endJobName, String monitorJobName,
\r
532 String jobGroup) throws SchedulerException {
\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
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
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
552 if (null != endTimeTrigger2) {
\r
553 quartzScheduler.unscheduleJob(
\r
554 TriggerKey.triggerKey(endJobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup));
\r
556 if (null != endTimeTrigger3) {
\r
557 quartzScheduler.unscheduleJob(
\r
558 TriggerKey.triggerKey(monitorJobName + END_TIME_APPENDER + TRIGGER_APPENDER, jobGroup));
\r
560 if (null != trigger1) {
\r
562 .unscheduleJob(TriggerKey.triggerKey(startJobName + TRIGGER_APPENDER, jobGroup));
\r
564 if (null != trigger2) {
\r
566 .unscheduleJob(TriggerKey.triggerKey(endJobName + TRIGGER_APPENDER, jobGroup));
\r
568 if (null != trigger3) {
\r
570 .unscheduleJob(TriggerKey.triggerKey(monitorJobName + TRIGGER_APPENDER, jobGroup));
\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
583 public boolean isJobEnabled(String jobName, String jobGroup) {
\r
584 boolean retVal = true;
\r
587 Trigger trigger = getTrigger(jobName, jobGroup);
\r
588 if (null == trigger)
\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
600 public void enableJob(String jobName, String jobGroup) throws SchedulerException {
\r
601 logger.debug(ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB + jobName + STARTED);
\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
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
618 logger.debug(ENABLE_JOB_ENABLE_SCHEDULE_FOR_JOB + jobName + SUCCESSFULLY_COMPLETED);
\r
623 public void disableJob(String jobName, String jobGroup) throws SchedulerException {
\r
624 logger.debug(ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB + jobName + STARTED);
\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
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
641 logger.debug(ENABLE_JOB_DISABLE_SCHEDULE_FOR_JOB + jobName + " completed");
\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
652 public JobInfo getJobInfo(String jobId, String jobGroup) {
\r
653 final String methodName = "getJobInfo";
\r
654 logger.debug(methodName + " : " + METHOD_STARTED);
\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
667 } catch (org.quartz.SchedulerException exception) {
\r
668 logger.error(EXCEPTION_WHILE_GETTING_GET_JOB_INFO + exception.getLocalizedMessage());
\r
670 logger.debug(methodName + " : method ended");
\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
681 public void updateJobData(String jobName, String jobGroup, Map<String, Object> jobData)
\r
682 throws SchedulerException {
\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
690 quartzScheduler.addJob(jobDetail, true, true);
\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
701 public Map<String, Object> getJobData(String jobName, String jobGroup) throws SchedulerException {
\r
703 Map<String, Object> jobData = new HashMap<>();
\r
705 JobDetail jobDetail =
\r
706 quartzScheduler.getJobDetail(new JobKey(jobName + JOB_APPENDER, jobGroup));
\r
707 if (null == jobDetail)
\r
709 for (String key : jobDetail.getJobDataMap().keySet()) {
\r
710 jobData.put(key, jobDetail.getJobDataMap().get(key));
\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
720 public void deleteJobData(String jobName, String jobGroup, Set<String> keys)
\r
721 throws SchedulerException {
\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
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
737 public boolean resumeQuartzSchedulars() throws SchedulerException {
\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
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
755 public boolean stopQuartzSchedulars() throws SchedulerException {
\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
762 logger.debug("DM is running on active server/quartz already running in standby mode;");
\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
773 public void switchToStandby() throws SchedulerException {
\r
775 if (null != quartzScheduler) {
\r
776 quartzScheduler.shutdown();
\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
787 public void switchToActive() throws SchedulerException {
\r
790 if (null != quartzScheduler) {
\r
791 quartzScheduler.shutdown();
\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
803 public boolean isQuartzRunninginActiveMode() {
\r
805 if (!quartzScheduler.getSchedulerInstanceId().endsWith("_standby")
\r
806 && quartzScheduler.isStarted())
\r
808 } catch (org.quartz.SchedulerException e) {
\r
809 logger.error("Quatz scheudler failed to retrive mode: Caught Exception: " + e.getMessage());
\r