def test_regularLocks(self):
lock1 = locks.MasterLock("masterlock")
lock2 = locks.WorkerLock("workerlock")
self.setupStep(self.FakeBuildStep(
locks=[locks.LockAccess(lock1, 'counting'), locks.LockAccess(lock2, 'exclusive')]))
self.expectOutcome(result=SUCCESS)
yield self.runStep()
def testNowMixed2(self):
""" Test counting is not possible when an exclsuive has the lock """
lid = locks.MasterLock('dummy')
lac = locks.LockAccess(lid, 'counting')
lae = locks.LockAccess(lid, 'exclusive')
l = locks.BaseLock("name", maxCount=2)
self.failUnless(l.isAvailable(lae))
l.claim("count-owner", lae)
self.failIf(l.isAvailable(lac))
l.release("count-owner", lae)
self.failUnless(l.isAvailable(lae))
def test_regularLocks(self):
lock1 = mock.Mock(spec=locks.MasterLock)
lock1.name = "masterlock"
lock2 = mock.Mock(spec=locks.SlaveLock)
lock2.name = "slavelock"
self.setupStep(
self.FakeBuildStep(locks=[
locks.LockAccess(lock1, 'counting'),
locks.LockAccess(lock2, 'exclusive')
]))
self.expectOutcome(result=SUCCESS)
yield self.runStep()
def test_regularLocks(self):
master_lock = locks.MasterLock("masterlock")
worker_lock = locks.WorkerLock("workerlock")
lock_accesses = [locks.LockAccess(master_lock, 'counting'),
locks.LockAccess(worker_lock, 'exclusive')]
self.setupStep(self.LockBuildStep(testcase=self, lock_accesses=lock_accesses,
locks=lock_accesses))
self.expectOutcome(result=SUCCESS)
yield self.runStep()
botmaster = self.step.build.builder.botmaster
real_master_lock = yield botmaster.getLockFromLockAccess(lock_accesses[0],
self.build.config_version)
real_worker_lock = yield botmaster.getLockFromLockAccess(lock_accesses[1],
self.build.config_version)
self.assertTrue(real_master_lock.isAvailable(self, lock_accesses[0]))
self.assertIn('workername', real_worker_lock.locks)
self.assertTrue(real_worker_lock.locks['workername'].isAvailable(self, lock_accesses[1]))
def testLaterCounting(self):
lid = locks.MasterLock('dummy')
la = locks.LockAccess(lid, 'counting')
lock = locks.BaseLock("name", 2)
lock.claim("owner1", la)
lock.claim("owner2", la)
d = claimHarder(lock, "owner3", la)
d.addCallback(lambda lock: lock.release("owner3", la))
lock.release("owner2", la)
lock.release("owner1", la)
return d
def testNowCounting(self):
lid = locks.MasterLock('dummy')
la = locks.LockAccess(lid, 'counting')
lock = locks.BaseLock("name", 2)
self.failUnless(lock.isAvailable(la))
lock.claim("owner1", la)
self.failUnless(lock.isAvailable(la))
lock.claim("owner2", la)
self.failIf(lock.isAvailable(la))
lock.release("owner1", la)
self.failUnless(lock.isAvailable(la))
lock.release("owner2", la)
self.failUnless(lock.isAvailable(la))
def testRandomCounting(self):
lid = locks.MasterLock('dummy')
la = locks.LockAccess(lid, 'counting')
COUNT = 5
lock = locks.BaseLock("name", COUNT)
dl = []
for i in range(100):
owner = "owner%d" % i
mode = random.choice(["now", "very soon", "soon"])
d = claimHarder(lock, owner, la)
def _check(lock):
self.failIf(len(lock.owners) > COUNT)
return lock
d.addCallback(_check)
d.addCallback(hold, owner, la, mode)
dl.append(d)
d = defer.DeferredList(dl)
d.addCallback(self._cleanup, lock, COUNT, la)
return d
def rendered_locks(props):
renderedLocks[0] = True
access1 = locks.LockAccess(lock1, 'counting')
access2 = locks.LockAccess(lock2, 'exclusive')
return [access1, access2]
def lock(name):
l = mock.Mock(spec=locks.MasterLock)
l.name = name
if bare_builder_lock:
return l
return locks.LockAccess(l, "counting", _skipChecks=True)
def testCompetitionExclusive(self):
lid = locks.MasterLock('dummy')
la = locks.LockAccess(lid, 'exclusive')
return self._testCompetition(la)
def testCompetitionCounting(self):
lid = locks.MasterLock('dummy')
la = locks.LockAccess(lid, 'counting')
return self._testCompetition(la)
def testLaterExclusive(self):
lid = locks.MasterLock('dummy')
la = locks.LockAccess(lid, 'exclusive')
return self._testLater(la)
def testLaterCounting(self):
lid = locks.MasterLock('dummy')
la = locks.LockAccess(lid, 'counting')
return self._testLater(la)
def test_cancelWhileLocksAvailable(self):
def _owns_lock(step, lock):
access = [
step_access for step_lock, step_access in step.locks
if step_lock == lock
][0]
return lock.isOwner(step, access)
def _lock_available(step, lock):
access = [
step_access for step_lock, step_access in step.locks
if step_lock == lock
][0]
return lock.isAvailable(step, access)
lock1 = locks.MasterLock("masterlock1")
real_lock1 = locks.RealMasterLock(lock1)
lock2 = locks.MasterLock("masterlock2")
real_lock2 = locks.RealMasterLock(lock2)
stepa = self.setupStep(
self.FakeBuildStep(locks=[(real_lock1,
locks.LockAccess(lock1, 'exclusive'))]))
stepb = self.setupStep(
self.FakeBuildStep(locks=[(real_lock2,
locks.LockAccess(lock2, 'exclusive'))]))
stepc = self.setupStep(
self.FakeBuildStep(
locks=[(real_lock1, locks.LockAccess(lock1, 'exclusive')
), (real_lock2,
locks.LockAccess(lock2, 'exclusive'))]))
stepd = self.setupStep(
self.FakeBuildStep(
locks=[(real_lock1, locks.LockAccess(lock1, 'exclusive')
), (real_lock2,
locks.LockAccess(lock2, 'exclusive'))]))
# Start all the steps
yield stepa.acquireLocks()
yield stepb.acquireLocks()
c_d = stepc.acquireLocks()
d_d = stepd.acquireLocks()
# Check that step a and step b have the locks
self.assertTrue(_owns_lock(stepa, real_lock1))
self.assertTrue(_owns_lock(stepb, real_lock2))
# Check that step c does not have a lock
self.assertFalse(_owns_lock(stepc, real_lock1))
self.assertFalse(_owns_lock(stepc, real_lock2))
# Check that step d does not have a lock
self.assertFalse(_owns_lock(stepd, real_lock1))
self.assertFalse(_owns_lock(stepd, real_lock2))
# Release lock 1
stepa.releaseLocks()
yield deferLater(reactor, 0, lambda: None)
# lock1 should be available for step c
self.assertTrue(_lock_available(stepc, real_lock1))
self.assertFalse(_lock_available(stepc, real_lock2))
self.assertFalse(_lock_available(stepd, real_lock1))
self.assertFalse(_lock_available(stepd, real_lock2))
# Cancel step c
stepc.interrupt("cancelling")
yield c_d
# Check that step c does not have a lock
self.assertFalse(_owns_lock(stepc, real_lock1))
self.assertFalse(_owns_lock(stepc, real_lock2))
# No lock should be available for step c
self.assertFalse(_lock_available(stepc, real_lock1))
self.assertFalse(_lock_available(stepc, real_lock2))
# lock 1 should be available for step d
self.assertTrue(_lock_available(stepd, real_lock1))
self.assertFalse(_lock_available(stepd, real_lock2))
# Release lock 2
stepb.releaseLocks()
# Both locks should be available for step d
self.assertTrue(_lock_available(stepd, real_lock1))
self.assertTrue(_lock_available(stepd, real_lock2))
# So it should run
yield d_d
# Check that step d owns the locks
self.assertTrue(_owns_lock(stepd, real_lock1))
self.assertTrue(_owns_lock(stepd, real_lock2))
def rendered_locks(props):
master_access = locks.LockAccess(master_lock, 'counting')
worker_access = locks.LockAccess(worker_lock, 'exclusive')
lock_accesses.append(master_access)
lock_accesses.append(worker_access)
return [master_access, worker_access]
