/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_lockdir.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-05-27 01:58:44 UTC
  • mfrom: (5193.4.24 gio-transport)
  • Revision ID: pqm@pqm.ubuntu.com-20100527015844-ya4jahnwjx5y8ej2
(lifeless) Add a gio based transport using gio+ as a prefix to get at the
 gio logic. (Mattias Eriksson)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_lockdir.py
1
 
# Copyright (C) 2006 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006-2010 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for LockDir"""
18
18
 
19
 
from threading import Thread
 
19
from cStringIO import StringIO
 
20
import os
 
21
from threading import Thread, Lock
20
22
import time
21
23
 
 
24
import bzrlib
 
25
from bzrlib import (
 
26
    config,
 
27
    errors,
 
28
    lock,
 
29
    osutils,
 
30
    tests,
 
31
    transport,
 
32
    )
22
33
from bzrlib.errors import (
23
 
        LockBreakMismatch,
24
 
        LockContention, LockError, UnlockableTransport,
25
 
        LockNotHeld, LockBroken
26
 
        )
 
34
    LockBreakMismatch,
 
35
    LockBroken,
 
36
    LockContention,
 
37
    LockError,
 
38
    LockFailed,
 
39
    LockNotHeld,
 
40
    )
27
41
from bzrlib.lockdir import LockDir
28
42
from bzrlib.tests import TestCaseWithTransport
 
43
from bzrlib.trace import note
29
44
 
30
45
# These tests sometimes use threads to test the behaviour of lock files with
31
46
# concurrent actors.  This is not a typical (or necessarily supported) use;
40
55
class TestLockDir(TestCaseWithTransport):
41
56
    """Test LockDir operations"""
42
57
 
 
58
    def logging_report_function(self, fmt, *args):
 
59
        self._logged_reports.append((fmt, args))
 
60
 
 
61
    def setup_log_reporter(self, lock_dir):
 
62
        self._logged_reports = []
 
63
        lock_dir._report_function = self.logging_report_function
 
64
 
43
65
    def test_00_lock_creation(self):
44
66
        """Creation of lock file on a transport"""
45
67
        t = self.get_transport()
56
78
        lf = LockDir(self.get_transport(), 'test_lock')
57
79
        self.assertEqual(lf.peek(), None)
58
80
 
 
81
    def get_lock(self):
 
82
        return LockDir(self.get_transport(), 'test_lock')
 
83
 
 
84
    def test_unlock_after_break_raises(self):
 
85
        ld = self.get_lock()
 
86
        ld2 = self.get_lock()
 
87
        ld.create()
 
88
        ld.attempt_lock()
 
89
        ld2.force_break(ld2.peek())
 
90
        self.assertRaises(LockBroken, ld.unlock)
 
91
 
59
92
    def test_03_readonly_peek(self):
60
93
        lf = LockDir(self.get_readonly_transport(), 'test_lock')
61
94
        self.assertEqual(lf.peek(), None)
76
109
        """Fail to create lock on readonly transport"""
77
110
        t = self.get_readonly_transport()
78
111
        lf = LockDir(t, 'test_lock')
79
 
        self.assertRaises(UnlockableTransport, lf.create)
 
112
        self.assertRaises(LockFailed, lf.create)
80
113
 
81
114
    def test_12_lock_readonly_transport(self):
82
115
        """Fail to lock on readonly transport"""
83
116
        lf = LockDir(self.get_transport(), 'test_lock')
84
117
        lf.create()
85
118
        lf = LockDir(self.get_readonly_transport(), 'test_lock')
86
 
        self.assertRaises(UnlockableTransport, lf.attempt_lock)
 
119
        self.assertRaises(LockFailed, lf.attempt_lock)
87
120
 
88
121
    def test_20_lock_contested(self):
89
122
        """Contention to get a lock"""
93
126
        lf1.attempt_lock()
94
127
        lf2 = LockDir(t, 'test_lock')
95
128
        try:
96
 
            # locking is between LockDir instances; aliases within 
 
129
            # locking is between LockDir instances; aliases within
97
130
            # a single process are not detected
98
131
            lf2.attempt_lock()
99
132
            self.fail('Failed to detect lock collision')
109
142
        lf1 = LockDir(t, 'test_lock')
