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