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