110
143
        lf1.create()
111
144
        lf1.attempt_lock()
 
145
        self.addCleanup(lf1.unlock)
112
146
        # lock is held, should get some info on it
113
147
        info1 = lf1.peek()
114
148
        self.assertEqual(set(info1.keys()),
128
162
        lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
129
163
        self.assertEqual(lf2.peek(), None)
130
164
        lf1.attempt_lock()
 
165
        self.addCleanup(lf1.unlock)
131
166
        info2 = lf2.peek()
132
167
        self.assertTrue(info2)
133
168
        self.assertEqual(info2['nonce'], lf1.nonce)
134
169
 
135
170
    def test_30_lock_wait_fail(self):
136
171
        """Wait on a lock, then fail
137
 
        
 
172
 
138
173
        We ask to wait up to 400ms; this should fail within at most one
139
174
        second.  (Longer times are more realistic but we don't want the test
140
175
        suite to take too long, and this should do for now.)
143
178
        lf1 = LockDir(t, 'test_lock')
144
179
        lf1.create()
145
180
        lf2 = LockDir(t, 'test_lock')
 
181
        self.setup_log_reporter(lf2)
146
182
        lf1.attempt_lock()
147
183
        try:
148
184
            before = time.time()
149
185
            self.assertRaises(LockContention, lf2.wait_lock,
150
186
                              timeout=0.4, poll=0.1)
151
187
            after = time.time()
152
 
            self.assertTrue(after - before <= 1.0)
 
188
            # it should only take about 0.4 seconds, but we allow more time in
 
189
            # case the machine is heavily loaded
 
190
            self.assertTrue(after - before <= 8.0,
 
191
                    "took %f seconds to detect lock contention" % (after - before))
153
192
        finally:
154
193
            lf1.unlock()
 
194
        lock_base = lf2.transport.abspath(lf2.path)
 
195
        self.assertEqual(1, len(self._logged_reports))
 
196
        lock_url = lf2.transport.abspath(lf2.path)
 
197
        self.assertEqual('%s %s\n'
 
198
                         '%s\n%s\n'
 
199
                         'Will continue to try until %s, unless '
 
200
                         'you press Ctrl-C.\n'
 
201
                         'See "bzr help break-lock" for more.',
 
202
                         self._logged_reports[0][0])
 
203
        args = self._logged_reports[0][1]
 
204
        self.assertEqual('Unable to obtain', args[0])
 
205
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
206
        self.assertStartsWith(args[2], 'held by ')
 
207
        self.assertStartsWith(args[3], 'locked ')
 
208
        self.assertEndsWith(args[3], ' ago')
 
209
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
155
210
 
156
211
    def test_31_lock_wait_easy(self):
157
212
        """Succeed when waiting on a lock with no contention.
159
214
        t = self.get_transport()
160
215
        lf1 = LockDir(t, 'test_lock')
161
216
        lf1.create()
 
217
        self.setup_log_reporter(lf1)
162
218
        try:
163
219
            before = time.time()
164
220
            lf1.wait_lock(timeout=0.4, poll=0.1)
166
222
            self.assertTrue(after - before <= 1.0)
167
223
        finally:
168
224
            lf1.unlock()
 
225
        self.assertEqual([], self._logged_reports)
169
226
 
170
227
    def test_32_lock_wait_succeed(self):
171
228
        """Succeed when trying to acquire a lock that gets released
172
229
 
173
 
        One thread holds on a lock and then releases it; another 
 
230
        One thread holds on a lock and then releases it; another
174
231
        tries to lock it.
175
232
        """
 
233
        # This test sometimes fails like this:
 
234
        # Traceback (most recent call last):
 
235
 
 
236
        #   File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
 
237
        # test_lockdir.py", line 247, in test_32_lock_wait_succeed
 
238
        #     self.assertEqual(1, len(self._logged_reports))
 
239
        # AssertionError: not equal:
 
240
        # a = 1
 
241
        # b = 0
 
242
        raise tests.TestSkipped("Test fails intermittently")
176
243
        t = self.get_transport()
177
244
        lf1 = LockDir(t, 'test_lock')
178
245
        lf1.create()
185
252
        unlocker.start()
186
253
        try:
187
254
            lf2 = LockDir(t, 'test_lock')
 
255
            self.setup_log_reporter(lf2)
188
256
            before = time.time()
189
257
            # wait and then lock
190
258
            lf2.wait_lock(timeout=0.4, poll=0.1)
193
261
        finally:
194
262
            unlocker.join()
195
263
 
196
 
    def test_33_wait(self):
197
 
        """Succeed when waiting on a lock that gets released
 
264
        # There should be only 1 report, even though it should have to
 
265
        # wait for a while
 
266
        lock_base = lf2.transport.abspath(lf2.path)
 
267
        self.assertEqual(1, len(self._logged_reports))
 
268
        self.assertEqual('%s %s\n'
 
269
                         '%s\n%s\n'
 
270
                         'Will continue to try until %s\n',
 
271
                         self._logged_reports[0][0])
 
272
        args = self._logged_reports[0][1]
 
273
        self.assertEqual('Unable to obtain', args[0])
 
274
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
275
        self.assertStartsWith(args[2], 'held by ')
 
276
        self.assertStartsWith(args[3], 'locked ')
 
277
        self.assertEndsWith(args[3], ' ago')
 
278
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
198
279
 
199
 
        The difference from test_32_lock_wait_succeed is that the second 
200
 
        caller does not actually acquire the lock, but just waits for it
201
 
        to be released.  This is done over a readonly transport.
202
 
        """
 
280
    def test_34_lock_write_waits(self):
 
281
        """LockDir.lock_write() will wait for the lock."""
 
282
        # the test suite sets the default to 0 to make deadlocks fail fast.
 
283
        # change it for this test, as we want to try a manual deadlock.
 
284
        raise tests.TestSkipped('Timing-sensitive test')
 
285
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
203
286
        t = self.get_transport()
204
287
        lf1 = LockDir(t, 'test_lock')
205
288
        lf1.create()
211
294
        unlocker = Thread(target=wait_and_unlock)
212
295
        unlocker.start()
213
296
        try:
214
 
            lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
 
297
            lf2 = LockDir(t, 'test_lock')
 
298
            self.setup_log_reporter(lf2)
215
299
            before = time.time()
216
 
            # wait but don't lock
217
 
            lf2.wait(timeout=0.4, poll=0.1)
 
300
            # wait and then lock
 
301
            lf2.lock_write()
218
302
            after = time.time()
219
 
            self.assertTrue(after - before <= 1.0)
220
 
        finally:
221
 
            unlocker.join()
 
303
        finally:
 
304
            unlocker.join()
 
305
 
 
306
        # There should be only 1 report, even though it should have to
 
307
        # wait for a while
 
308
        lock_base = lf2.transport.abspath(lf2.path)
 
309
        self.assertEqual(1, len(self._logged_reports))
 
310
        self.assertEqual('%s %s\n'
 
311
                         '%s\n%s\n'
 
312
                         'Will continue to try until %s\n',
 
313
                         self._logged_reports[0][0])
 
314
        args = self._logged_reports[0][1]
 
315
        self.assertEqual('Unable to obtain', args[0])
 
316
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
317
        self.assertStartsWith(args[2], 'held by ')
 
318
        self.assertStartsWith(args[3], 'locked ')
 
319
        self.assertEndsWith(args[3], ' ago')
 
320
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
 
321
 
 
322
    def test_35_wait_lock_changing(self):
 
323
        """LockDir.wait_lock() will report if the lock changes underneath.
 
324
 
 
325
        This is the stages we want to happen:
 
326
 
 
327
        0) Synchronization locks are created and locked.
 
328
        1) Lock1 obtains the lockdir, and releases the 'check' lock.
 
329
        2) Lock2 grabs the 'check' lock, and checks the lockdir.
 
330
           It sees the lockdir is already acquired, reports the fact,
 
331
           and unsets the 'checked' lock.
 
332
        3) Thread1 blocks on acquiring the 'checked' lock, and then tells
 
333
           Lock1 to release and acquire the lockdir. This resets the 'check'
 
334
           lock.
 
335
        4) Lock2 acquires the 'check' lock, and checks again. It notices
 
336
           that the holder of the lock has changed, and so reports a new
 
337
           lock holder.
 
338
        5) Thread1 blocks on the 'checked' lock, this time, it completely
 
339
           unlocks the lockdir, allowing Lock2 to acquire the lock.
 
340
        """
 
341
 
 
342
        raise tests.KnownFailure(
 
343
            "timing dependency in lock tests (#213182)")
 
344
 
 
345
        wait_to_check_lock = Lock()
 
346
        wait_until_checked_lock = Lock()
 
347
 
 
348
        wait_to_check_lock.acquire()
 
349
        wait_until_checked_lock.acquire()
 
350
        note('locked check and checked locks')
 
351
 
 
352
        class LockDir1(LockDir):
 
353
            """Use the synchronization points for the first lock."""
 
354
 
 
355
            def attempt_lock(self):
 
356
                # Once we have acquired the lock, it is okay for
 
357
                # the other lock to check it
 
358
                try:
 
359
                    return super(LockDir1, self).attempt_lock()
 
360
                finally:
 
361
                    note('lock1: releasing check lock')
 
362
                    wait_to_check_lock.release()
 
363
 
 
364
        class LockDir2(LockDir):
 
365
            """Use the synchronization points for the second lock."""
 
366
 
 
367
            def attempt_lock(self):
 
368
                note('lock2: waiting for check lock')
 
369
                wait_to_check_lock.acquire()
 
370
                note('lock2: acquired check lock')
 
371
                try:
 
372
                    return super(LockDir2, self).attempt_lock()
 
373
                finally:
 
374
                    note('lock2: releasing checked lock')
 
375
                    wait_until_checked_lock.release()
 
376
 
 
377
        t = self.get_transport()
 
378
        lf1 = LockDir1(t, 'test_lock')
 
379
        lf1.create()
 
380
 
 
381
        lf2 = LockDir2(t, 'test_lock')
 
382
        self.setup_log_reporter(lf2)
 
383
 
 
384
        def wait_and_switch():
 
385
            lf1.attempt_lock()
 
386
            # Block until lock2 has had a chance to check
 
387
            note('lock1: waiting 1 for checked lock')
 
388
            wait_until_checked_lock.acquire()
 
389
            note('lock1: acquired for checked lock')
 
390
            note('lock1: released lockdir')
 
391
            lf1.unlock()
 
392
            note('lock1: acquiring lockdir')
 
393
            # Create a new nonce, so the lock looks different.
 
394
            lf1.nonce = osutils.rand_chars(20)
 
395
            lf1.lock_write()
 
396
            note('lock1: acquired lockdir')
 
397
 
 
398
            # Block until lock2 has peeked again
 
399
            note('lock1: waiting 2 for checked lock')
 
400
            wait_until_checked_lock.acquire()
 
401
            note('lock1: acquired for checked lock')
 
402
            # Now unlock, and let lock 2 grab the lock
 
403
            lf1.unlock()
 
404
            wait_to_check_lock.release()
 
405
 
 
406
        unlocker = Thread(target=wait_and_switch)
 
407
        unlocker.start()
 
408
        try:
 
409
            # Wait and play against the other thread
 
410
            lf2.wait_lock(timeout=20.0, poll=0.01)
 
411
        finally:
 
412
            unlocker.join()
 
413
        lf2.unlock()
 
414
 
 
415
        # There should be 2 reports, because the lock changed
 
416
        lock_base = lf2.transport.abspath(lf2.path)
 
417
        self.assertEqual(2, len(self._logged_reports))
 
418
        lock_url = lf2.transport.abspath(lf2.path)
 
419
        self.assertEqual('%s %s\n'
 
420
                         '%s\n%s\n'
 
421
                         'Will continue to try until %s, unless '
 
422
                         'you press Ctrl-C.\n'
 
423
                         'See "bzr help break-lock" for more.',
 
424
                         self._logged_reports[0][0])
 
425
        args = self._logged_reports[0][1]
 
426
        self.assertEqual('Unable to obtain', args[0])
 
427
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
428
        self.assertStartsWith(args[2], 'held by ')
 
429
        self.assertStartsWith(args[3], 'locked ')
 
430
        self.assertEndsWith(args[3], ' ago')
 
431
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
 
432
 
 
433
        self.assertEqual('%s %s\n'
 
434
                         '%s\n%s\n'
 
435
                         'Will continue to try until %s, unless '
 
436
                         'you press Ctrl-C.\n'
 
437
                         'See "bzr help break-lock" for more.',
 
438
                         self._logged_reports[1][0])
 
439
        args = self._logged_reports[1][1]
 
440
        self.assertEqual('Lock owner changed for', args[0])
 
441
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
442
        self.assertStartsWith(args[2], 'held by ')
 
443
        self.assertStartsWith(args[3], 'locked ')
 
444
        self.assertEndsWith(args[3], ' ago')
 
445
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
222
446
 
223
447
    def test_40_confirm_easy(self):
224
448
        """Confirm a lock that's already held"""
226
450
        lf1 = LockDir(t, 'test_lock')
227
451
        lf1.create()
228
452
        lf1.attempt_lock()
 
453
        self.addCleanup(lf1.unlock)
229
454
        lf1.confirm()
230
455
 
231
456
    def test_41_confirm_not_held(self):
243
468
        lf1.attempt_lock()
244
469
        t.move('test_lock', 'lock_gone_now')
245
470
        self.assertRaises(LockBroken, lf1.confirm)
 
471
        # Clean up
 
472
        t.move('lock_gone_now', 'test_lock')
 
473
        lf1.unlock()
246
474
 
247
475
    def test_43_break(self):
248
476
        """Break a lock whose caller has forgotten it"""
259
487
        lf2.force_break(holder_info)
260
488
        # now we should be able to take it
261
489
        lf2.attempt_lock()
 
490
        self.addCleanup(lf2.unlock)
262
491
        lf2.confirm()
263
492
 
264
493
    def test_44_break_already_released(self):
276
505
        lf2.force_break(holder_info)
277
506
        # now we should be able to take it
278
507
        lf2.attempt_lock()
 
508
        self.addCleanup(lf2.unlock)
279
509
        lf2.confirm()
280
510
 
281
511
    def test_45_break_mismatch(self):
307
537
        """Check the on-disk representation of LockDirs is as expected.
308
538
 
309
539
        There should always be a top-level directory named by the lock.
310
 
        When the lock is held, there should be a lockname/held directory 
 
540
        When the lock is held, there should be a lockname/held directory
311
541
        containing an info file.
312
542
        """
313
543
        t = self.get_transport()
318
548
        self.assertTrue(t.has('test_lock/held/info'))
319
549
        lf1.unlock()
320
550
        self.assertFalse(t.has('test_lock/held/info'))
 
551
 
 
552
    def test_break_lock(self):
 
553
        # the ui based break_lock routine should Just Work (tm)
 
554
        ld1 = self.get_lock()
 
555
        ld2 = self.get_lock()
 
556
        ld1.create()
 
557
        ld1.lock_write()
 
558
        # do this without IO redirection to ensure it doesn't prompt.
 
559
        self.assertRaises(AssertionError, ld1.break_lock)
 
560
        orig_factory = bzrlib.ui.ui_factory
 
561
        bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
 
562
        try:
 
563
            ld2.break_lock()
 
564
            self.assertRaises(LockBroken, ld1.unlock)
 
565
        finally:
 
566
            bzrlib.ui.ui_factory = orig_factory
 
567
 
 
568
    def test_create_missing_base_directory(self):
 
569
        """If LockDir.path doesn't exist, it can be created
 
570
 
 
571
        Some people manually remove the entire lock/ directory trying
 
572
        to unlock a stuck repository/branch/etc. Rather than failing
 
573
        after that, just create the lock directory when needed.
 
574
        """
 
575
        t = self.get_transport()
 
576
        lf1 = LockDir(t, 'test_lock')
 
577
 
 
578
        lf1.create()
 
579
        self.failUnless(t.has('test_lock'))
 
580
 
 
581
        t.rmdir('test_lock')
 
582
        self.failIf(t.has('test_lock'))
 
583
 
 
584
        # This will create 'test_lock' if it needs to
 
585
        lf1.lock_write()
 
586
        self.failUnless(t.has('test_lock'))
 
587
        self.failUnless(t.has('test_lock/held/info'))
 
588
 
 
589
        lf1.unlock()
 
590
        self.failIf(t.has('test_lock/held/info'))
 
591
 
 
592
    def test__format_lock_info(self):
 
593
        ld1 = self.get_lock()
 
594
        ld1.create()
 
595
        ld1.lock_write()
 
596
        try:
 
597
            info_list = ld1._format_lock_info(ld1.peek())
 
598
        finally:
 
599
            ld1.unlock()
 
600
        self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
 
601
                         info_list[0])
 
