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