def testStopBuildWaitingForLocks(self):
r = FakeRequest()
b = Build([r])
b.setBuilder(Mock())
b.builder.botmaster = FakeMaster()
slavebuilder = Mock()
status = Mock()
l = SlaveLock('lock')
lock_access = l.access('counting')
l.access = lambda mode: lock_access
real_lock = b.builder.botmaster.getLockByID(l).getLock(slavebuilder)
b.setLocks([l])
step = Mock()
step.return_value = step
step.startStep.return_value = SUCCESS
step.alwaysRun = False
b.setStepFactories([(step, {})])
real_lock.claim(Mock(), l.access('counting'))
def acquireLocks(res=None):
retval = Build.acquireLocks(b, res)
b.stopBuild('stop it')
return retval
b.acquireLocks = acquireLocks
b.startBuild(status, None, slavebuilder)
self.assert_( ('startStep', (b.remote,), {}) not in step.method_calls)
self.assert_(b.currentStep is None)
self.assertEqual(b.result, EXCEPTION)
self.assert_( ('interrupt', ('stop it',), {}) not in step.method_calls)
def testBuildWaitingForLocks(self):
r = FakeRequest()
b = Build([r])
b.setBuilder(Mock())
b.builder.botmaster = FakeMaster()
slavebuilder = Mock()
status = Mock()
l = SlaveLock('lock')
claimCount = [0]
lock_access = l.access('counting')
l.access = lambda mode: lock_access
real_lock = b.builder.botmaster.getLockByID(l).getLock(slavebuilder)
def claim(owner, access):
claimCount[0] += 1
return real_lock.old_claim(owner, access)
real_lock.old_claim = real_lock.claim
real_lock.claim = claim
b.setLocks([l])
step = Mock()
step.return_value = step
step.startStep.return_value = SUCCESS
b.setStepFactories([(step, {})])
real_lock.claim(Mock(), l.access('counting'))
b.startBuild(status, None, slavebuilder)
self.assert_( ('startStep', (b.remote,), {}) not in step.method_calls)
self.assertEquals(claimCount[0], 1)
self.assert_(b.currentStep is None)
self.assert_(b._acquiringLock is not None)
def testBuildLocksAcquired(self):
r = FakeRequest()
b = Build([r])
b.setBuilder(Mock())
b.builder.botmaster = FakeMaster()
slavebuilder = Mock()
status = Mock()
l = SlaveLock("lock")
claimCount = [0]
lock_access = l.access("counting")
l.access = lambda mode: lock_access
real_lock = b.builder.botmaster.getLockByID(l).getLock(slavebuilder)
def claim(owner, access):
claimCount[0] += 1
return real_lock.old_claim(owner, access)
real_lock.old_claim = real_lock.claim
real_lock.claim = claim
b.setLocks([l])
step = Mock()
step.return_value = step
step.startStep.return_value = SUCCESS
b.setStepFactories([(step, {})])
b.startBuild(status, None, slavebuilder)
self.assertEqual(b.result, SUCCESS)
self.assert_(("startStep", (b.remote,), {}) in step.method_calls)
self.assertEquals(claimCount[0], 1)
def testBuildLocksOrder(self):
"""Test that locks are acquired in FIFO order; specifically that
counting locks cannot jump ahead of exclusive locks"""
eBuild = self.build
cBuilder = FakeBuilder(self.master)
cBuild = Build([self.request])
cBuild.setBuilder(cBuilder)
eWorker = Mock()
cWorker = Mock()
eWorker.worker = self.worker
cWorker.worker = self.worker
eWorker.prepare = cWorker.prepare = lambda _: True
eWorker.ping = cWorker.ping = lambda: True
l = WorkerLock('lock', 2)
claimLog = []
realLock = self.master.botmaster.getLockByID(l).getLock(self.worker)
def claim(owner, access):
claimLog.append(owner)
return realLock.oldClaim(owner, access)
realLock.oldClaim = realLock.claim
realLock.claim = claim
eBuild.setLocks([l.access('exclusive')])
cBuild.setLocks([l.access('counting')])
fakeBuild = Mock()
fakeBuildAccess = l.access('counting')
realLock.claim(fakeBuild, fakeBuildAccess)
step = Mock()
step.return_value = step
step.startStep.return_value = SUCCESS
eBuild.setStepFactories([FakeStepFactory(step)])
cBuild.setStepFactories([FakeStepFactory(step)])
e = eBuild.startBuild(FakeBuildStatus(), eWorker)
c = cBuild.startBuild(FakeBuildStatus(), cWorker)
d = defer.DeferredList([e, c])
realLock.release(fakeBuild, fakeBuildAccess)
def check(ign):
self.assertEqual(eBuild.results, SUCCESS)
self.assertEqual(cBuild.results, SUCCESS)
self.assertEqual(claimLog, [fakeBuild, eBuild, cBuild])
d.addCallback(check)
return d
def testBuildLocksOrder(self):
"""Test that locks are acquired in FIFO order; specifically that
counting locks cannot jump ahead of exclusive locks"""
eBuild = self.build
cBuilder = FakeBuilder(self.master)
cBuild = Build([self.request])
cBuild.setBuilder(cBuilder)
eWorker = Mock()
cWorker = Mock()
eWorker.worker = self.worker
cWorker.worker = self.worker
eWorker.prepare = cWorker.prepare = lambda _: True
eWorker.ping = cWorker.ping = lambda: True
l = WorkerLock("lock", 2)
claimLog = []
realLock = self.master.botmaster.getLockByID(l).getLock(self.worker)
def claim(owner, access):
claimLog.append(owner)
return realLock.oldClaim(owner, access)
realLock.oldClaim = realLock.claim
realLock.claim = claim
eBuild.setLocks([l.access("exclusive")])
cBuild.setLocks([l.access("counting")])
fakeBuild = Mock()
fakeBuildAccess = l.access("counting")
realLock.claim(fakeBuild, fakeBuildAccess)
step = Mock()
step.return_value = step
step.startStep.return_value = SUCCESS
eBuild.setStepFactories([FakeStepFactory(step)])
cBuild.setStepFactories([FakeStepFactory(step)])
e = eBuild.startBuild(FakeBuildStatus(), eWorker)
c = cBuild.startBuild(FakeBuildStatus(), cWorker)
d = defer.DeferredList([e, c])
realLock.release(fakeBuild, fakeBuildAccess)
def check(ign):
self.assertEqual(eBuild.results, SUCCESS)
self.assertEqual(cBuild.results, SUCCESS)
self.assertEqual(claimLog, [fakeBuild, eBuild, cBuild])
d.addCallback(check)
return d
def testBuildLocksOrder(self):
"""Test that locks are acquired in FIFO order; specifically that
counting locks cannot jump ahead of exclusive locks"""
eBuild = self.build
cBuilder = self.createBuilder()
cBuild = Build([self.request])
cBuild.setBuilder(cBuilder)
eSlavebuilder = Mock()
cSlavebuilder = Mock()
slave = eSlavebuilder.slave
cSlavebuilder.slave = slave
l = SlaveLock('lock', 2)
claimLog = []
realLock = self.master.botmaster.getLockByID(l).getLock(slave)
def claim(owner, access):
claimLog.append(owner)
return realLock.oldClaim(owner, access)
realLock.oldClaim = realLock.claim
realLock.claim = claim
eBuild.setLocks([l.access('exclusive')])
cBuild.setLocks([l.access('counting')])
fakeBuild = Mock()
fakeBuildAccess = l.access('counting')
realLock.claim(fakeBuild, fakeBuildAccess)
step = Mock()
step.return_value = step
step.startStep.return_value = SUCCESS
eBuild.setStepFactories([FakeStepFactory(step)])
cBuild.setStepFactories([FakeStepFactory(step)])
e = eBuild.startBuild(FakeBuildStatus(), None, eSlavebuilder)
c = cBuild.startBuild(FakeBuildStatus(), None, cSlavebuilder)
d = defer.DeferredList([e, c])
realLock.release(fakeBuild, fakeBuildAccess)
def check(ign):
self.assertEqual(eBuild.result, NOT_REBUILT)
self.assertEqual(cBuild.result, NOT_REBUILT)
self.assertEquals(claimLog, [fakeBuild, eBuild, cBuild])
d.addCallback(check)
return d
def testBuildLocksOrder(self):
"""Test that locks are acquired in FIFO order; specifically that
counting locks cannot jump ahead of exclusive locks"""
eBuild = self.build
cBuilder = self.createBuilder()
cBuild = Build([self.request])
cBuild.setBuilder(cBuilder)
eSlavebuilder = Mock()
cSlavebuilder = Mock()
slave = eSlavebuilder.slave
cSlavebuilder.slave = slave
l = SlaveLock('lock', 2)
claimLog = []
realLock = self.master.botmaster.getLockByID(l).getLock(slave)
def claim(owner, access):
claimLog.append(owner)
return realLock.oldClaim(owner, access)
realLock.oldClaim = realLock.claim
realLock.claim = claim
eBuild.setLocks([l.access('exclusive')])
cBuild.setLocks([l.access('counting')])
fakeBuild = Mock()
fakeBuildAccess = l.access('counting')
realLock.claim(fakeBuild, fakeBuildAccess)
step = Mock()
step.return_value = step
step.startStep.return_value = SUCCESS
eBuild.setStepFactories([FakeStepFactory(step)])
cBuild.setStepFactories([FakeStepFactory(step)])
e = eBuild.startBuild(FakeBuildStatus(), None, eSlavebuilder)
c = cBuild.startBuild(FakeBuildStatus(), None, cSlavebuilder)
d = defer.DeferredList([e, c])
realLock.release(fakeBuild, fakeBuildAccess)
def check(ign):
self.assertEqual(eBuild.result, SUCCESS)
self.assertEqual(cBuild.result, SUCCESS)
self.assertEquals(claimLog, [fakeBuild, eBuild, cBuild])
d.addCallback(check)
return d
def testBuildLocksOrder(self):
"""Test that locks are acquired in FIFO order; specifically that
counting locks cannot jump ahead of exclusive locks"""
eBuild = self.build
cBuilder = FakeBuilder(self.master)
cBuild = Build([self.request])
cBuild.setBuilder(cBuilder)
eWorker = Mock()
cWorker = Mock()
eWorker.worker = self.worker
cWorker.worker = self.worker
eWorker.substantiate_if_needed = cWorker.substantiate_if_needed = lambda _: True
eWorker.ping = cWorker.ping = lambda: True
lock = WorkerLock('lock', 2)
claimLog = []
real_workerlock = yield self.master.botmaster.getLockByID(lock, 0)
realLock = real_workerlock.getLockForWorker(self.worker.workername)
def claim(owner, access):
claimLog.append(owner)
return realLock.oldClaim(owner, access)
realLock.oldClaim = realLock.claim
realLock.claim = claim
yield eBuild.setLocks([lock.access('exclusive')])
yield cBuild.setLocks([lock.access('counting')])
fakeBuild = Mock()
fakeBuildAccess = lock.access('counting')
realLock.claim(fakeBuild, fakeBuildAccess)
step = FakeBuildStep()
eBuild.setStepFactories([FakeStepFactory(step)])
cBuild.setStepFactories([FakeStepFactory(step)])
e = eBuild.startBuild(eWorker)
c = cBuild.startBuild(cWorker)
d = defer.DeferredList([e, c])
realLock.release(fakeBuild, fakeBuildAccess)
yield d
self.assertEqual(eBuild.results, SUCCESS)
self.assertEqual(cBuild.results, SUCCESS)
self.assertEqual(claimLog, [fakeBuild, eBuild, cBuild])