602
        self.assertContainsRe(info_list[1],
 
603
                              r'^held by .* on host .* \[process #\d*\]$')
 
604
        self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
 
605
 
 
606
    def test_lock_without_email(self):
 
607
        global_config = config.GlobalConfig()
 
608
        # Intentionally has no email address
 
609
        global_config.set_user_option('email', 'User Identity')
 
610
        ld1 = self.get_lock()
 
611
        ld1.create()
 
612
        ld1.lock_write()
 
613
        ld1.unlock()
 
614
 
 
615
    def test_lock_permission(self):
 
616
        if not osutils.supports_posix_readonly():
 
617
            raise tests.TestSkipped('Cannot induce a permission failure')
 
618
        ld1 = self.get_lock()
 
619
        lock_path = ld1.transport.local_abspath('test_lock')
 
620
        os.mkdir(lock_path)
 
621
        osutils.make_readonly(lock_path)
 
622
        self.assertRaises(errors.LockFailed, ld1.attempt_lock)
 
623
 
 
624
    def test_lock_by_token(self):
 
625
        ld1 = self.get_lock()
 
626
        token = ld1.lock_write()
 
627
        self.addCleanup(ld1.unlock)
 
628
        self.assertNotEqual(None, token)
 
629
        ld2 = self.get_lock()
 
