mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-07-07 18:25:23 +00:00
1f5c3a1d20
Also, don't add the new scheduled action to Quartz until the transaction commits, to ensure the nodes are really there before Quartz fires git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@22136 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
1334 lines
51 KiB
Java
1334 lines
51 KiB
Java
/*
|
|
* Copyright (C) 2005-2010 Alfresco Software Limited.
|
|
*
|
|
* This file is part of Alfresco
|
|
*
|
|
* Alfresco is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package org.alfresco.repo.action.scheduled;
|
|
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
|
|
import javax.transaction.UserTransaction;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.repo.action.ActionImpl;
|
|
import org.alfresco.repo.action.RuntimeActionService;
|
|
import org.alfresco.repo.action.ActionServiceImplTest.SleepActionExecuter;
|
|
import org.alfresco.repo.action.scheduled.ScheduledPersistedActionServiceImpl.ScheduledPersistedActionServiceBootstrap;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil;
|
|
import org.alfresco.service.cmr.action.Action;
|
|
import org.alfresco.service.cmr.action.ActionService;
|
|
import org.alfresco.service.cmr.action.scheduled.ScheduledPersistedAction;
|
|
import org.alfresco.service.cmr.action.scheduled.ScheduledPersistedActionService;
|
|
import org.alfresco.service.cmr.action.scheduled.SchedulableAction.IntervalPeriod;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.service.namespace.RegexQNamePattern;
|
|
import org.alfresco.service.transaction.TransactionService;
|
|
import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
|
|
import org.alfresco.util.ApplicationContextHelper;
|
|
import org.quartz.DateIntervalTrigger;
|
|
import org.quartz.Job;
|
|
import org.quartz.JobDetail;
|
|
import org.quartz.JobExecutionContext;
|
|
import org.quartz.JobExecutionException;
|
|
import org.quartz.Scheduler;
|
|
import org.quartz.SimpleTrigger;
|
|
import org.quartz.Trigger;
|
|
import org.quartz.DateIntervalTrigger.IntervalUnit;
|
|
import org.springframework.beans.BeansException;
|
|
import org.springframework.context.ApplicationContext;
|
|
import org.springframework.context.ApplicationContextAware;
|
|
import org.springframework.context.ConfigurableApplicationContext;
|
|
|
|
/**
|
|
* Unit tests for the {@link ScheduledPersistedActionService}
|
|
*/
|
|
public class ScheduledPersistedActionServiceTest extends TestCase
|
|
{
|
|
private static ConfigurableApplicationContext ctx =
|
|
(ConfigurableApplicationContext) ApplicationContextHelper.getApplicationContext();
|
|
|
|
private ScheduledPersistedActionServiceBootstrap bootstrap;
|
|
private ScheduledPersistedActionService service;
|
|
private ScheduledPersistedActionServiceImpl serviceImpl;
|
|
private Scheduler scheduler;
|
|
|
|
private TransactionService transactionService;
|
|
private RuntimeActionService runtimeActionService;
|
|
private ActionService actionService;
|
|
private NodeService nodeService;
|
|
|
|
private Action testAction;
|
|
private Action testAction2;
|
|
private Action testAction3;
|
|
|
|
@Override
|
|
protected void setUp() throws Exception
|
|
{
|
|
actionService = (ActionService) ctx.getBean("actionService");
|
|
nodeService = (NodeService) ctx.getBean("nodeService");
|
|
transactionService = (TransactionService) ctx
|
|
.getBean("transactionService");
|
|
runtimeActionService = (RuntimeActionService) ctx
|
|
.getBean("actionService");
|
|
service = (ScheduledPersistedActionService) ctx
|
|
.getBean("ScheduledPersistedActionService");
|
|
serviceImpl = (ScheduledPersistedActionServiceImpl) ctx
|
|
.getBean("scheduledPersistedActionService");
|
|
scheduler = (Scheduler) ctx.getBean("schedulerFactory");
|
|
bootstrap = (ScheduledPersistedActionServiceBootstrap) ctx
|
|
.getBean("scheduledPersistedActionServiceBootstrap");
|
|
|
|
// Set the current security context as admin
|
|
AuthenticationUtil.setFullyAuthenticatedUser(AuthenticationUtil
|
|
.getAdminUserName());
|
|
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
|
|
// Register the test executor, if needed
|
|
SleepActionExecuter.registerIfNeeded(ctx);
|
|
|
|
// Zap all test schedules
|
|
List<ScheduledPersistedAction> schedules = service.listSchedules();
|
|
for (ScheduledPersistedAction schedule : schedules)
|
|
{
|
|
service.deleteSchedule(schedule);
|
|
}
|
|
|
|
// Persist an action that uses the test executor
|
|
testAction = new TestAction(actionService
|
|
.createAction(SleepActionExecuter.NAME));
|
|
runtimeActionService.createActionNodeRef(
|
|
//
|
|
testAction,
|
|
ScheduledPersistedActionServiceImpl.SCHEDULED_ACTION_ROOT_NODE_REF,
|
|
ContentModel.ASSOC_CONTAINS, QName.createQName("TestAction"));
|
|
|
|
testAction2 = new TestAction(actionService
|
|
.createAction(SleepActionExecuter.NAME));
|
|
runtimeActionService.createActionNodeRef(
|
|
//
|
|
testAction2,
|
|
ScheduledPersistedActionServiceImpl.SCHEDULED_ACTION_ROOT_NODE_REF,
|
|
ContentModel.ASSOC_CONTAINS, QName.createQName("TestAction2"));
|
|
|
|
testAction3 = new TestAction(actionService
|
|
.createAction(SleepActionExecuter.NAME));
|
|
|
|
// Finish setup
|
|
txn.commit();
|
|
|
|
// By default, we don't want the scheduler to fire while the tests run
|
|
// Certain tests will enable it as required
|
|
scheduler.standby();
|
|
}
|
|
|
|
@Override
|
|
protected void tearDown() throws Exception
|
|
{
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
|
|
// Zap all test schedules
|
|
List<ScheduledPersistedAction> schedules = service.listSchedules();
|
|
for (ScheduledPersistedAction schedule : schedules)
|
|
{
|
|
service.deleteSchedule(schedule);
|
|
}
|
|
txn.commit();
|
|
|
|
// Re-enable the scheduler again
|
|
scheduler.start();
|
|
}
|
|
|
|
/**
|
|
* Test that the {@link ScheduledPersistedAction} implementation behaves
|
|
* properly
|
|
*/
|
|
public void testPersistedActionImpl() throws Exception
|
|
{
|
|
ScheduledPersistedActionImpl schedule =
|
|
new ScheduledPersistedActionImpl(testAction);
|
|
ScheduledPersistedActionImpl schedule3 =
|
|
new ScheduledPersistedActionImpl(testAction3);
|
|
|
|
// Check the core bits
|
|
assertEquals(null, schedule.getPersistedAtNodeRef());
|
|
assertEquals(testAction, schedule.getAction());
|
|
assertEquals(testAction.getNodeRef(), schedule.getActionNodeRef());
|
|
|
|
assertEquals(null, schedule3.getPersistedAtNodeRef());
|
|
assertEquals(testAction3, schedule3.getAction());
|
|
assertEquals(null, schedule3.getActionNodeRef());
|
|
|
|
// Persist the 3rd action
|
|
runtimeActionService.createActionNodeRef(
|
|
//
|
|
testAction3,
|
|
ScheduledPersistedActionServiceImpl.SCHEDULED_ACTION_ROOT_NODE_REF,
|
|
ContentModel.ASSOC_CONTAINS, QName.createQName("TestAction3"));
|
|
|
|
assertEquals(null, schedule.getPersistedAtNodeRef());
|
|
assertEquals(testAction, schedule.getAction());
|
|
assertEquals(testAction.getNodeRef(), schedule.getActionNodeRef());
|
|
|
|
assertEquals(null, schedule3.getPersistedAtNodeRef());
|
|
assertEquals(testAction3, schedule3.getAction());
|
|
assertEquals(testAction3.getNodeRef(), schedule3.getActionNodeRef());
|
|
assertNotNull(schedule3.getAction().getNodeRef());
|
|
|
|
// Check the start/end date bits
|
|
assertEquals(null, schedule.getScheduleStart());
|
|
assertEquals(null, schedule.getScheduleEnd());
|
|
|
|
schedule.setScheduleStart(new Date(1234));
|
|
assertEquals(1234, schedule.getScheduleStart().getTime());
|
|
assertEquals(null, schedule.getScheduleEnd());
|
|
|
|
schedule.setScheduleEnd(new Date(4321));
|
|
assertEquals(1234, schedule.getScheduleStart().getTime());
|
|
assertEquals(4321, schedule.getScheduleEnd().getTime());
|
|
|
|
assertEquals(null, schedule3.getScheduleStart());
|
|
assertEquals(null, schedule3.getScheduleEnd());
|
|
|
|
schedule.setScheduleStart(null);
|
|
assertEquals(null, schedule.getScheduleStart());
|
|
assertEquals(4321, schedule.getScheduleEnd().getTime());
|
|
|
|
schedule.setScheduleEnd(null);
|
|
assertEquals(null, schedule.getScheduleStart());
|
|
assertEquals(null, schedule.getScheduleEnd());
|
|
|
|
// Check the interval parts
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(null, schedule.getScheduleIntervalCount());
|
|
assertEquals(null, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalCount(3);
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(3, schedule.getScheduleIntervalCount().intValue());
|
|
assertEquals(null, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
assertEquals("3Hour", schedule.getScheduleInterval());
|
|
assertEquals(3, schedule.getScheduleIntervalCount().intValue());
|
|
assertEquals(IntervalPeriod.Hour, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalCount(8);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Month);
|
|
assertEquals("8Month", schedule.getScheduleInterval());
|
|
assertEquals(8, schedule.getScheduleIntervalCount().intValue());
|
|
assertEquals(IntervalPeriod.Month, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalCount(null);
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(null, schedule.getScheduleIntervalCount());
|
|
assertEquals(IntervalPeriod.Month, schedule.getScheduleIntervalPeriod());
|
|
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(null, schedule.getScheduleIntervalCount());
|
|
assertEquals(null, schedule.getScheduleIntervalPeriod());
|
|
|
|
// Trigger parts happen in another test
|
|
}
|
|
|
|
/**
|
|
* Tests that the to-trigger stuff works properly
|
|
*/
|
|
public void testActionToTrigger() throws Exception
|
|
{
|
|
// Can't get a trigger until persisted
|
|
ScheduledPersistedActionImpl schedule =
|
|
(ScheduledPersistedActionImpl) service.createSchedule(testAction);
|
|
Trigger t;
|
|
try {
|
|
schedule.asTrigger();
|
|
fail("Should require persistence first");
|
|
} catch (IllegalStateException e) {
|
|
}
|
|
|
|
service.saveSchedule(schedule);
|
|
schedule.asTrigger();
|
|
|
|
// No schedule, no trigger
|
|
assertEquals(null, schedule.getScheduleInterval());
|
|
assertEquals(null, schedule.getScheduleIntervalCount());
|
|
assertEquals(null, schedule.getScheduleIntervalPeriod());
|
|
assertEquals(null, schedule.asTrigger());
|
|
|
|
// Only start date
|
|
schedule.setScheduleStart(new Date(12345));
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals(12345, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
assertEquals(SimpleTrigger.class, t.getClass());
|
|
|
|
// Only end date
|
|
// (End date + no repeat = never schedule)
|
|
schedule.setScheduleStart(null);
|
|
schedule.setScheduleEnd(new Date(12345));
|
|
|
|
t = schedule.asTrigger();
|
|
assertEquals(null, t);
|
|
|
|
// Only interval
|
|
schedule.setScheduleStart(null);
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleIntervalCount(2);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Second);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals((double) System.currentTimeMillis(), (double) t
|
|
.getStartTime().getTime(), 10); // Within 10ms
|
|
assertEquals(null, t.getEndTime());
|
|
assertEquals(DateIntervalTrigger.class, t.getClass());
|
|
assertEquals(2, ((DateIntervalTrigger) t).getRepeatInterval());
|
|
assertEquals(IntervalUnit.SECOND, ((DateIntervalTrigger) t)
|
|
.getRepeatIntervalUnit());
|
|
|
|
// Start+interval
|
|
schedule.setScheduleStart(new Date(12345));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleIntervalCount(3);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Month);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals(12345, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
assertEquals(DateIntervalTrigger.class, t.getClass());
|
|
assertEquals(3, ((DateIntervalTrigger) t).getRepeatInterval());
|
|
assertEquals(IntervalUnit.MONTH, ((DateIntervalTrigger) t)
|
|
.getRepeatIntervalUnit());
|
|
|
|
// Start+interval+end-in-the-past
|
|
schedule.setScheduleStart(new Date(12345));
|
|
schedule.setScheduleEnd(new Date(54321));
|
|
schedule.setScheduleIntervalCount(12);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Week);
|
|
|
|
t = schedule.asTrigger();
|
|
assertEquals(null, t);
|
|
|
|
// Start+interval+end-in-the-future
|
|
long future = System.currentTimeMillis() + 1234567;
|
|
schedule.setScheduleStart(new Date(12345));
|
|
schedule.setScheduleEnd(new Date(future));
|
|
schedule.setScheduleIntervalCount(12);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Week);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals(12345, t.getStartTime().getTime());
|
|
assertEquals(future, t.getEndTime().getTime());
|
|
assertEquals(DateIntervalTrigger.class, t.getClass());
|
|
assertEquals(12, ((DateIntervalTrigger) t).getRepeatInterval());
|
|
assertEquals(IntervalUnit.WEEK, ((DateIntervalTrigger) t)
|
|
.getRepeatIntervalUnit());
|
|
|
|
// interval+end
|
|
schedule.setScheduleStart(null);
|
|
schedule.setScheduleEnd(new Date(future));
|
|
schedule.setScheduleIntervalCount(6);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals((double) System.currentTimeMillis(), (double) t
|
|
.getStartTime().getTime(), 2); // Within 2ms
|
|
assertEquals(future, t.getEndTime().getTime());
|
|
assertEquals(DateIntervalTrigger.class, t.getClass());
|
|
assertEquals(6, ((DateIntervalTrigger) t).getRepeatInterval());
|
|
assertEquals(IntervalUnit.HOUR, ((DateIntervalTrigger) t)
|
|
.getRepeatIntervalUnit());
|
|
|
|
// Start+end-in-the-past
|
|
// (Ignored as the end has passed)
|
|
schedule.setScheduleStart(new Date(12345));
|
|
schedule.setScheduleEnd(new Date(54321));
|
|
schedule.setScheduleIntervalCount(null);
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
|
|
t = schedule.asTrigger();
|
|
assertEquals(null, t);
|
|
|
|
// Start+end-in-the-future
|
|
// Start is used to decide when to run
|
|
// End is used to decide if we missed it!
|
|
// (No interval so no repeats so end not needed on trigger)
|
|
schedule.setScheduleStart(new Date(12345));
|
|
schedule.setScheduleEnd(new Date(future));
|
|
schedule.setScheduleIntervalCount(null);
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
assertEquals(12345, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
assertEquals(SimpleTrigger.class, t.getClass());
|
|
}
|
|
|
|
/**
|
|
* Tests that the triggers are suitably tweaked based on when the last run
|
|
* occured
|
|
*/
|
|
public void testAsTriggerLastRun() throws Exception
|
|
{
|
|
long future = System.currentTimeMillis() + 1234567;
|
|
long future90mins = System.currentTimeMillis() + 90*60*1000;
|
|
long past30mins = System.currentTimeMillis() - 30*60*1000;
|
|
long past90mins = System.currentTimeMillis() - 90*60*1000;
|
|
long past150mins = System.currentTimeMillis() - 150*60*1000;
|
|
|
|
ScheduledPersistedActionImpl schedule = (ScheduledPersistedActionImpl) service
|
|
.createSchedule(testAction);
|
|
service.saveSchedule(schedule);
|
|
Trigger t;
|
|
|
|
|
|
// No start date, repeats set, never run
|
|
// Will be started ASAP
|
|
schedule.setScheduleStart(null);
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(null);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
schedule.setScheduleIntervalCount(2);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(
|
|
(double) System.currentTimeMillis(),
|
|
(double) t.getStartTime().getTime(), 10); // Within 10ms
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// No start date, repeats set, previously run
|
|
// Will be started ASAP
|
|
schedule.setScheduleStart(null);
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(new Date(past30mins));
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
schedule.setScheduleIntervalCount(2);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(
|
|
(double) System.currentTimeMillis(),
|
|
(double) t.getStartTime().getTime(), 10); // Within 10ms
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the past, no repeats, never run
|
|
// Will be started ASAP
|
|
schedule.setScheduleStart(new Date(past30mins));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(null);
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
schedule.setScheduleIntervalCount(null);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(past30mins, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the future, no repeats, never run
|
|
// Will be started at the requested time
|
|
schedule.setScheduleStart(new Date(future));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(null);
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
schedule.setScheduleIntervalCount(null);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(future, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the past, no repeats, has run since the start date
|
|
// Won't be started, as deemed to have already fired
|
|
schedule.setScheduleStart(new Date(past90mins));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(new Date(past30mins));
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
schedule.setScheduleIntervalCount(null);
|
|
|
|
t = schedule.asTrigger();
|
|
assertEquals(null, t);
|
|
|
|
|
|
// Start date in the past, no repeats, previously run but before the start date
|
|
// Will be run ASAP, previous run details will be ignored
|
|
schedule.setScheduleStart(new Date(past30mins));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(new Date(past90mins));
|
|
schedule.setScheduleIntervalPeriod(null);
|
|
schedule.setScheduleIntervalCount(null);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(past30mins, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the future, no repeats, previously run
|
|
// Will be started at the requested time
|
|
schedule.setScheduleStart(new Date(future));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(new Date(past30mins));
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
schedule.setScheduleIntervalCount(2);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(future, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the past, has repeats, never run
|
|
// Will be run ASAP
|
|
schedule.setScheduleStart(new Date(past30mins));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(null);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
schedule.setScheduleIntervalCount(2);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(past30mins, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the future, has repeats, never run
|
|
// Will be started at the requested time
|
|
schedule.setScheduleStart(new Date(future));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(null);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
schedule.setScheduleIntervalCount(2);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(future, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the past, has repeats, last run was before
|
|
// the start date
|
|
// Will be run ASAP, previous run details will be ignored
|
|
schedule.setScheduleStart(new Date(past30mins));
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(new Date(past90mins));
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
schedule.setScheduleIntervalCount(2);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(past30mins, t.getStartTime().getTime());
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the past, has repeats, run since the start date,
|
|
// last run within the repeat interval
|
|
// Will run at the next interval, based off the start time
|
|
schedule.setScheduleStart(new Date(past150mins)); // 2.5 hours ago
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(new Date(past30mins)); // 0.5 hours ago, schedule worked
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
schedule.setScheduleIntervalCount(2);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(future90mins, t.getStartTime().getTime()); // 4 hours from start time
|
|
assertEquals(null, t.getEndTime());
|
|
|
|
|
|
// Start date in the past, has repeats, run since the start date,
|
|
// last run over a repeat interval ago
|
|
// Will be run ASAP, start date based on real start so that
|
|
// the interval is done right
|
|
schedule.setScheduleStart(new Date(past150mins)); // 2.5 hours ago
|
|
schedule.setScheduleEnd(null);
|
|
schedule.setScheduleLastExecutedAt(new Date(past90mins));
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Hour);
|
|
schedule.setScheduleIntervalCount(2);
|
|
|
|
t = schedule.asTrigger();
|
|
assertNotNull(t);
|
|
|
|
assertEquals(past150mins, t.getStartTime().getTime()); // Real start used
|
|
assertEquals(future90mins, t.getFireTimeAfter(new Date()).getTime()); // After this, fire 4 hours from start
|
|
assertEquals(null, t.getEndTime());
|
|
}
|
|
|
|
/**
|
|
* Tests that we can create, save, edit, delete etc the scheduled persisted
|
|
* actions
|
|
*/
|
|
public void testCreation()
|
|
{
|
|
ScheduledPersistedAction schedule = service.createSchedule(testAction);
|
|
assertNotNull(schedule);
|
|
assertTrue(testAction == schedule.getAction());
|
|
assertEquals(testAction.getNodeRef(), schedule.getAction().getNodeRef());
|
|
|
|
assertNull(schedule.getScheduleStart());
|
|
assertNull(schedule.getScheduleInterval());
|
|
assertNull(schedule.getScheduleIntervalCount());
|
|
assertNull(schedule.getScheduleIntervalPeriod());
|
|
|
|
Date now = new Date();
|
|
schedule.setScheduleStart(now);
|
|
assertEquals(now, schedule.getScheduleStart());
|
|
schedule.setScheduleIntervalCount(2);
|
|
assertEquals(new Integer(2), schedule.getScheduleIntervalCount());
|
|
schedule
|
|
.setScheduleIntervalPeriod(ScheduledPersistedAction.IntervalPeriod.Day);
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, schedule
|
|
.getScheduleIntervalPeriod());
|
|
}
|
|
|
|
public void testCreateSaveLoad() throws Exception
|
|
{
|
|
// create and save schedule
|
|
ScheduledPersistedAction schedule = service.createSchedule(testAction);
|
|
assertNotNull(schedule);
|
|
Date now = new Date();
|
|
schedule.setScheduleStart(now);
|
|
schedule.setScheduleIntervalCount(2);
|
|
schedule
|
|
.setScheduleIntervalPeriod(ScheduledPersistedAction.IntervalPeriod.Day);
|
|
|
|
assertNull(
|
|
((ScheduledPersistedActionImpl) schedule).getPersistedAtNodeRef()
|
|
);
|
|
service.saveSchedule(schedule);
|
|
assertNotNull(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
|
|
// Load it again, should have the same details still
|
|
ScheduledPersistedAction retrieved = serviceImpl
|
|
.loadPersistentSchedule(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(2), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, retrieved
|
|
.getScheduleIntervalPeriod());
|
|
assertNotNull(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
|
|
// Load a 2nd copy, won't be any changes
|
|
ScheduledPersistedAction second = serviceImpl
|
|
.loadPersistentSchedule(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
assertNotNull(second);
|
|
assertEquals(testAction.getNodeRef(), second.getAction().getNodeRef());
|
|
assertEquals(now, second.getScheduleStart());
|
|
assertEquals(new Integer(2), second.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, second
|
|
.getScheduleIntervalPeriod());
|
|
|
|
// Now ensure we can create for an action that didn't have a noderef
|
|
// when we started
|
|
schedule = service.createSchedule(testAction3);
|
|
|
|
assertNull(schedule.getActionNodeRef());
|
|
assertNull(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
|
|
runtimeActionService.createActionNodeRef(
|
|
//
|
|
testAction3,
|
|
ScheduledPersistedActionServiceImpl.SCHEDULED_ACTION_ROOT_NODE_REF,
|
|
ContentModel.ASSOC_CONTAINS, QName.createQName("TestAction3"));
|
|
|
|
assertNotNull(schedule.getActionNodeRef());
|
|
assertNull(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
|
|
service.saveSchedule(schedule);
|
|
|
|
assertNotNull(schedule.getActionNodeRef());
|
|
assertNotNull(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
}
|
|
|
|
/**
|
|
* Ensures that we can create, save, edit, save load, edit, save, load etc,
|
|
* all without problems, and without creating duplicates
|
|
*/
|
|
public void testEditing() throws Exception
|
|
{
|
|
// create and save schedule
|
|
ScheduledPersistedAction schedule = service.createSchedule(testAction);
|
|
assertNotNull(schedule);
|
|
Date now = new Date();
|
|
schedule.setScheduleStart(now);
|
|
schedule.setScheduleIntervalCount(2);
|
|
schedule
|
|
.setScheduleIntervalPeriod(ScheduledPersistedAction.IntervalPeriod.Day);
|
|
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
service.saveSchedule(schedule);
|
|
txn.commit();
|
|
|
|
// Load and check it hasn't changed
|
|
txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
ScheduledPersistedAction retrieved = serviceImpl
|
|
.loadPersistentSchedule(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
txn.commit();
|
|
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(2), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, retrieved
|
|
.getScheduleIntervalPeriod());
|
|
|
|
// Save and re-load without changes
|
|
txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
service.saveSchedule(schedule);
|
|
retrieved = serviceImpl
|
|
.loadPersistentSchedule(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
txn.commit();
|
|
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(2), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, retrieved
|
|
.getScheduleIntervalPeriod());
|
|
|
|
// Make some small changes
|
|
txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
retrieved = serviceImpl
|
|
.loadPersistentSchedule(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
retrieved.setScheduleIntervalCount(3);
|
|
service.saveSchedule(retrieved);
|
|
retrieved = serviceImpl
|
|
.loadPersistentSchedule(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
txn.commit();
|
|
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(3), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Day, retrieved
|
|
.getScheduleIntervalPeriod());
|
|
|
|
// And some more changes
|
|
retrieved
|
|
.setScheduleIntervalPeriod(ScheduledPersistedAction.IntervalPeriod.Month);
|
|
now = new Date();
|
|
retrieved.setScheduleStart(now);
|
|
|
|
txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
service.saveSchedule(retrieved);
|
|
retrieved = serviceImpl
|
|
.loadPersistentSchedule(((ScheduledPersistedActionImpl) schedule)
|
|
.getPersistedAtNodeRef());
|
|
txn.commit();
|
|
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getAction().getNodeRef());
|
|
assertEquals(now, retrieved.getScheduleStart());
|
|
assertEquals(new Integer(3), retrieved.getScheduleIntervalCount());
|
|
assertEquals(ScheduledPersistedAction.IntervalPeriod.Month, retrieved
|
|
.getScheduleIntervalPeriod());
|
|
}
|
|
|
|
/**
|
|
* Tests that the listings work, both of all scheduled, and from an action
|
|
*/
|
|
public void testLoadList() throws Exception
|
|
{
|
|
assertEquals(0, service.listSchedules().size());
|
|
|
|
// Create
|
|
ScheduledPersistedAction schedule1 = service.createSchedule(testAction);
|
|
assertNotNull(schedule1);
|
|
ScheduledPersistedAction schedule2 = service.createSchedule(testAction2);
|
|
assertNotNull(schedule2);
|
|
|
|
assertEquals(0, service.listSchedules().size());
|
|
|
|
service.saveSchedule(schedule1);
|
|
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(testAction.getNodeRef(), service.listSchedules().get(0)
|
|
.getActionNodeRef());
|
|
|
|
service.saveSchedule(schedule2);
|
|
assertEquals(2, service.listSchedules().size());
|
|
}
|
|
|
|
public void testLoadFromAction() throws Exception
|
|
{
|
|
// Create schedule
|
|
ScheduledPersistedAction schedule1 = service.createSchedule(testAction);
|
|
assertNotNull(schedule1);
|
|
service.saveSchedule(schedule1);
|
|
|
|
// retrieve schedule for action which doesn't have schedule
|
|
ScheduledPersistedAction retrieved = service.getSchedule(testAction2);
|
|
assertNull(retrieved);
|
|
|
|
// and from one which does
|
|
retrieved = service.getSchedule(testAction);
|
|
assertNotNull(retrieved);
|
|
assertEquals(testAction.getNodeRef(), retrieved.getActionNodeRef());
|
|
}
|
|
|
|
/**
|
|
* Tests that the startup registering works properly
|
|
*/
|
|
public void testStartup() throws Exception
|
|
{
|
|
// Startup with none there, nothing happens
|
|
assertEquals(
|
|
0,
|
|
scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length
|
|
);
|
|
assertEquals(
|
|
0,
|
|
service.listSchedules().size()
|
|
);
|
|
|
|
bootstrap.onBootstrap(null);
|
|
|
|
assertEquals(
|
|
0,
|
|
scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length
|
|
);
|
|
assertEquals(
|
|
0,
|
|
service.listSchedules().size()
|
|
);
|
|
|
|
|
|
// Manually add a scheduled action
|
|
// Does a bit of faffing to have it not in Quartz initially
|
|
long future = System.currentTimeMillis() + 1234567;
|
|
ScheduledPersistedAction schedule = service.createSchedule(testAction);
|
|
schedule.setScheduleStart(new Date(future));
|
|
service.saveSchedule(schedule);
|
|
|
|
((ScheduledPersistedActionServiceImpl)ctx.getBean("scheduledPersistedActionService"))
|
|
.removeFromScheduler( (ScheduledPersistedActionImpl)schedule );
|
|
|
|
assertEquals(
|
|
0,
|
|
scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length
|
|
);
|
|
assertEquals(
|
|
1,
|
|
service.listSchedules().size()
|
|
);
|
|
|
|
// Now do the bootstrap, and see it get registered
|
|
bootstrap.onBootstrap(null);
|
|
|
|
assertEquals(
|
|
1,
|
|
scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length
|
|
);
|
|
assertEquals(
|
|
1,
|
|
service.listSchedules().size()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Ensures that deletion works correctly
|
|
*/
|
|
public void testDeletion() throws Exception
|
|
{
|
|
// Delete does nothing if not persisted
|
|
assertEquals(0, service.listSchedules().size());
|
|
ScheduledPersistedAction schedule1 = service.createSchedule(testAction);
|
|
assertEquals(0, service.listSchedules().size());
|
|
|
|
service.deleteSchedule(schedule1);
|
|
assertEquals(0, service.listSchedules().size());
|
|
|
|
// Create and save two
|
|
ScheduledPersistedAction schedule2 = service.createSchedule(testAction2);
|
|
service.saveSchedule(schedule1);
|
|
service.saveSchedule(schedule2);
|
|
assertEquals(2, service.listSchedules().size());
|
|
NodeRef schedule1NodeRef = ((ScheduledPersistedActionImpl) schedule1)
|
|
.getPersistedAtNodeRef();
|
|
NodeRef schedule2NodeRef = ((ScheduledPersistedActionImpl) schedule2)
|
|
.getPersistedAtNodeRef();
|
|
|
|
// Both should have the relationship
|
|
assertEquals(1, nodeService.getTargetAssocs(schedule1NodeRef,
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(1, nodeService.getTargetAssocs(schedule2NodeRef,
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(1, nodeService.getSourceAssocs(testAction.getNodeRef(),
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(1, nodeService.getSourceAssocs(testAction2.getNodeRef(),
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
|
|
// Delete one - the correct one goes!
|
|
service.deleteSchedule(schedule2);
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(testAction.getNodeRef(), service.listSchedules().get(0)
|
|
.getActionNodeRef());
|
|
assertNotNull(serviceImpl.loadPersistentSchedule(schedule1NodeRef));
|
|
assertNull(serviceImpl.loadPersistentSchedule(schedule2NodeRef));
|
|
assertNotNull(service.getSchedule(testAction));
|
|
assertNull(service.getSchedule(testAction2));
|
|
|
|
// Ensure that the relationship went
|
|
assertEquals(1, nodeService.getTargetAssocs(schedule1NodeRef,
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(1, nodeService.getSourceAssocs(testAction.getNodeRef(),
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(0, nodeService.getSourceAssocs(testAction2.getNodeRef(),
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
|
|
// Re-delete already deleted, no change
|
|
service.deleteSchedule(schedule2);
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(testAction.getNodeRef(), service.listSchedules().get(0)
|
|
.getActionNodeRef());
|
|
assertNotNull(serviceImpl.loadPersistentSchedule(schedule1NodeRef));
|
|
assertNull(serviceImpl.loadPersistentSchedule(schedule2NodeRef));
|
|
assertNotNull(service.getSchedule(testAction));
|
|
assertNull(service.getSchedule(testAction2));
|
|
|
|
// Delete the 2nd
|
|
service.deleteSchedule(schedule1);
|
|
assertEquals(0, service.listSchedules().size());
|
|
assertNull(serviceImpl.loadPersistentSchedule(schedule1NodeRef));
|
|
assertNull(serviceImpl.loadPersistentSchedule(schedule2NodeRef));
|
|
assertNull(service.getSchedule(testAction));
|
|
assertNull(service.getSchedule(testAction2));
|
|
|
|
// Ensure that the relationship went
|
|
assertEquals(0, nodeService.getSourceAssocs(testAction.getNodeRef(),
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
assertEquals(0, nodeService.getSourceAssocs(testAction2.getNodeRef(),
|
|
RegexQNamePattern.MATCH_ALL).size());
|
|
|
|
// Can add back in again after being deleted
|
|
service.saveSchedule(schedule1);
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(testAction.getNodeRef(), service.listSchedules().get(0)
|
|
.getActionNodeRef());
|
|
assertNotNull(service.getSchedule(testAction));
|
|
assertNull(service.getSchedule(testAction2));
|
|
|
|
// If we delete the action, then we have an orphaned schedule
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
txn.begin();
|
|
nodeService.deleteNode(testAction.getNodeRef());
|
|
txn.commit();
|
|
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(1, service.listSchedules().size());
|
|
assertEquals(null, service.listSchedules().get(0).getAction());
|
|
assertEquals(null, service.listSchedules().get(0).getActionNodeRef());
|
|
}
|
|
|
|
/**
|
|
* Tests that things get properly injected onto the job bean
|
|
*/
|
|
public void testJobBeanInjection() throws Exception
|
|
{
|
|
// This test needs the scheduler running properly
|
|
scheduler.start();
|
|
|
|
// The job should run almost immediately
|
|
Job job = new TestJob();
|
|
JobDetail details = new JobDetail("ThisIsATest", null, job.getClass());
|
|
Trigger now = new SimpleTrigger("TestTrigger", new Date(1));
|
|
now.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
|
|
|
|
Scheduler scheduler = (Scheduler) ctx.getBean("schedulerFactory");
|
|
scheduler.scheduleJob(details, now);
|
|
|
|
// Allow it to run
|
|
for (int i = 0; i < 20; i++) {
|
|
if (!TestJob.ran)
|
|
Thread.sleep(50);
|
|
}
|
|
|
|
// Ensure it ran, and it got a copy of the context
|
|
assertEquals(true, TestJob.ran);
|
|
assertEquals(true, TestJob.gotContext);
|
|
}
|
|
|
|
/**
|
|
* Tests that things actually get run correctly. Each sub-test runs in its
|
|
* own transaction
|
|
*/
|
|
public void testExecution() throws Exception
|
|
{
|
|
final SleepActionExecuter sleepActionExec = (SleepActionExecuter) ctx
|
|
.getBean(SleepActionExecuter.NAME);
|
|
sleepActionExec.resetTimesExecuted();
|
|
sleepActionExec.setSleepMs(1);
|
|
|
|
// This test needs the scheduler running properly
|
|
scheduler.start();
|
|
|
|
// Until the schedule is persisted, nothing will happen
|
|
ScheduledPersistedAction schedule = service.createSchedule(testAction);
|
|
assertEquals(
|
|
0,
|
|
scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length
|
|
);
|
|
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<Void>() {
|
|
public Void execute() throws Throwable {
|
|
|
|
// A job due to start in 1 second, and run once
|
|
ScheduledPersistedAction schedule = service
|
|
.createSchedule(testAction);
|
|
schedule.setScheduleStart(new Date(
|
|
System.currentTimeMillis() + 1000));
|
|
assertNull(schedule.getScheduleInterval());
|
|
assertNull(schedule.getScheduleIntervalCount());
|
|
assertNull(schedule.getScheduleIntervalPeriod());
|
|
assertNull(schedule.getScheduleLastExecutedAt());
|
|
|
|
System.out.println("Job starts in 1 second, no repeat...");
|
|
service.saveSchedule(schedule);
|
|
|
|
return null;
|
|
}
|
|
}, false, true);
|
|
|
|
// Check it went in
|
|
assertEquals(
|
|
1,
|
|
scheduler
|
|
.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
// Let it run
|
|
Thread.sleep(2000);
|
|
|
|
// Ensure it did properly run the once
|
|
assertEquals(1, sleepActionExec.getTimesExecuted());
|
|
|
|
// Should have removed itself now the schedule is over
|
|
assertEquals(
|
|
0,
|
|
scheduler
|
|
.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<Void>() {
|
|
public Void execute() throws Throwable {
|
|
|
|
// Ensure it was tagged with when it ran
|
|
ScheduledPersistedAction schedule = service
|
|
.getSchedule(testAction);
|
|
assertEquals(
|
|
(double) System.currentTimeMillis(),
|
|
(double) schedule.getScheduleLastExecutedAt().getTime(),
|
|
2500); // Within 2.5 secs
|
|
|
|
// Zap it
|
|
service.deleteSchedule(schedule);
|
|
assertEquals(
|
|
0,
|
|
scheduler
|
|
.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
return null;
|
|
}
|
|
}, false, true);
|
|
|
|
// ==========================
|
|
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<Void>() {
|
|
public Void execute() throws Throwable {
|
|
|
|
// A job that runs every 2 seconds, for the next 3.5 seconds
|
|
// (Should get to run twice, now and @2 secs)
|
|
ScheduledPersistedAction schedule = service
|
|
.createSchedule(testAction);
|
|
schedule.setScheduleStart(new Date(System.currentTimeMillis()-50));
|
|
((ScheduledPersistedActionImpl) schedule)
|
|
.setScheduleEnd(new Date(
|
|
System.currentTimeMillis() + 3500));
|
|
schedule.setScheduleIntervalCount(2);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Second);
|
|
assertEquals("2Second", schedule.getScheduleInterval());
|
|
|
|
// Reset count
|
|
sleepActionExec.resetTimesExecuted();
|
|
assertEquals(0, sleepActionExec.getTimesExecuted());
|
|
|
|
service.saveSchedule(schedule);
|
|
System.out.println(
|
|
"Job " +
|
|
((ScheduledPersistedActionImpl)schedule).getPersistedAtNodeRef() +
|
|
" starts now, repeats twice @ 2s"
|
|
);
|
|
|
|
return null;
|
|
}
|
|
}, false, true);
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<Void>() {
|
|
public Void execute() throws Throwable {
|
|
Thread.sleep(4250);
|
|
|
|
ScheduledPersistedAction schedule = service
|
|
.getSchedule(testAction);
|
|
|
|
// Ensure it did properly run two times
|
|
// (Depending on timing of tests, might actually slip in 3
|
|
// runs)
|
|
if (sleepActionExec.getTimesExecuted() == 3) {
|
|
assertEquals(3, sleepActionExec.getTimesExecuted());
|
|
} else {
|
|
assertEquals(2, sleepActionExec.getTimesExecuted());
|
|
}
|
|
|
|
// Zap it
|
|
service.deleteSchedule(schedule);
|
|
assertEquals(
|
|
0,
|
|
scheduler.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length
|
|
);
|
|
|
|
return null;
|
|
}
|
|
}, false, true);
|
|
|
|
// ==========================
|
|
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<Void>() {
|
|
public Void execute() throws Throwable {
|
|
|
|
// A job that starts in 2 seconds time, and runs
|
|
// every second until we kill it
|
|
ScheduledPersistedAction schedule = service
|
|
.createSchedule(testAction);
|
|
schedule.setScheduleStart(new Date(
|
|
System.currentTimeMillis() + 2000));
|
|
schedule.setScheduleIntervalCount(1);
|
|
schedule.setScheduleIntervalPeriod(IntervalPeriod.Second);
|
|
assertEquals("1Second", schedule.getScheduleInterval());
|
|
|
|
// Reset count
|
|
sleepActionExec.resetTimesExecuted();
|
|
assertEquals(0, sleepActionExec.getTimesExecuted());
|
|
|
|
System.out.println("Job starts in 2s, repeats @ 1s");
|
|
service.saveSchedule(schedule);
|
|
|
|
return null;
|
|
}
|
|
}, false, true);
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<Void>() {
|
|
public Void execute() throws Throwable {
|
|
|
|
// Let it run a few times
|
|
Thread.sleep(5000);
|
|
|
|
// Zap it - should still be live
|
|
ScheduledPersistedAction schedule = service
|
|
.getSchedule(testAction);
|
|
assertEquals(
|
|
1,
|
|
scheduler
|
|
.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
service.deleteSchedule(schedule);
|
|
assertEquals(
|
|
0,
|
|
scheduler
|
|
.getJobNames(ScheduledPersistedActionServiceImpl.SCHEDULER_GROUP).length);
|
|
|
|
// Check it ran an appropriate number of times
|
|
assertEquals("Didn't run enough - "
|
|
+ sleepActionExec.getTimesExecuted(), true,
|
|
sleepActionExec.getTimesExecuted() >= 3);
|
|
assertEquals("Ran too much - "
|
|
+ sleepActionExec.getTimesExecuted(), true,
|
|
sleepActionExec.getTimesExecuted() < 5);
|
|
|
|
// Ensure it finished shutting down
|
|
Thread.sleep(500);
|
|
|
|
return null;
|
|
}
|
|
}, false, true);
|
|
}
|
|
|
|
/**
|
|
* Tests that when we have more than one schedule defined and active, then
|
|
* the correct things run at the correct times, and we never get confused
|
|
*/
|
|
public void testMultipleExecutions() throws Exception
|
|
{
|
|
final SleepActionExecuter sleepActionExec = (SleepActionExecuter) ctx
|
|
.getBean(SleepActionExecuter.NAME);
|
|
sleepActionExec.resetTimesExecuted();
|
|
sleepActionExec.setSleepMs(1);
|
|
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<Void>() {
|
|
public Void execute() throws Throwable {
|
|
|
|
// Create one that starts running in 2 seconds, runs every 2
|
|
// seconds
|
|
// until 9 seconds are up (will run 4 times)
|
|
ScheduledPersistedActionImpl scheduleA = (ScheduledPersistedActionImpl) service
|
|
.createSchedule(testAction);
|
|
scheduleA.setScheduleStart(new Date(System
|
|
.currentTimeMillis() + 2000));
|
|
scheduleA.setScheduleEnd(new Date(
|
|
System.currentTimeMillis() + 9000));
|
|
scheduleA.setScheduleIntervalCount(2);
|
|
scheduleA.setScheduleIntervalPeriod(IntervalPeriod.Second);
|
|
service.saveSchedule(scheduleA);
|
|
|
|
// Create one that starts running now, every second until 9.5
|
|
// seconds
|
|
// are up (will run 9-10 times)
|
|
ScheduledPersistedActionImpl scheduleB = (ScheduledPersistedActionImpl) service
|
|
.createSchedule(testAction2);
|
|
scheduleB.setScheduleStart(new Date(System
|
|
.currentTimeMillis()));
|
|
scheduleB.setScheduleEnd(new Date(
|
|
System.currentTimeMillis() + 9500));
|
|
scheduleB.setScheduleIntervalCount(1);
|
|
scheduleB.setScheduleIntervalPeriod(IntervalPeriod.Second);
|
|
service.saveSchedule(scheduleB);
|
|
|
|
return null;
|
|
}
|
|
}, false, true);
|
|
|
|
// Set them going
|
|
scheduler.start();
|
|
|
|
// Wait for 10 seconds for them to run and finish
|
|
Thread.sleep(10 * 1000);
|
|
|
|
// Check that they really did run properly
|
|
transactionService.getRetryingTransactionHelper().doInTransaction(
|
|
new RetryingTransactionCallback<Void>() {
|
|
public Void execute() throws Throwable {
|
|
|
|
ScheduledPersistedAction scheduleA = service
|
|
.getSchedule(testAction);
|
|
ScheduledPersistedAction scheduleB = service
|
|
.getSchedule(testAction2);
|
|
|
|
// Both should have last run at some point in the last second
|
|
// or two
|
|
assertEquals((double) System.currentTimeMillis(),
|
|
(double) scheduleA.getScheduleLastExecutedAt()
|
|
.getTime(), 2500);
|
|
assertEquals((double) System.currentTimeMillis(),
|
|
(double) scheduleB.getScheduleLastExecutedAt()
|
|
.getTime(), 2500);
|
|
|
|
// A should have run ~4 times
|
|
// B should have run ~9 times
|
|
assertEquals("Didn't run enough - "
|
|
+ sleepActionExec.getTimesExecuted(), true,
|
|
sleepActionExec.getTimesExecuted() >= 11);
|
|
assertEquals("Ran too much - "
|
|
+ sleepActionExec.getTimesExecuted(), true,
|
|
sleepActionExec.getTimesExecuted() < 16);
|
|
|
|
return null;
|
|
}
|
|
}, false, true);
|
|
}
|
|
|
|
// ============================================================================
|
|
|
|
/**
|
|
* For unit testing only - not thread safe!
|
|
*/
|
|
public static class TestJob implements Job, ApplicationContextAware
|
|
{
|
|
private static boolean gotContext = false;
|
|
private static boolean ran = false;
|
|
|
|
public TestJob()
|
|
{
|
|
gotContext = false;
|
|
ran = false;
|
|
}
|
|
|
|
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
|
|
{
|
|
gotContext = true;
|
|
}
|
|
|
|
public void execute(JobExecutionContext paramJobExecutionContext) throws JobExecutionException
|
|
{
|
|
ran = true;
|
|
}
|
|
}
|
|
|
|
protected static class TestAction extends ActionImpl
|
|
{
|
|
protected TestAction(Action action)
|
|
{
|
|
super(action);
|
|
}
|
|
}
|
|
|
|
}
|