001
014
015 package com.liferay.portal.scheduler;
016
017 import com.liferay.portal.kernel.audit.AuditMessage;
018 import com.liferay.portal.kernel.audit.AuditRouterUtil;
019 import com.liferay.portal.kernel.cal.DayAndPosition;
020 import com.liferay.portal.kernel.cal.Duration;
021 import com.liferay.portal.kernel.cal.Recurrence;
022 import com.liferay.portal.kernel.cal.RecurrenceSerializer;
023 import com.liferay.portal.kernel.json.JSONFactoryUtil;
024 import com.liferay.portal.kernel.log.Log;
025 import com.liferay.portal.kernel.log.LogFactoryUtil;
026 import com.liferay.portal.kernel.messaging.DestinationNames;
027 import com.liferay.portal.kernel.messaging.Message;
028 import com.liferay.portal.kernel.scheduler.JobState;
029 import com.liferay.portal.kernel.scheduler.SchedulerEngine;
030 import com.liferay.portal.kernel.scheduler.SchedulerEngineHelper;
031 import com.liferay.portal.kernel.scheduler.SchedulerEntry;
032 import com.liferay.portal.kernel.scheduler.SchedulerException;
033 import com.liferay.portal.kernel.scheduler.SchedulerLifecycle;
034 import com.liferay.portal.kernel.scheduler.StorageType;
035 import com.liferay.portal.kernel.scheduler.Trigger;
036 import com.liferay.portal.kernel.scheduler.TriggerFactoryUtil;
037 import com.liferay.portal.kernel.scheduler.TriggerState;
038 import com.liferay.portal.kernel.scheduler.messaging.SchedulerResponse;
039 import com.liferay.portal.kernel.security.pacl.DoPrivileged;
040 import com.liferay.portal.kernel.util.CalendarFactoryUtil;
041 import com.liferay.portal.kernel.util.InetAddressUtil;
042 import com.liferay.portal.kernel.util.ObjectValuePair;
043 import com.liferay.portal.kernel.util.ParamUtil;
044 import com.liferay.portal.kernel.util.PortalLifecycle;
045 import com.liferay.portal.kernel.util.StringPool;
046 import com.liferay.portal.model.CompanyConstants;
047 import com.liferay.portal.util.PortalUtil;
048 import com.liferay.portal.util.PropsValues;
049
050 import java.util.ArrayList;
051 import java.util.Calendar;
052 import java.util.Date;
053 import java.util.List;
054
055 import javax.portlet.PortletRequest;
056
057
060 @DoPrivileged
061 public class SchedulerEngineHelperImpl implements SchedulerEngineHelper {
062
063 @Override
064 public void addJob(
065 Trigger trigger, StorageType storageType, String description,
066 String destinationName, Message message,
067 String messageListenerClassName, String portletId,
068 int exceptionsMaxSize)
069 throws SchedulerException {
070
071 if (message == null) {
072 message = new Message();
073 }
074
075 message.put(
076 SchedulerEngine.MESSAGE_LISTENER_CLASS_NAME,
077 messageListenerClassName);
078 message.put(SchedulerEngine.PORTLET_ID, portletId);
079
080 schedule(
081 trigger, storageType, description, destinationName, message,
082 exceptionsMaxSize);
083 }
084
085 @Override
086 public void addJob(
087 Trigger trigger, StorageType storageType, String description,
088 String destinationName, Object payload,
089 String messageListenerClassName, String portletId,
090 int exceptionsMaxSize)
091 throws SchedulerException {
092
093 Message message = new Message();
094
095 message.setPayload(payload);
096
097 addJob(
098 trigger, storageType, description, destinationName, message,
099 messageListenerClassName, portletId, exceptionsMaxSize);
100 }
101
102 @Override
103 public void addScriptingJob(
104 Trigger trigger, StorageType storageType, String description,
105 String language, String script, int exceptionsMaxSize)
106 throws SchedulerException {
107
108 Message message = new Message();
109
110 message.put(SchedulerEngine.LANGUAGE, language);
111 message.put(SchedulerEngine.SCRIPT, script);
112
113 schedule(
114 trigger, storageType, description,
115 DestinationNames.SCHEDULER_SCRIPTING, message, exceptionsMaxSize);
116 }
117
118 @Override
119 public void auditSchedulerJobs(Message message, TriggerState triggerState)
120 throws SchedulerException {
121
122 if (!PropsValues.AUDIT_MESSAGE_SCHEDULER_JOB) {
123 return;
124 }
125
126 try {
127 AuditMessage auditMessage = new AuditMessage(
128 SchedulerEngine.AUDIT_ACTION, CompanyConstants.SYSTEM, 0,
129 StringPool.BLANK, SchedulerEngine.class.getName(), "0",
130 triggerState.toString(), new Date(),
131 JSONFactoryUtil.createJSONObject(
132 JSONFactoryUtil.serialize(message)));
133
134 auditMessage.setServerName(InetAddressUtil.getLocalHostName());
135 auditMessage.setServerPort(PortalUtil.getPortalPort(false));
136
137 AuditRouterUtil.route(auditMessage);
138 }
139 catch (Exception e) {
140 throw new SchedulerException(e);
141 }
142 }
143
144 @Override
145 public void delete(SchedulerEntry schedulerEntry, StorageType storageType)
146 throws SchedulerException {
147
148 Trigger trigger = schedulerEntry.getTrigger();
149
150 delete(trigger.getJobName(), trigger.getGroupName(), storageType);
151 }
152
153 @Override
154 public void delete(String groupName, StorageType storageType)
155 throws SchedulerException {
156
157 _schedulerEngine.delete(namespaceGroupName(groupName, storageType));
158 }
159
160 @Override
161 public void delete(
162 String jobName, String groupName, StorageType storageType)
163 throws SchedulerException {
164
165 _schedulerEngine.delete(
166 jobName, namespaceGroupName(groupName, storageType));
167 }
168
169 @Override
170 public String getCronText(Calendar calendar, boolean timeZoneSensitive) {
171 return getCronText(
172 null, calendar, timeZoneSensitive, Recurrence.NO_RECURRENCE);
173 }
174
175 @Override
176 public String getCronText(
177 PortletRequest portletRequest, Calendar calendar,
178 boolean timeZoneSensitive, int recurrenceType) {
179
180 Calendar recurrenceCalendar = null;
181
182 if (timeZoneSensitive) {
183 recurrenceCalendar = CalendarFactoryUtil.getCalendar();
184
185 recurrenceCalendar.setTime(calendar.getTime());
186 }
187 else {
188 recurrenceCalendar = (Calendar)calendar.clone();
189 }
190
191 Recurrence recurrence = new Recurrence(
192 recurrenceCalendar, new Duration(1, 0, 0, 0), recurrenceType);
193
194 recurrence.setWeekStart(Calendar.SUNDAY);
195
196 if (recurrenceType == Recurrence.DAILY) {
197 int dailyType = ParamUtil.getInteger(portletRequest, "dailyType");
198
199 if (dailyType == 0) {
200 int dailyInterval = ParamUtil.getInteger(
201 portletRequest, "dailyInterval", 1);
202
203 recurrence.setInterval(dailyInterval);
204 }
205 else {
206 DayAndPosition[] dayPos = {
207 new DayAndPosition(Calendar.MONDAY, 0),
208 new DayAndPosition(Calendar.TUESDAY, 0),
209 new DayAndPosition(Calendar.WEDNESDAY, 0),
210 new DayAndPosition(Calendar.THURSDAY, 0),
211 new DayAndPosition(Calendar.FRIDAY, 0)};
212
213 recurrence.setByDay(dayPos);
214 }
215 }
216 else if (recurrenceType == Recurrence.WEEKLY) {
217 int weeklyInterval = ParamUtil.getInteger(
218 portletRequest, "weeklyInterval", 1);
219
220 recurrence.setInterval(weeklyInterval);
221
222 List<DayAndPosition> dayPos = new ArrayList<DayAndPosition>();
223
224 addWeeklyDayPos(portletRequest, dayPos, Calendar.SUNDAY);
225 addWeeklyDayPos(portletRequest, dayPos, Calendar.MONDAY);
226 addWeeklyDayPos(portletRequest, dayPos, Calendar.TUESDAY);
227 addWeeklyDayPos(portletRequest, dayPos, Calendar.WEDNESDAY);
228 addWeeklyDayPos(portletRequest, dayPos, Calendar.THURSDAY);
229 addWeeklyDayPos(portletRequest, dayPos, Calendar.FRIDAY);
230 addWeeklyDayPos(portletRequest, dayPos, Calendar.SATURDAY);
231
232 if (dayPos.size() == 0) {
233 dayPos.add(new DayAndPosition(Calendar.MONDAY, 0));
234 }
235
236 recurrence.setByDay(dayPos.toArray(new DayAndPosition[0]));
237 }
238 else if (recurrenceType == Recurrence.MONTHLY) {
239 int monthlyType = ParamUtil.getInteger(
240 portletRequest, "monthlyType");
241
242 if (monthlyType == 0) {
243 int monthlyDay = ParamUtil.getInteger(
244 portletRequest, "monthlyDay0", 1);
245
246 recurrence.setByMonthDay(new int[] {monthlyDay});
247
248 int monthlyInterval = ParamUtil.getInteger(
249 portletRequest, "monthlyInterval0", 1);
250
251 recurrence.setInterval(monthlyInterval);
252 }
253 else {
254 int monthlyPos = ParamUtil.getInteger(
255 portletRequest, "monthlyPos");
256 int monthlyDay = ParamUtil.getInteger(
257 portletRequest, "monthlyDay1");
258
259 DayAndPosition[] dayPos = {
260 new DayAndPosition(monthlyDay, monthlyPos)};
261
262 recurrence.setByDay(dayPos);
263
264 int monthlyInterval = ParamUtil.getInteger(
265 portletRequest, "monthlyInterval1", 1);
266
267 recurrence.setInterval(monthlyInterval);
268 }
269 }
270 else if (recurrenceType == Recurrence.YEARLY) {
271 int yearlyType = ParamUtil.getInteger(portletRequest, "yearlyType");
272
273 if (yearlyType == 0) {
274 int yearlyMonth = ParamUtil.getInteger(
275 portletRequest, "yearlyMonth0");
276 int yearlyDay = ParamUtil.getInteger(
277 portletRequest, "yearlyDay0", 1);
278
279 recurrence.setByMonth(new int[] {yearlyMonth});
280 recurrence.setByMonthDay(new int[] {yearlyDay});
281
282 int yearlyInterval = ParamUtil.getInteger(
283 portletRequest, "yearlyInterval0", 1);
284
285 recurrence.setInterval(yearlyInterval);
286 }
287 else {
288 int yearlyPos = ParamUtil.getInteger(
289 portletRequest, "yearlyPos");
290 int yearlyDay = ParamUtil.getInteger(
291 portletRequest, "yearlyDay1");
292 int yearlyMonth = ParamUtil.getInteger(
293 portletRequest, "yearlyMonth1");
294
295 DayAndPosition[] dayPos = {
296 new DayAndPosition(yearlyDay, yearlyPos)};
297
298 recurrence.setByDay(dayPos);
299
300 recurrence.setByMonth(new int[] {yearlyMonth});
301
302 int yearlyInterval = ParamUtil.getInteger(
303 portletRequest, "yearlyInterval1", 1);
304
305 recurrence.setInterval(yearlyInterval);
306 }
307 }
308
309 return RecurrenceSerializer.toCronText(recurrence);
310 }
311
312 @Override
313 public Date getEndTime(SchedulerResponse schedulerResponse) {
314 Message message = schedulerResponse.getMessage();
315
316 JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
317
318 TriggerState triggerState = jobState.getTriggerState();
319
320 if (triggerState.equals(TriggerState.NORMAL) ||
321 triggerState.equals(TriggerState.PAUSED)) {
322
323 return (Date)message.get(SchedulerEngine.END_TIME);
324 }
325 else {
326 return jobState.getTriggerDate(SchedulerEngine.END_TIME);
327 }
328 }
329
330 @Override
331 public Date getEndTime(
332 String jobName, String groupName, StorageType storageType)
333 throws SchedulerException {
334
335 SchedulerResponse schedulerResponse = getScheduledJob(
336 jobName, groupName, storageType);
337
338 if (schedulerResponse != null) {
339 return getEndTime(schedulerResponse);
340 }
341
342 return null;
343 }
344
345 @Override
346 public Date getFinalFireTime(SchedulerResponse schedulerResponse) {
347 Message message = schedulerResponse.getMessage();
348
349 JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
350
351 TriggerState triggerState = jobState.getTriggerState();
352
353 if (triggerState.equals(TriggerState.NORMAL) ||
354 triggerState.equals(TriggerState.PAUSED)) {
355
356 return (Date)message.get(SchedulerEngine.FINAL_FIRE_TIME);
357 }
358 else {
359 return jobState.getTriggerDate(SchedulerEngine.FINAL_FIRE_TIME);
360 }
361 }
362
363 @Override
364 public Date getFinalFireTime(
365 String jobName, String groupName, StorageType storageType)
366 throws SchedulerException {
367
368 SchedulerResponse schedulerResponse = getScheduledJob(
369 jobName, groupName, storageType);
370
371 if (schedulerResponse != null) {
372 return getFinalFireTime(schedulerResponse);
373 }
374
375 return null;
376 }
377
378 @Override
379 public ObjectValuePair<Exception, Date>[] getJobExceptions(
380 SchedulerResponse schedulerResponse) {
381
382 Message message = schedulerResponse.getMessage();
383
384 JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
385
386 return jobState.getExceptions();
387 }
388
389 @Override
390 public ObjectValuePair<Exception, Date>[] getJobExceptions(
391 String jobName, String groupName, StorageType storageType)
392 throws SchedulerException {
393
394 SchedulerResponse schedulerResponse = getScheduledJob(
395 jobName, groupName, storageType);
396
397 if (schedulerResponse != null) {
398 return getJobExceptions(schedulerResponse);
399 }
400
401 return null;
402 }
403
404 @Override
405 public TriggerState getJobState(SchedulerResponse schedulerResponse) {
406 Message message = schedulerResponse.getMessage();
407
408 JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
409
410 return jobState.getTriggerState();
411 }
412
413 @Override
414 public TriggerState getJobState(
415 String jobName, String groupName, StorageType storageType)
416 throws SchedulerException {
417
418 SchedulerResponse schedulerResponse = getScheduledJob(
419 jobName, groupName, storageType);
420
421 if (schedulerResponse != null) {
422 return getJobState(schedulerResponse);
423 }
424
425 return null;
426 }
427
428 @Override
429 public Date getNextFireTime(SchedulerResponse schedulerResponse) {
430 Message message = schedulerResponse.getMessage();
431
432 JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
433
434 TriggerState triggerState = jobState.getTriggerState();
435
436 if (triggerState.equals(TriggerState.NORMAL) ||
437 triggerState.equals(TriggerState.PAUSED)) {
438
439 return (Date)message.get(SchedulerEngine.NEXT_FIRE_TIME);
440 }
441 else {
442 return jobState.getTriggerDate(SchedulerEngine.NEXT_FIRE_TIME);
443 }
444 }
445
446 @Override
447 public Date getNextFireTime(
448 String jobName, String groupName, StorageType storageType)
449 throws SchedulerException {
450
451 SchedulerResponse schedulerResponse = getScheduledJob(
452 jobName, groupName, storageType);
453
454 if (schedulerResponse != null) {
455 return getNextFireTime(schedulerResponse);
456 }
457
458 return null;
459 }
460
461 @Override
462 public Date getPreviousFireTime(SchedulerResponse schedulerResponse) {
463 Message message = schedulerResponse.getMessage();
464
465 JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
466
467 TriggerState triggerState = jobState.getTriggerState();
468
469 if (triggerState.equals(TriggerState.NORMAL) ||
470 triggerState.equals(TriggerState.PAUSED)) {
471
472 return (Date)message.get(SchedulerEngine.PREVIOUS_FIRE_TIME);
473 }
474 else {
475 return jobState.getTriggerDate(SchedulerEngine.PREVIOUS_FIRE_TIME);
476 }
477 }
478
479 @Override
480 public Date getPreviousFireTime(
481 String jobName, String groupName, StorageType storageType)
482 throws SchedulerException {
483
484 SchedulerResponse schedulerResponse = getScheduledJob(
485 jobName, groupName, storageType);
486
487 if (schedulerResponse != null) {
488 return getPreviousFireTime(schedulerResponse);
489 }
490
491 return null;
492 }
493
494 @Override
495 public SchedulerResponse getScheduledJob(
496 String jobName, String groupName, StorageType storageType)
497 throws SchedulerException {
498
499 return _schedulerEngine.getScheduledJob(
500 jobName, namespaceGroupName(groupName, storageType));
501 }
502
503 @Override
504 public List<SchedulerResponse> getScheduledJobs()
505 throws SchedulerException {
506
507 return _schedulerEngine.getScheduledJobs();
508 }
509
510 @Override
511 public List<SchedulerResponse> getScheduledJobs(StorageType storageType)
512 throws SchedulerException {
513
514 List<SchedulerResponse> schedulerResponses =
515 new ArrayList<SchedulerResponse>();
516
517 for (SchedulerResponse schedulerResponse :
518 _schedulerEngine.getScheduledJobs()) {
519
520 if (storageType.equals(schedulerResponse.getStorageType())) {
521 schedulerResponses.add(schedulerResponse);
522 }
523 }
524
525 return schedulerResponses;
526 }
527
528 @Override
529 public List<SchedulerResponse> getScheduledJobs(
530 String groupName, StorageType storageType)
531 throws SchedulerException {
532
533 return _schedulerEngine.getScheduledJobs(
534 namespaceGroupName(groupName, storageType));
535 }
536
537 @Override
538 public Date getStartTime(SchedulerResponse schedulerResponse) {
539 Message message = schedulerResponse.getMessage();
540
541 JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
542
543 TriggerState triggerState = jobState.getTriggerState();
544
545 if (triggerState.equals(TriggerState.NORMAL) ||
546 triggerState.equals(TriggerState.PAUSED)) {
547
548 return (Date)message.get(SchedulerEngine.START_TIME);
549 }
550 else {
551 return jobState.getTriggerDate(SchedulerEngine.START_TIME);
552 }
553 }
554
555 @Override
556 public Date getStartTime(
557 String jobName, String groupName, StorageType storageType)
558 throws SchedulerException {
559
560 SchedulerResponse schedulerResponse = getScheduledJob(
561 jobName, groupName, storageType);
562
563 if (schedulerResponse != null) {
564 return getStartTime(schedulerResponse);
565 }
566
567 return null;
568 }
569
570 @Override
571 public void initialize() throws SchedulerException {
572 SchedulerLifecycle schedulerLifecycle = new SchedulerLifecycle();
573
574 schedulerLifecycle.registerPortalLifecycle(PortalLifecycle.METHOD_INIT);
575 }
576
577 @Override
578 public String namespaceGroupName(
579 String groupName, StorageType storageType) {
580
581 return storageType.toString().concat(StringPool.POUND).concat(
582 groupName);
583 }
584
585 @Override
586 public void pause(String groupName, StorageType storageType)
587 throws SchedulerException {
588
589 _schedulerEngine.pause(namespaceGroupName(groupName, storageType));
590 }
591
592 @Override
593 public void pause(String jobName, String groupName, StorageType storageType)
594 throws SchedulerException {
595
596 _schedulerEngine.pause(
597 jobName, namespaceGroupName(groupName, storageType));
598 }
599
600 @Override
601 public void resume(String groupName, StorageType storageType)
602 throws SchedulerException {
603
604 _schedulerEngine.resume(namespaceGroupName(groupName, storageType));
605 }
606
607 @Override
608 public void resume(
609 String jobName, String groupName, StorageType storageType)
610 throws SchedulerException {
611
612 _schedulerEngine.resume(
613 jobName, namespaceGroupName(groupName, storageType));
614 }
615
616 @Override
617 public void schedule(
618 SchedulerEntry schedulerEntry, StorageType storageType,
619 String portletId, int exceptionsMaxSize)
620 throws SchedulerException {
621
622 Message message = new Message();
623
624 message.put(
625 SchedulerEngine.MESSAGE_LISTENER_CLASS_NAME,
626 schedulerEntry.getEventListenerClass());
627 message.put(SchedulerEngine.PORTLET_ID, portletId);
628
629 schedule(
630 schedulerEntry.getTrigger(), storageType,
631 schedulerEntry.getDescription(),
632 DestinationNames.SCHEDULER_DISPATCH, message, exceptionsMaxSize);
633 }
634
635 @Override
636 public void schedule(
637 Trigger trigger, StorageType storageType, String description,
638 String destinationName, Message message, int exceptionsMaxSize)
639 throws SchedulerException {
640
641 if (message == null) {
642 message = new Message();
643 }
644
645 message.put(SchedulerEngine.EXCEPTIONS_MAX_SIZE, exceptionsMaxSize);
646
647 trigger = TriggerFactoryUtil.buildTrigger(
648 trigger.getTriggerType(), trigger.getJobName(),
649 namespaceGroupName(trigger.getGroupName(), storageType),
650 trigger.getStartDate(), trigger.getEndDate(),
651 trigger.getTriggerContent());
652
653 _schedulerEngine.schedule(
654 trigger, description, destinationName, message);
655 }
656
657 @Override
658 public void schedule(
659 Trigger trigger, StorageType storageType, String description,
660 String destinationName, Object payload, int exceptionsMaxSize)
661 throws SchedulerException {
662
663 Message message = new Message();
664
665 message.setPayload(payload);
666
667 schedule(
668 trigger, storageType, description, destinationName, message,
669 exceptionsMaxSize);
670 }
671
672 public void setSchedulerEngine(SchedulerEngine schedulerEngine) {
673 _schedulerEngine = schedulerEngine;
674 }
675
676 @Override
677 public void shutdown() throws SchedulerException {
678 _schedulerEngine.shutdown();
679 }
680
681 @Override
682 public void start() throws SchedulerException {
683 _schedulerEngine.start();
684 }
685
686 @Override
687 public void suppressError(
688 String jobName, String groupName, StorageType storageType)
689 throws SchedulerException {
690
691 _schedulerEngine.suppressError(
692 jobName, namespaceGroupName(groupName, storageType));
693 }
694
695 @Override
696 public void unschedule(
697 SchedulerEntry schedulerEntry, StorageType storageType)
698 throws SchedulerException {
699
700 Trigger trigger = schedulerEntry.getTrigger();
701
702 unschedule(trigger.getJobName(), trigger.getGroupName(), storageType);
703 }
704
705 @Override
706 public void unschedule(String groupName, StorageType storageType)
707 throws SchedulerException {
708
709 _schedulerEngine.unschedule(namespaceGroupName(groupName, storageType));
710 }
711
712 @Override
713 public void unschedule(
714 String jobName, String groupName, StorageType storageType)
715 throws SchedulerException {
716
717 _schedulerEngine.unschedule(
718 jobName, namespaceGroupName(groupName, storageType));
719 }
720
721 @Override
722 public void update(
723 String jobName, String groupName, StorageType storageType,
724 String description, String language, String script,
725 int exceptionsMaxSize)
726 throws SchedulerException {
727
728 SchedulerResponse schedulerResponse = getScheduledJob(
729 jobName, groupName, storageType);
730
731 if (schedulerResponse == null) {
732 return;
733 }
734
735 Trigger trigger = schedulerResponse.getTrigger();
736
737 if (trigger == null) {
738 return;
739 }
740
741 Message message = schedulerResponse.getMessage();
742
743 if (message == null) {
744 return;
745 }
746
747 addScriptingJob(
748 trigger, storageType, description, language, script,
749 exceptionsMaxSize);
750 }
751
752 @Override
753 public void update(Trigger trigger, StorageType storageType)
754 throws SchedulerException {
755
756 trigger = TriggerFactoryUtil.buildTrigger(
757 trigger.getTriggerType(), trigger.getJobName(),
758 namespaceGroupName(trigger.getGroupName(), storageType),
759 trigger.getStartDate(), trigger.getEndDate(),
760 trigger.getTriggerContent());
761
762 _schedulerEngine.update(trigger);
763 }
764
765 protected void addWeeklyDayPos(
766 PortletRequest portletRequest, List<DayAndPosition> list, int day) {
767
768 if (ParamUtil.getBoolean(portletRequest, "weeklyDayPos" + day)) {
769 list.add(new DayAndPosition(day, 0));
770 }
771 }
772
773 private static Log _log = LogFactoryUtil.getLog(
774 SchedulerEngineHelperImpl.class);
775
776 private SchedulerEngine _schedulerEngine;
777
778 }