630
        t2 = ld2.lock_write(token)
 
631
        self.addCleanup(ld2.unlock)
 
632
        self.assertEqual(token, t2)
 
633
 
 
634
    def test_lock_with_buggy_rename(self):
 
635
        # test that lock acquisition handles servers which pretend they
 
636
        # renamed correctly but that actually fail
 
637
        t = transport.get_transport('brokenrename+' + self.get_url())
 
638
        ld1 = LockDir(t, 'test_lock')
 
639
        ld1.create()
 
640
        ld1.attempt_lock()
 
641
        ld2 = LockDir(t, 'test_lock')
 
642
        # we should fail to lock
 
643
        e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
 
644
        # now the original caller should succeed in unlocking
 
645
        ld1.unlock()
 
646
        # and there should be nothing left over
 
647
        self.assertEquals([], t.list_dir('test_lock'))
 
648
 
 
649
    def test_failed_lock_leaves_no_trash(self):
 
650
        # if we fail to acquire the lock, we don't leave pending directories
 
651
        # behind -- https://bugs.launchpad.net/bzr/+bug/109169
 
652
        ld1 = self.get_lock()
 
653
        ld2 = self.get_lock()
 
654
        # should be nothing before we start
 
655
        ld1.create()
 
656
        t = self.get_transport().clone('test_lock')
 
