def test_poolStartServiceChecksForWork(self):
"""
L{PeerConnectionPool.startService} kicks off the idle work-check loop.
"""
reactor = MemoryReactorWithClock()
cph = SteppablePoolHelper(nodeSchema + schemaText)
then = datetime.datetime(2012, 12, 12, 12, 12, 0)
reactor.advance(astimestamp(then))
cph.setUp(self)
pcp = PeerConnectionPool(reactor, cph.pool.connection, 4321, schema)
now = then + datetime.timedelta(seconds=pcp.queueProcessTimeout * 2)
@transactionally(cph.pool.connection)
def createOldWork(txn):
one = DummyWorkItem.create(txn, workID=1, a=3, b=4, notBefore=then)
two = DummyWorkItem.create(txn, workID=2, a=7, b=9, notBefore=now)
return gatherResults([one, two])
pcp.startService()
cph.flushHolders()
reactor.advance(pcp.queueProcessTimeout * 2)
self.assertEquals(cph.rows("select * from DUMMY_WORK_DONE"), [(1, 7)])
cph.rows("delete from DUMMY_WORK_DONE")
reactor.advance(pcp.queueProcessTimeout * 2)
self.assertEquals(cph.rows("select * from DUMMY_WORK_DONE"), [(2, 16)])
def test_notBeforeBefore(self):
"""
L{PeerConnectionPool.enqueueWork} will execute its work immediately if
the C{notBefore} attribute of the work item in question is in the past.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
realChoosePerformer = qpool.choosePerformer
performerChosen = []
def catchPerformerChoice():
result = realChoosePerformer()
performerChosen.append(True)
return result
qpool.choosePerformer = catchPerformerChoice
@transactionally(dbpool.connection)
def check(txn):
return qpool.enqueueWork(
txn, DummyWorkItem, a=3, b=9,
notBefore=datetime.datetime(2012, 12, 12, 12, 12, 0)
).whenProposed()
proposal = yield check
clock.advance(1000)
# Advance far beyond the given timestamp.
self.assertEquals(performerChosen, [True])
result = yield proposal.whenExecuted()
self.assertIdentical(result, proposal)
def test_poolStartServiceChecksForWork(self):
"""
L{PeerConnectionPool.startService} kicks off the idle work-check loop.
"""
reactor = MemoryReactorWithClock()
cph = SteppablePoolHelper(nodeSchema + schemaText)
then = datetime.datetime(2012, 12, 12, 12, 12, 0)
reactor.advance(astimestamp(then))
cph.setUp(self)
pcp = PeerConnectionPool(reactor, cph.pool.connection, 4321, schema)
now = then + datetime.timedelta(seconds=pcp.queueProcessTimeout * 2)
@transactionally(cph.pool.connection)
def createOldWork(txn):
one = DummyWorkItem.create(txn, workID=1, a=3, b=4, notBefore=then)
two = DummyWorkItem.create(txn, workID=2, a=7, b=9, notBefore=now)
return gatherResults([one, two])
pcp.startService()
cph.flushHolders()
reactor.advance(pcp.queueProcessTimeout * 2)
self.assertEquals(
cph.rows("select * from DUMMY_WORK_DONE"),
[(1, 7)]
)
cph.rows("delete from DUMMY_WORK_DONE")
reactor.advance(pcp.queueProcessTimeout * 2)
self.assertEquals(
cph.rows("select * from DUMMY_WORK_DONE"),
[(2, 16)]
)
def test_notBeforeWhenCheckingForLostWork(self):
"""
L{PeerConnectionPool._periodicLostWorkCheck} should execute any
outstanding work items, but only those that are expired.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
# An arbitrary point in time.
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
# *why* does datetime still not have .astimestamp()
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
# Let's create a couple of work items directly, not via the enqueue
# method, so that they exist but nobody will try to immediately execute
# them.
@transactionally(dbpool.connection)
@inlineCallbacks
def setup(txn):
# First, one that's right now.
yield DummyWorkItem.create(txn, a=1, b=2, notBefore=fakeNow)
# Next, create one that's actually far enough into the past to run.
yield DummyWorkItem.create(
txn,
a=3,
b=4,
notBefore=(
# Schedule it in the past so that it should have already
# run.
fakeNow - datetime.timedelta(
seconds=qpool.queueProcessTimeout + 20)))
# Finally, one that's actually scheduled for the future.
yield DummyWorkItem.create(txn,
a=10,
b=20,
notBefore=fakeNow +
datetime.timedelta(1000))
yield setup
qpool.running = True
yield qpool._periodicLostWorkCheck()
@transactionally(dbpool.connection)
def check(txn):
return DummyWorkDone.all(txn)
every = yield check
self.assertEquals([x.aPlusB for x in every], [7])
def test_notBeforeWhenEnqueueing(self):
"""
L{PeerConnectionPool.enqueueWork} enqueues some work immediately, but
only executes it when enough time has elapsed to allow the C{notBefore}
attribute of the given work item to have passed.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
realChoosePerformer = qpool.choosePerformer
performerChosen = []
def catchPerformerChoice():
result = realChoosePerformer()
performerChosen.append(True)
return result
qpool.choosePerformer = catchPerformerChoice
@transactionally(dbpool.connection)
def check(txn):
return qpool.enqueueWork(txn,
DummyWorkItem,
a=3,
b=9,
notBefore=datetime.datetime(
2012, 12, 12, 12, 12,
20)).whenProposed()
proposal = yield check
# This is going to schedule the work to happen with some asynchronous
# I/O in the middle; this is a problem because how do we know when it's
# time to check to see if the work has started? We need to intercept
# the thing that kicks off the work; we can then wait for the work
# itself.
self.assertEquals(performerChosen, [])
# Advance to exactly the appointed second.
clock.advance(20 - 12)
self.assertEquals(performerChosen, [True])
# FIXME: if this fails, it will hang, but that's better than no
# notification that it is broken at all.
result = yield proposal.whenExecuted()
self.assertIdentical(result, proposal)
def test_notBeforeWhenCheckingForLostWork(self):
"""
L{PeerConnectionPool._periodicLostWorkCheck} should execute any
outstanding work items, but only those that are expired.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
# An arbitrary point in time.
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
# *why* does datetime still not have .astimestamp()
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
# Let's create a couple of work items directly, not via the enqueue
# method, so that they exist but nobody will try to immediately execute
# them.
@transactionally(dbpool.connection)
@inlineCallbacks
def setup(txn):
# First, one that's right now.
yield DummyWorkItem.create(txn, a=1, b=2, notBefore=fakeNow)
# Next, create one that's actually far enough into the past to run.
yield DummyWorkItem.create(
txn, a=3, b=4, notBefore=(
# Schedule it in the past so that it should have already
# run.
fakeNow - datetime.timedelta(
seconds=qpool.queueProcessTimeout + 20
)
)
)
# Finally, one that's actually scheduled for the future.
yield DummyWorkItem.create(
txn, a=10, b=20, notBefore=fakeNow + datetime.timedelta(1000)
)
yield setup
yield qpool._periodicLostWorkCheck()
@transactionally(dbpool.connection)
def check(txn):
return DummyWorkDone.all(txn)
every = yield check
self.assertEquals([x.aPlusB for x in every], [7])
def test_notBeforeWhenEnqueueing(self):
"""
L{PeerConnectionPool.enqueueWork} enqueues some work immediately, but
only executes it when enough time has elapsed to allow the C{notBefore}
attribute of the given work item to have passed.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
realChoosePerformer = qpool.choosePerformer
performerChosen = []
def catchPerformerChoice():
result = realChoosePerformer()
performerChosen.append(True)
return result
qpool.choosePerformer = catchPerformerChoice
@transactionally(dbpool.connection)
def check(txn):
return qpool.enqueueWork(
txn, DummyWorkItem, a=3, b=9,
notBefore=datetime.datetime(2012, 12, 12, 12, 12, 20)
).whenProposed()
proposal = yield check
# This is going to schedule the work to happen with some asynchronous
# I/O in the middle; this is a problem because how do we know when it's
# time to check to see if the work has started? We need to intercept
# the thing that kicks off the work; we can then wait for the work
# itself.
self.assertEquals(performerChosen, [])
# Advance to exactly the appointed second.
clock.advance(20 - 12)
self.assertEquals(performerChosen, [True])
# FIXME: if this fails, it will hang, but that's better than no
# notification that it is broken at all.
result = yield proposal.whenExecuted()
self.assertIdentical(result, proposal)
def test_notBeforeBefore(self):
"""
L{PeerConnectionPool.enqueueWork} will execute its work immediately if
the C{notBefore} attribute of the work item in question is in the past.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
realChoosePerformer = qpool.choosePerformer
performerChosen = []
def catchPerformerChoice():
result = realChoosePerformer()
performerChosen.append(True)
return result
qpool.choosePerformer = catchPerformerChoice
@transactionally(dbpool.connection)
def check(txn):
return qpool.enqueueWork(txn,
DummyWorkItem,
a=3,
b=9,
notBefore=datetime.datetime(
2012, 12, 12, 12, 12,
0)).whenProposed()
proposal = yield check
clock.advance(1000)
# Advance far beyond the given timestamp.
self.assertEquals(performerChosen, [True])
result = yield proposal.whenExecuted()
self.assertIdentical(result, proposal)
