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]