657
        def check_dir(a):
 
658
            self.assertEquals(a, t.list_dir('.'))
 
659
        check_dir([])
 
660
        # when held, that's all we see
 
661
        ld1.attempt_lock()
 
662
        self.addCleanup(ld1.unlock)
 
663
        check_dir(['held'])
 
664
        # second guy should fail
 
665
        self.assertRaises(errors.LockContention, ld2.attempt_lock)
 
666
        # no kibble
 
667
        check_dir(['held'])
 
668
 
 
669
    def test_no_lockdir_info(self):
 
670
        """We can cope with empty info files."""
 
671
        # This seems like a fairly common failure case - see
 
672
        # <https://bugs.launchpad.net/bzr/+bug/185103> and all its dupes.
 
673
        # Processes are often interrupted after opening the file
 
674
        # before the actual contents are committed.
 
675
        t = self.get_transport()
 
676
        t.mkdir('test_lock')
 
677
        t.mkdir('test_lock/held')
 
678
        t.put_bytes('test_lock/held/info', '')
 
679
        lf = LockDir(t, 'test_lock')
 
680
        info = lf.peek()
 
681
        formatted_info = lf._format_lock_info(info)
 
682
        self.assertEquals(
 
683
            ['lock %s' % t.abspath('test_lock'),
 
684
             'held by <unknown> on host <unknown> [process #<unknown>]',
 
685
             'locked (unknown)'],
 
686
            formatted_info)
 
