def _scheduleMePlease(self):
"""
This queue needs to have its run() method invoked at some point in the
future. Tell the dependent scheduler to schedule it if it isn't
already pending execution.
"""
sched = IScheduler(self.store)
if len(list(sched.scheduledTimes(self))) == 0:
sched.schedule(self, sched.now())
def _scheduleMePlease(self):
"""
This queue needs to have its run() method invoked at some point in the
future. Tell the dependent scheduler to schedule it if it isn't
already pending execution.
"""
sched = IScheduler(self.store)
if len(list(sched.scheduledTimes(self))) == 0:
sched.schedule(self, sched.now())
def _schedule(self, when):
"""
Ensure that this hook is scheduled to run at or before C{when}.
"""
sched = IScheduler(self.store)
for scheduledAt in sched.scheduledTimes(self):
if when < scheduledAt:
sched.reschedule(self, scheduledAt, when)
break
else:
sched.schedule(self, when)
def _schedule(self, when):
"""
Ensure that this hook is scheduled to run at or before C{when}.
"""
sched = IScheduler(self.store)
for scheduledAt in sched.scheduledTimes(self):
if when < scheduledAt:
sched.reschedule(self, scheduledAt, when)
break
else:
sched.schedule(self, when)
def test_inspection(self):
"""
Test that the L{scheduledTimes} method returns an iterable of all the
times at which a particular item is scheduled to run.
"""
now = self.now() + timedelta(seconds=1)
off = timedelta(seconds=3)
sch = IScheduler(self.store)
runnable = TestEvent(store=self.store, name=u'Only event')
sch.schedule(runnable, now)
sch.schedule(runnable, now + off)
sch.schedule(runnable, now + off + off)
self.assertEquals(list(sch.scheduledTimes(runnable)),
[now, now + off, now + off + off])
def test_inspection(self):
"""
Test that the L{scheduledTimes} method returns an iterable of all the
times at which a particular item is scheduled to run.
"""
now = self.now() + timedelta(seconds=1)
off = timedelta(seconds=3)
sch = IScheduler(self.store)
runnable = TestEvent(store=self.store, name=u'Only event')
sch.schedule(runnable, now)
sch.schedule(runnable, now + off)
sch.schedule(runnable, now + off + off)
self.assertEquals(
list(sch.scheduledTimes(runnable)),
[now, now + off, now + off + off])
def test_scheduledTimesDuringRun(self):
"""
L{Scheduler.scheduledTimes} should not include scheduled times that have
already triggered.
"""
futureTimes = []
scheduler = IScheduler(self.store)
runner = HookRunner(store=self.store,
hook=lambda self: futureTimes.append(
list(scheduler.scheduledTimes(self))))
then = self.now() + timedelta(seconds=1)
scheduler.schedule(runner, self.now())
scheduler.schedule(runner, then)
self.clock.advance(1)
self.assertEquals(futureTimes, [[then], []])
def test_scheduledTimesDuringRun(self):
"""
L{Scheduler.scheduledTimes} should not include scheduled times that have
already triggered.
"""
futureTimes = []
scheduler = IScheduler(self.store)
runner = HookRunner(
store=self.store,
hook=lambda self: futureTimes.append(
list(scheduler.scheduledTimes(self))))
then = self.now() + timedelta(seconds=1)
scheduler.schedule(runner, self.now())
scheduler.schedule(runner, then)
self.clock.advance(1)
self.assertEquals(futureTimes, [[then], []])
class SubStoreSchedulerReentrancy(TestCase):
"""
Test re-entrant scheduling calls on an item run by a SubScheduler.
"""
def setUp(self):
self.clock = Clock()
self.dbdir = filepath.FilePath(self.mktemp())
self.store = Store(self.dbdir)
self.substoreItem = SubStore.createNew(self.store, ['sub'])
self.substore = self.substoreItem.open()
self.scheduler = IScheduler(self.store)
self.subscheduler = IScheduler(self.substore)
self.scheduler.callLater = self.clock.callLater
self.scheduler.now = lambda: Time.fromPOSIXTimestamp(self.clock.seconds())
self.subscheduler.now = lambda: Time.fromPOSIXTimestamp(self.clock.seconds())
IService(self.store).startService()
def tearDown(self):
return IService(self.store).stopService()
def _scheduleRunner(self, now, offset):
scheduledAt = Time.fromPOSIXTimestamp(now + offset)
rescheduleFor = Time.fromPOSIXTimestamp(now + offset + 10)
runnable = ScheduleCallingItem(store=self.substore, rescheduleFor=rescheduleFor)
self.subscheduler.schedule(runnable, scheduledAt)
return runnable
def testSchedule(self):
"""
Test the schedule method, as invoked from the run method of an item
being run by the subscheduler.
"""
now = self.clock.seconds()
runnable = self._scheduleRunner(now, 10)
self.clock.advance(11)
self.assertEqual(
list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + 20)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.subStore == self.substoreItem)
self.assertEqual(
list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(now + 20)])
def testScheduleWithLaterTimedEvents(self):
"""
Like L{testSchedule}, but use a SubScheduler which has pre-existing
TimedEvents which are beyond the new runnable's scheduled time (to
trigger the reschedule-using code-path in
_SubSchedulerParentHook._schedule).
"""
now = self.clock.seconds()
when = Time.fromPOSIXTimestamp(now + 30)
null = NullRunnable(store=self.substore)
self.subscheduler.schedule(null, when)
runnable = self._scheduleRunner(now, 10)
self.clock.advance(11)
self.assertEqual(
list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + 20)])
self.assertEqual(
list(self.subscheduler.scheduledTimes(null)),
[Time.fromPOSIXTimestamp(now + 30)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.subStore == self.substoreItem)
self.assertEqual(
list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(20)])
def testScheduleWithEarlierTimedEvents(self):
"""
Like L{testSchedule}, but use a SubScheduler which has pre-existing
TimedEvents which are before the new runnable's scheduled time.
"""
now = self.clock.seconds()
when = Time.fromPOSIXTimestamp(now + 15)
null = NullRunnable(store=self.substore)
self.subscheduler.schedule(null, when)
runnable = self._scheduleRunner(now, 10)
self.clock.advance(11)
self.assertEqual(
list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + 20)])
self.assertEqual(
list(self.subscheduler.scheduledTimes(null)),
[Time.fromPOSIXTimestamp(now + 15)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.subStore == self.substoreItem)
self.assertEqual(
list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(now + 15)])
def testMultipleEventsPerTick(self):
"""
Test running several runnables in a single tick of the subscheduler.
"""
now = self.clock.seconds()
runnables = [
self._scheduleRunner(now, 10),
self._scheduleRunner(now, 11),
self._scheduleRunner(now, 12)]
self.clock.advance(13)
for n, runnable in enumerate(runnables):
self.assertEqual(
list(self.subscheduler.scheduledTimes(runnable)),
[Time.fromPOSIXTimestamp(now + n + 20)])
hook = self.store.findUnique(
_SubSchedulerParentHook,
_SubSchedulerParentHook.subStore == self.substoreItem)
self.assertEqual(
list(self.scheduler.scheduledTimes(hook)),
[Time.fromPOSIXTimestamp(now + 20)])
