def test_21_peek_readonly(self): """Peek over a readonly transport""" t = self.get_transport() lf1 = LockDir(t, 'test_lock') lf1.create() lf2 = LockDir(self.get_readonly_transport(), 'test_lock') self.assertEqual(lf2.peek(), None) lf1.attempt_lock() info2 = lf2.peek() self.assertTrue(info2) self.assertEqual(info2['nonce'], lf1.nonce)
def test_missing_lockdir_info(self): """We can cope with absent info files.""" t = self.get_transport() t.mkdir('test_lock') t.mkdir('test_lock/held') lf = LockDir(t, 'test_lock') # In this case we expect the 'not held' result from peek, because peek # cannot be expected to notice that there is a 'held' directory with no # 'info' file. self.assertEqual(None, lf.peek()) # And lock/unlock may work or give LockContention (but not any other # error). try: lf.attempt_lock() except LockContention: # LockContention is ok, and expected on Windows pass else: # no error is ok, and expected on POSIX (because POSIX allows # os.rename over an empty directory). lf.unlock() # Currently raises TokenMismatch, but LockCorrupt would be reasonable # too. self.assertRaises( (errors.TokenMismatch, errors.LockCorrupt), lf.validate_token, 'fake token')
def test_uses_lockdir(self): """WorkingTreeFormat4 uses its own LockDir: - lock is a directory - when the WorkingTree is locked, LockDir can see that """ # this test could be factored into a subclass of tests common to both # format 3 and 4, but for now its not much of an issue as there is only one in common. t = self.get_transport() tree = self.make_workingtree() self.assertIsDirectory('.bzr', t) self.assertIsDirectory('.bzr/checkout', t) self.assertIsDirectory('.bzr/checkout/lock', t) our_lock = LockDir(t, '.bzr/checkout/lock') self.assertEquals(our_lock.peek(), None) tree.lock_write() self.assertTrue(our_lock.peek()) tree.unlock() self.assertEquals(our_lock.peek(), None)
def test_uses_lockdir(self): """WorkingTreeFormat3 uses its own LockDir: - lock is a directory - when the WorkingTree is locked, LockDir can see that """ t = self.get_transport() url = self.get_url() dir = bzrdir.BzrDirMetaFormat1().initialize(url) repo = dir.create_repository() branch = dir.create_branch() try: tree = workingtree.WorkingTreeFormat3().initialize(dir) except errors.NotLocalUrl: raise TestSkipped('Not a local URL') self.assertIsDirectory('.bzr', t) self.assertIsDirectory('.bzr/checkout', t) self.assertIsDirectory('.bzr/checkout/lock', t) our_lock = LockDir(t, '.bzr/checkout/lock') self.assertEquals(our_lock.peek(), None) tree.lock_write() self.assertTrue(our_lock.peek()) tree.unlock() self.assertEquals(our_lock.peek(), None)
def test_uses_lockdir(self): """WorkingTreeFormat3 uses its own LockDir: - lock is a directory - when the WorkingTree is locked, LockDir can see that """ t = self.get_transport() url = self.get_url() dir = bzrdir.BzrDirMetaFormat1().initialize(url) repo = dir.create_repository() branch = dir.create_branch() try: tree = workingtree_3.WorkingTreeFormat3().initialize(dir) except errors.NotLocalUrl: raise TestSkipped('Not a local URL') self.assertIsDirectory('.bzr', t) self.assertIsDirectory('.bzr/checkout', t) self.assertIsDirectory('.bzr/checkout/lock', t) our_lock = LockDir(t, '.bzr/checkout/lock') self.assertEquals(our_lock.peek(), None) tree.lock_write() self.assertTrue(our_lock.peek()) tree.unlock() self.assertEquals(our_lock.peek(), None)
def test_45_break_mismatch(self): """Lock break races with someone else acquiring it""" t = self.get_transport() lf1 = LockDir(t, 'test_lock') lf1.create() lf1.attempt_lock() # someone else sees it's still locked lf2 = LockDir(t, 'test_lock') holder_info = lf2.peek() # in the interim the lock is released lf1.unlock() lf3 = LockDir(t, 'test_lock') lf3.attempt_lock() # break should now *fail* self.assertRaises(LockBreakMismatch, lf2.force_break, holder_info) lf3.unlock()
def test_44_break_already_released(self): """Lock break races with regular release""" t = self.get_transport() lf1 = LockDir(t, 'test_lock') lf1.create() lf1.attempt_lock() # someone else sees it's still locked lf2 = LockDir(t, 'test_lock') holder_info = lf2.peek() # in the interim the lock is released lf1.unlock() # break should succeed lf2.force_break(holder_info) # now we should be able to take it lf2.attempt_lock() lf2.confirm()
def test_43_break(self): """Break a lock whose caller has forgotten it""" t = self.get_transport() lf1 = LockDir(t, 'test_lock') lf1.create() lf1.attempt_lock() # we incorrectly discard the lock object without unlocking it del lf1 # someone else sees it's still locked lf2 = LockDir(t, 'test_lock') holder_info = lf2.peek() self.assertTrue(holder_info) lf2.force_break(holder_info) # now we should be able to take it lf2.attempt_lock() lf2.confirm()
def test_20_lock_peek(self): """Peek at the state of a lock""" t = self.get_transport() lf1 = LockDir(t, 'test_lock') lf1.create() lf1.attempt_lock() # lock is held, should get some info on it info1 = lf1.peek() self.assertEqual(set(info1.keys()), set(['user', 'nonce', 'hostname', 'pid', 'start_time'])) # should get the same info if we look at it through a different # instance info2 = LockDir(t, 'test_lock').peek() self.assertEqual(info1, info2) # locks which are never used should be not-held self.assertEqual(LockDir(t, 'other_lock').peek(), None)
def test_no_lockdir_info(self): """We can cope with empty info files.""" # This seems like a fairly common failure case - see # <https://bugs.launchpad.net/bzr/+bug/185103> and all its dupes. # Processes are often interrupted after opening the file # before the actual contents are committed. t = self.get_transport() t.mkdir('test_lock') t.mkdir('test_lock/held') t.put_bytes('test_lock/held/info', '') lf = LockDir(t, 'test_lock') info = lf.peek() formatted_info = info.to_readable_dict() self.assertEqual( dict(user='******', hostname='<unknown>', pid='<unknown>', time_ago='(unknown)'), formatted_info)
def test_20_lock_peek(self): """Peek at the state of a lock""" t = self.get_transport() lf1 = LockDir(t, 'test_lock') lf1.create() lf1.attempt_lock() self.addCleanup(lf1.unlock) # lock is held, should get some info on it info1 = lf1.peek() self.assertEqual(set(info1.info_dict.keys()), set(['user', 'nonce', 'hostname', 'pid', 'start_time'])) # should get the same info if we look at it through a different # instance info2 = LockDir(t, 'test_lock').peek() self.assertEqual(info1, info2) # locks which are never used should be not-held self.assertEqual(LockDir(t, 'other_lock').peek(), None)
def test_no_lockdir_info(self): """We can cope with empty info files.""" # This seems like a fairly common failure case - see # <https://bugs.launchpad.net/bzr/+bug/185103> and all its dupes. # Processes are often interrupted after opening the file # before the actual contents are committed. t = self.get_transport() t.mkdir('test_lock') t.mkdir('test_lock/held') t.put_bytes('test_lock/held/info', '') lf = LockDir(t, 'test_lock') info = lf.peek() formatted_info = info.to_readable_dict() self.assertEquals( dict(user='******', hostname='<unknown>', pid='<unknown>', time_ago='(unknown)'), formatted_info)
def test_03_readonly_peek(self): lf = LockDir(self.get_readonly_transport(), 'test_lock') self.assertEqual(lf.peek(), None)
def test_02_unlocked_peek(self): lf = LockDir(self.get_transport(), 'test_lock') self.assertEqual(lf.peek(), None)