687
 
 
688
 
 
689
class TestLockDirHooks(TestCaseWithTransport):
 
690
 
 
691
    def setUp(self):
 
692
        super(TestLockDirHooks, self).setUp()
 
693
        self._calls = []
 
694
 
 
695
    def get_lock(self):
 
696
        return LockDir(self.get_transport(), 'test_lock')
 
697
 
 
698
    def record_hook(self, result):
 
699
        self._calls.append(result)
 
700
 
 
701
    def test_LockDir_acquired_success(self):
 
702
        # the LockDir.lock_acquired hook fires when a lock is acquired.
 
703
        LockDir.hooks.install_named_hook('lock_acquired',
 
704
                                         self.record_hook, 'record_hook')
 
705
        ld = self.get_lock()
 
706
        ld.create()
 
707
        self.assertEqual([], self._calls)
 
708
        result = ld.attempt_lock()
 
709
        lock_path = ld.transport.abspath(ld.path)
 
710
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
711
        ld.unlock()
 
712
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
713
 
 
714
    def test_LockDir_acquired_fail(self):
 
715
        # the LockDir.lock_acquired hook does not fire on failure.
 
716
        ld = self.get_lock()
 
717
        ld.create()
 
718
        ld2 = self.get_lock()
 
719
        ld2.attempt_lock()
 
