alfresco-community-repo/source/java/org/alfresco/repo/action/scheduled/ScheduledPersistedActionServiceTest.java
Nick Burch 1f5c3a1d20 Improve how scheduled actions with historic start dates are handled during startup. The last run time is used to decide when they need to be re-scheduled for (ALF-4505)
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
2010-09-01 16:16:32 +00:00

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);
}
}
}