720
        # install a lock hook now, when the disk lock is locked
 
721
        LockDir.hooks.install_named_hook('lock_acquired',
 
722
                                         self.record_hook, 'record_hook')
 
723
        self.assertRaises(errors.LockContention, ld.attempt_lock)
 
724
        self.assertEqual([], self._calls)
 
725
        ld2.unlock()
 
726
        self.assertEqual([], self._calls)
 
727
 
 
728
    def test_LockDir_released_success(self):
 
729
        # the LockDir.lock_released hook fires when a lock is acquired.
 
730
        LockDir.hooks.install_named_hook('lock_released',
 
731
                                         self.record_hook, 'record_hook')
 
732
        ld = self.get_lock()
 
733
        ld.create()
 
734
        self.assertEqual([], self._calls)
 
735
        result = ld.attempt_lock()
 
736
        self.assertEqual([], self._calls)
 
737
        ld.unlock()
 
738
        lock_path = ld.transport.abspath(ld.path)
 
739
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
740
 
 
741
    def test_LockDir_released_fail(self):
 
742
        # the LockDir.lock_released hook does not fire on failure.
 
743
        ld = self.get_lock()
 
744
        ld.create()
 
745
        ld2 = self.get_lock()
 
746
        ld.attempt_lock()
 
747
        ld2.force_break(ld2.peek())
 
748
        LockDir.hooks.install_named_hook('lock_released',
 
749
                                         self.record_hook, 'record_hook')
 
750
        self.assertRaises(LockBroken, ld.unlock)
 
751
        self.assertEqual([], self._calls)
 
752
 
 
753
    def test_LockDir_broken_success(self):
 
754
        # the LockDir.lock_broken hook fires when a lock is broken.
 
755
        ld = self.get_lock()
 
756
        ld.create()
 
757
        ld2 = self.get_lock()
 
758
        result = ld.attempt_lock()
 
759
        LockDir.hooks.install_named_hook('lock_broken',
 
760
                                         self.record_hook, 'record_hook')
 
761
        ld2.force_break(ld2.peek())
 
762
        lock_path = ld.transport.abspath(ld.path)
 
763
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
764
 
 
765
    def test_LockDir_broken_failure(self):
 
766
        # the LockDir.lock_broken hook does not fires when a lock is already
 
767
        # released.
 
768
        ld = self.get_lock()
 
769
        ld.create()
 
770
        ld2 = self.get_lock()
 
771
        result = ld.attempt_lock()
 
772
        holder_info = ld2.peek()
 
773
        ld.unlock()
 
774
        LockDir.hooks.install_named_hook('lock_broken',
 
775
                                         self.record_hook, 'record_hook')
 
776
        ld2.force_break(holder_info)
 
777
        lock_path = ld.transport.abspath(ld.path)
 
778
        self.assertEqual([], self._calls)