~bzr-pqm/bzr/bzr.dev

5557.1.15 by John Arbash Meinel
Merge bzr.dev 5597 to resolve NEWS, aka bzr-2.3.txt
1
# Copyright (C) 2006-2011 Canonical Ltd
1887.1.1 by Adeodato Simó
Do not separate paragraphs in the copyright statement with blank lines,
2
#
1553.5.12 by Martin Pool
New LockDir locking mechanism
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
1887.1.1 by Adeodato Simó
Do not separate paragraphs in the copyright statement with blank lines,
7
#
1553.5.12 by Martin Pool
New LockDir locking mechanism
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
# GNU General Public License for more details.
1887.1.1 by Adeodato Simó
Do not separate paragraphs in the copyright statement with blank lines,
12
#
1553.5.12 by Martin Pool
New LockDir locking mechanism
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
4183.7.1 by Sabin Iacob
update FSF mailing address
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
1553.5.12 by Martin Pool
New LockDir locking mechanism
16
17
"""Tests for LockDir"""
18
1551.10.3 by Aaron Bentley
Lock attempts don't treat permission problems as lock contention
19
import os
1553.5.12 by Martin Pool
New LockDir locking mechanism
20
import time
21
1687.1.5 by Robert Collins
Add break_lock utility function to LockDir.
22
import bzrlib
1957.1.7 by John Arbash Meinel
Add the ability to report if the lock changes from underneath you
23
from bzrlib import (
2055.2.1 by John Arbash Meinel
Make LockDir less sensitive to invalid configuration of email
24
    config,
1551.10.3 by Aaron Bentley
Lock attempts don't treat permission problems as lock contention
25
    errors,
3331.3.13 by Martin Pool
Fix up imports
26
    lock,
5425.4.9 by Martin Pool
Defensively handle 'localhost' in detecting dead locks
27
    lockdir,
1957.1.7 by John Arbash Meinel
Add the ability to report if the lock changes from underneath you
28
    osutils,
1551.10.4 by Aaron Bentley
Update to skip on win32
29
    tests,
2555.3.9 by Martin Pool
Add test and fix for locking robustly when rename of directories doesn't act as a mutex (thank John)
30
    transport,
1957.1.7 by John Arbash Meinel
Add the ability to report if the lock changes from underneath you
31
    )
1553.5.27 by Martin Pool
Confirm that only the intended holder of a lock was broken.
32
from bzrlib.errors import (
2872.5.1 by Martin Pool
Avoid internal error tracebacks on failure to lock on readonly transport (#129701).
33
    LockBreakMismatch,
34
    LockBroken,
35
    LockContention,
36
    LockFailed,
37
    LockNotHeld,
38
    )
5425.4.6 by Martin Pool
Move preparation of new locks into LockHeldInfo
39
from bzrlib.lockdir import (
40
    LockDir,
41
    LockHeldInfo,
42
    )
5579.3.1 by Jelmer Vernooij
Remove unused imports.
43
from bzrlib.tests import (
44
    features,
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
45
    TestCase,
6362.2.5 by Martin Packman
Tweaks including those suggested by vila in review
46
    TestCaseInTempDir,
5579.3.1 by Jelmer Vernooij
Remove unused imports.
47
    TestCaseWithTransport,
48
    )
1553.5.12 by Martin Pool
New LockDir locking mechanism
49
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
50
# These tests are run on the default transport provided by the test framework
51
# (typically a local disk transport).  That can be changed by the --transport
52
# option to bzr selftest.  The required properties of the transport
53
# implementation are tested separately.  (The main requirement is just that
54
# they don't allow overwriting nonempty directories.)
55
5425.4.27 by Martin Pool
pep8 cleanups
56
1553.5.12 by Martin Pool
New LockDir locking mechanism
57
class TestLockDir(TestCaseWithTransport):
58
    """Test LockDir operations"""
59
1957.1.1 by John Arbash Meinel
Report to the user when we are spinning on a lock
60
    def logging_report_function(self, fmt, *args):
61
        self._logged_reports.append((fmt, args))
62
63
    def setup_log_reporter(self, lock_dir):
64
        self._logged_reports = []
65
        lock_dir._report_function = self.logging_report_function
66
1553.5.12 by Martin Pool
New LockDir locking mechanism
67
    def test_00_lock_creation(self):
68
        """Creation of lock file on a transport"""
69
        t = self.get_transport()
70
        lf = LockDir(t, 'test_lock')
1553.5.13 by Martin Pool
New Transport.rename that mustn't overwrite
71
        self.assertFalse(lf.is_held)
1553.5.12 by Martin Pool
New LockDir locking mechanism
72
73
    def test_01_lock_repr(self):
74
        """Lock string representation"""
75
        lf = LockDir(self.get_transport(), 'test_lock')
76
        r = repr(lf)
77
        self.assertContainsRe(r, r'^LockDir\(.*/test_lock\)$')
78
79
    def test_02_unlocked_peek(self):
80
        lf = LockDir(self.get_transport(), 'test_lock')
81
        self.assertEqual(lf.peek(), None)
82
1687.1.3 by Robert Collins
Make LockDir.unlock check the lock is still intact.
83
    def get_lock(self):
84
        return LockDir(self.get_transport(), 'test_lock')
85
86
    def test_unlock_after_break_raises(self):
87
        ld = self.get_lock()
88
        ld2 = self.get_lock()
89
        ld.create()
90
        ld.attempt_lock()
91
        ld2.force_break(ld2.peek())
92
        self.assertRaises(LockBroken, ld.unlock)
93
1553.5.12 by Martin Pool
New LockDir locking mechanism
94
    def test_03_readonly_peek(self):
95
        lf = LockDir(self.get_readonly_transport(), 'test_lock')
96
        self.assertEqual(lf.peek(), None)
97
98
    def test_10_lock_uncontested(self):
99
        """Acquire and release a lock"""
100
        t = self.get_transport()
101
        lf = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
102
        lf.create()
1553.5.12 by Martin Pool
New LockDir locking mechanism
103
        lf.attempt_lock()
104
        try:
1553.5.13 by Martin Pool
New Transport.rename that mustn't overwrite
105
            self.assertTrue(lf.is_held)
1553.5.12 by Martin Pool
New LockDir locking mechanism
106
        finally:
107
            lf.unlock()
1553.5.13 by Martin Pool
New Transport.rename that mustn't overwrite
108
            self.assertFalse(lf.is_held)
1553.5.12 by Martin Pool
New LockDir locking mechanism
109
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
110
    def test_11_create_readonly_transport(self):
111
        """Fail to create lock on readonly transport"""
112
        t = self.get_readonly_transport()
113
        lf = LockDir(t, 'test_lock')
2872.5.1 by Martin Pool
Avoid internal error tracebacks on failure to lock on readonly transport (#129701).
114
        self.assertRaises(LockFailed, lf.create)
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
115
116
    def test_12_lock_readonly_transport(self):
1553.5.12 by Martin Pool
New LockDir locking mechanism
117
        """Fail to lock on readonly transport"""
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
118
        lf = LockDir(self.get_transport(), 'test_lock')
119
        lf.create()
120
        lf = LockDir(self.get_readonly_transport(), 'test_lock')
2872.5.1 by Martin Pool
Avoid internal error tracebacks on failure to lock on readonly transport (#129701).
121
        self.assertRaises(LockFailed, lf.attempt_lock)
1553.5.12 by Martin Pool
New LockDir locking mechanism
122
123
    def test_20_lock_contested(self):
124
        """Contention to get a lock"""
125
        t = self.get_transport()
126
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
127
        lf1.create()
1553.5.12 by Martin Pool
New LockDir locking mechanism
128
        lf1.attempt_lock()
129
        lf2 = LockDir(t, 'test_lock')
130
        try:
3943.8.1 by Marius Kruger
remove all trailing whitespace from bzr source
131
            # locking is between LockDir instances; aliases within
1553.5.12 by Martin Pool
New LockDir locking mechanism
132
            # a single process are not detected
133
            lf2.attempt_lock()
134
            self.fail('Failed to detect lock collision')
135
        except LockContention, e:
136
            self.assertEqual(e.lock, lf2)
137
            self.assertContainsRe(str(e),
138
                    r'^Could not acquire.*test_lock.*$')
139
        lf1.unlock()
140
141
    def test_20_lock_peek(self):
142
        """Peek at the state of a lock"""
143
        t = self.get_transport()
144
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
145
        lf1.create()
1553.5.12 by Martin Pool
New LockDir locking mechanism
146
        lf1.attempt_lock()
4327.1.1 by Vincent Ladeuil
Start addressing test failing when run with -Dlock.
147
        self.addCleanup(lf1.unlock)
1553.5.12 by Martin Pool
New LockDir locking mechanism
148
        # lock is held, should get some info on it
149
        info1 = lf1.peek()
5425.4.3 by Martin Pool
Represent lock held info as an object, not just a dict
150
        self.assertEqual(set(info1.info_dict.keys()),
5425.4.27 by Martin Pool
pep8 cleanups
151
            set(['user', 'nonce', 'hostname', 'pid', 'start_time']))
1553.5.12 by Martin Pool
New LockDir locking mechanism
152
        # should get the same info if we look at it through a different
153
        # instance
154
        info2 = LockDir(t, 'test_lock').peek()
155
        self.assertEqual(info1, info2)
156
        # locks which are never used should be not-held
157
        self.assertEqual(LockDir(t, 'other_lock').peek(), None)
158
159
    def test_21_peek_readonly(self):
160
        """Peek over a readonly transport"""
161
        t = self.get_transport()
162
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
163
        lf1.create()
1553.5.12 by Martin Pool
New LockDir locking mechanism
164
        lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
165
        self.assertEqual(lf2.peek(), None)
166
        lf1.attempt_lock()
4327.1.1 by Vincent Ladeuil
Start addressing test failing when run with -Dlock.
167
        self.addCleanup(lf1.unlock)
1553.5.12 by Martin Pool
New LockDir locking mechanism
168
        info2 = lf2.peek()
169
        self.assertTrue(info2)
5425.4.3 by Martin Pool
Represent lock held info as an object, not just a dict
170
        self.assertEqual(info2.get('nonce'), lf1.nonce)
1553.5.12 by Martin Pool
New LockDir locking mechanism
171
172
    def test_30_lock_wait_fail(self):
173
        """Wait on a lock, then fail
3943.8.1 by Marius Kruger
remove all trailing whitespace from bzr source
174
1553.5.12 by Martin Pool
New LockDir locking mechanism
175
        We ask to wait up to 400ms; this should fail within at most one
176
        second.  (Longer times are more realistic but we don't want the test
177
        suite to take too long, and this should do for now.)
178
        """
179
        t = self.get_transport()
180
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
181
        lf1.create()
1553.5.12 by Martin Pool
New LockDir locking mechanism
182
        lf2 = LockDir(t, 'test_lock')
1957.1.1 by John Arbash Meinel
Report to the user when we are spinning on a lock
183
        self.setup_log_reporter(lf2)
1553.5.12 by Martin Pool
New LockDir locking mechanism
184
        lf1.attempt_lock()
185
        try:
186
            before = time.time()
187
            self.assertRaises(LockContention, lf2.wait_lock,
188
                              timeout=0.4, poll=0.1)
189
            after = time.time()
1704.2.1 by Martin Pool
Fix time-dependency in LockDir tests -- allow more margin for error in time to detect lock contention
190
            # it should only take about 0.4 seconds, but we allow more time in
191
            # case the machine is heavily loaded
3943.8.1 by Marius Kruger
remove all trailing whitespace from bzr source
192
            self.assertTrue(after - before <= 8.0,
5425.4.27 by Martin Pool
pep8 cleanups
193
                "took %f seconds to detect lock contention" % (after - before))
1553.5.12 by Martin Pool
New LockDir locking mechanism
194
        finally:
195
            lf1.unlock()
1957.1.7 by John Arbash Meinel
Add the ability to report if the lock changes from underneath you
196
        self.assertEqual(1, len(self._logged_reports))
5425.4.18 by Martin Pool
Cleaner and consistent user-orientend representation of LockHeldInfo
197
        self.assertContainsRe(self._logged_reports[0][0],
198
            r'Unable to obtain lock .* held by jrandom@example\.com on .*'
199
            r' \(process #\d+\), acquired .* ago\.\n'
200
            r'Will continue to try until \d{2}:\d{2}:\d{2}, unless '
201
            r'you press Ctrl-C.\n'
202
            r'See "bzr help break-lock" for more.')
1553.5.12 by Martin Pool
New LockDir locking mechanism
203
204
    def test_31_lock_wait_easy(self):
205
        """Succeed when waiting on a lock with no contention.
206
        """
207
        t = self.get_transport()
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
208
        lf1 = LockDir(t, 'test_lock')
209
        lf1.create()
1957.1.1 by John Arbash Meinel
Report to the user when we are spinning on a lock
210
        self.setup_log_reporter(lf1)
1553.5.12 by Martin Pool
New LockDir locking mechanism
211
        try:
212
            before = time.time()
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
213
            lf1.wait_lock(timeout=0.4, poll=0.1)
1553.5.12 by Martin Pool
New LockDir locking mechanism
214
            after = time.time()
215
            self.assertTrue(after - before <= 1.0)
216
        finally:
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
217
            lf1.unlock()
1957.1.1 by John Arbash Meinel
Report to the user when we are spinning on a lock
218
        self.assertEqual([], self._logged_reports)
1553.5.12 by Martin Pool
New LockDir locking mechanism
219
1553.5.20 by Martin Pool
Start adding LockDir.confirm() method
220
    def test_40_confirm_easy(self):
221
        """Confirm a lock that's already held"""
222
        t = self.get_transport()
223
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
224
        lf1.create()
1553.5.20 by Martin Pool
Start adding LockDir.confirm() method
225
        lf1.attempt_lock()
4327.1.1 by Vincent Ladeuil
Start addressing test failing when run with -Dlock.
226
        self.addCleanup(lf1.unlock)
1553.5.20 by Martin Pool
Start adding LockDir.confirm() method
227
        lf1.confirm()
228
229
    def test_41_confirm_not_held(self):
230
        """Confirm a lock that's already held"""
231
        t = self.get_transport()
232
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
233
        lf1.create()
1553.5.20 by Martin Pool
Start adding LockDir.confirm() method
234
        self.assertRaises(LockNotHeld, lf1.confirm)
1553.5.23 by Martin Pool
Start LockDir.confirm method and LockBroken exception
235
236
    def test_42_confirm_broken_manually(self):
237
        """Confirm a lock broken by hand"""
238
        t = self.get_transport()
239
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
240
        lf1.create()
1553.5.23 by Martin Pool
Start LockDir.confirm method and LockBroken exception
241
        lf1.attempt_lock()
242
        t.move('test_lock', 'lock_gone_now')
243
        self.assertRaises(LockBroken, lf1.confirm)
4327.1.1 by Vincent Ladeuil
Start addressing test failing when run with -Dlock.
244
        # Clean up
245
        t.move('lock_gone_now', 'test_lock')
246
        lf1.unlock()
1553.5.25 by Martin Pool
New LockDir.force_break and simple test case
247
248
    def test_43_break(self):
249
        """Break a lock whose caller has forgotten it"""
250
        t = self.get_transport()
251
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
252
        lf1.create()
1553.5.25 by Martin Pool
New LockDir.force_break and simple test case
253
        lf1.attempt_lock()
254
        # we incorrectly discard the lock object without unlocking it
255
        del lf1
256
        # someone else sees it's still locked
257
        lf2 = LockDir(t, 'test_lock')
1553.5.27 by Martin Pool
Confirm that only the intended holder of a lock was broken.
258
        holder_info = lf2.peek()
259
        self.assertTrue(holder_info)
260
        lf2.force_break(holder_info)
1553.5.25 by Martin Pool
New LockDir.force_break and simple test case
261
        # now we should be able to take it
262
        lf2.attempt_lock()
4327.1.4 by Vincent Ladeuil
Fix lock test failures by taking lock breaking into account.
263
        self.addCleanup(lf2.unlock)
1553.5.25 by Martin Pool
New LockDir.force_break and simple test case
264
        lf2.confirm()
1553.5.26 by Martin Pool
Breaking an already-released lock should just succeed
265
266
    def test_44_break_already_released(self):
267
        """Lock break races with regular release"""
268
        t = self.get_transport()
269
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
270
        lf1.create()
1553.5.26 by Martin Pool
Breaking an already-released lock should just succeed
271
        lf1.attempt_lock()
272
        # someone else sees it's still locked
273
        lf2 = LockDir(t, 'test_lock')
274
        holder_info = lf2.peek()
275
        # in the interim the lock is released
276
        lf1.unlock()
277
        # break should succeed
1553.5.27 by Martin Pool
Confirm that only the intended holder of a lock was broken.
278
        lf2.force_break(holder_info)
1553.5.26 by Martin Pool
Breaking an already-released lock should just succeed
279
        # now we should be able to take it
280
        lf2.attempt_lock()
4327.1.1 by Vincent Ladeuil
Start addressing test failing when run with -Dlock.
281
        self.addCleanup(lf2.unlock)
1553.5.26 by Martin Pool
Breaking an already-released lock should just succeed
282
        lf2.confirm()
283
1553.5.27 by Martin Pool
Confirm that only the intended holder of a lock was broken.
284
    def test_45_break_mismatch(self):
285
        """Lock break races with someone else acquiring it"""
286
        t = self.get_transport()
287
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
288
        lf1.create()
1553.5.27 by Martin Pool
Confirm that only the intended holder of a lock was broken.
289
        lf1.attempt_lock()
290
        # someone else sees it's still locked
291
        lf2 = LockDir(t, 'test_lock')
292
        holder_info = lf2.peek()
293
        # in the interim the lock is released
294
        lf1.unlock()
295
        lf3 = LockDir(t, 'test_lock')
296
        lf3.attempt_lock()
297
        # break should now *fail*
298
        self.assertRaises(LockBreakMismatch, lf2.force_break,
299
                          holder_info)
300
        lf3.unlock()
1553.5.54 by Martin Pool
Add LockDir.read_lock fake method
301
302
    def test_46_fake_read_lock(self):
303
        t = self.get_transport()
304
        lf1 = LockDir(t, 'test_lock')
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
305
        lf1.create()
1553.5.54 by Martin Pool
Add LockDir.read_lock fake method
306
        lf1.lock_read()
307
        lf1.unlock()
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
308
309
    def test_50_lockdir_representation(self):
310
        """Check the on-disk representation of LockDirs is as expected.
311
312
        There should always be a top-level directory named by the lock.
3943.8.1 by Marius Kruger
remove all trailing whitespace from bzr source
313
        When the lock is held, there should be a lockname/held directory
1553.5.58 by Martin Pool
Change LockDirs to format "lock-name/held/info"
314
        containing an info file.
315
        """
316
        t = self.get_transport()
317
        lf1 = LockDir(t, 'test_lock')
318
        lf1.create()
319
        self.assertTrue(t.has('test_lock'))
320
        lf1.lock_write()
321
        self.assertTrue(t.has('test_lock/held/info'))
322
        lf1.unlock()
323
        self.assertFalse(t.has('test_lock/held/info'))
1687.1.5 by Robert Collins
Add break_lock utility function to LockDir.
324
325
    def test_break_lock(self):
326
        # the ui based break_lock routine should Just Work (tm)
327
        ld1 = self.get_lock()
328
        ld2 = self.get_lock()
329
        ld1.create()
330
        ld1.lock_write()
1687.1.6 by Robert Collins
Extend LockableFiles to support break_lock() calls.
331
        # do this without IO redirection to ensure it doesn't prompt.
332
        self.assertRaises(AssertionError, ld1.break_lock)
1687.1.5 by Robert Collins
Add break_lock utility function to LockDir.
333
        orig_factory = bzrlib.ui.ui_factory
4449.3.27 by Martin Pool
More test updates to use CannedInputUIFactory
334
        bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
1687.1.5 by Robert Collins
Add break_lock utility function to LockDir.
335
        try:
336
            ld2.break_lock()
337
            self.assertRaises(LockBroken, ld1.unlock)
338
        finally:
339
            bzrlib.ui.ui_factory = orig_factory
1955.1.1 by John Arbash Meinel
LockDir can create the root directory if it fails to create a pending directory due to NoSuchFile.
340
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
341
    def test_break_lock_corrupt_info(self):
342
        """break_lock works even if the info file is corrupt (and tells the UI
343
        that it is corrupt).
344
        """
345
        ld = self.get_lock()
346
        ld2 = self.get_lock()
347
        ld.create()
348
        ld.lock_write()
349
        ld.transport.put_bytes_non_atomic('test_lock/held/info', '\0')
5425.4.27 by Martin Pool
pep8 cleanups
350
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
351
        class LoggingUIFactory(bzrlib.ui.SilentUIFactory):
352
            def __init__(self):
353
                self.prompts = []
5425.4.27 by Martin Pool
pep8 cleanups
354
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
355
            def get_boolean(self, prompt):
356
                self.prompts.append(('boolean', prompt))
357
                return True
5425.4.27 by Martin Pool
pep8 cleanups
358
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
359
        ui = LoggingUIFactory()
5599.2.1 by John Arbash Meinel
Fix breaking corrupt lock files on Windows.
360
        self.overrideAttr(bzrlib.ui, 'ui_factory', ui)
361
        ld2.break_lock()
362
        self.assertLength(1, ui.prompts)
363
        self.assertEqual('boolean', ui.prompts[0][0])
364
        self.assertStartsWith(ui.prompts[0][1], 'Break (corrupt LockDir')
365
        self.assertRaises(LockBroken, ld.unlock)
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
366
367
    def test_break_lock_missing_info(self):
368
        """break_lock works even if the info file is missing (and tells the UI
369
        that it is corrupt).
370
        """
371
        ld = self.get_lock()
372
        ld2 = self.get_lock()
373
        ld.create()
374
        ld.lock_write()
375
        ld.transport.delete('test_lock/held/info')
5425.4.27 by Martin Pool
pep8 cleanups
376
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
377
        class LoggingUIFactory(bzrlib.ui.SilentUIFactory):
378
            def __init__(self):
379
                self.prompts = []
5425.4.27 by Martin Pool
pep8 cleanups
380
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
381
            def get_boolean(self, prompt):
382
                self.prompts.append(('boolean', prompt))
383
                return True
5425.4.27 by Martin Pool
pep8 cleanups
384
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
385
        ui = LoggingUIFactory()
386
        orig_factory = bzrlib.ui.ui_factory
387
        bzrlib.ui.ui_factory = ui
388
        try:
389
            ld2.break_lock()
390
            self.assertRaises(LockBroken, ld.unlock)
391
            self.assertLength(0, ui.prompts)
392
        finally:
393
            bzrlib.ui.ui_factory = orig_factory
394
        # Suppress warnings due to ld not being unlocked
395
        # XXX: if lock_broken hook was invoked in this case, this hack would
396
        # not be necessary.  - Andrew Bennetts, 2010-09-06.
397
        del self._lock_actions[:]
398
1955.1.1 by John Arbash Meinel
LockDir can create the root directory if it fails to create a pending directory due to NoSuchFile.
399
    def test_create_missing_base_directory(self):
400
        """If LockDir.path doesn't exist, it can be created
401
402
        Some people manually remove the entire lock/ directory trying
403
        to unlock a stuck repository/branch/etc. Rather than failing
404
        after that, just create the lock directory when needed.
405
        """
406
        t = self.get_transport()
407
        lf1 = LockDir(t, 'test_lock')
408
409
        lf1.create()
5784.1.1 by Martin Pool
Stop using failIf, failUnless, etc
410
        self.assertTrue(t.has('test_lock'))
1955.1.1 by John Arbash Meinel
LockDir can create the root directory if it fails to create a pending directory due to NoSuchFile.
411
412
        t.rmdir('test_lock')
5784.1.1 by Martin Pool
Stop using failIf, failUnless, etc
413
        self.assertFalse(t.has('test_lock'))
1955.1.1 by John Arbash Meinel
LockDir can create the root directory if it fails to create a pending directory due to NoSuchFile.
414
415
        # This will create 'test_lock' if it needs to
416
        lf1.lock_write()
5784.1.1 by Martin Pool
Stop using failIf, failUnless, etc
417
        self.assertTrue(t.has('test_lock'))
418
        self.assertTrue(t.has('test_lock/held/info'))
1955.1.1 by John Arbash Meinel
LockDir can create the root directory if it fails to create a pending directory due to NoSuchFile.
419
420
        lf1.unlock()
5784.1.1 by Martin Pool
Stop using failIf, failUnless, etc
421
        self.assertFalse(t.has('test_lock/held/info'))
1957.1.6 by John Arbash Meinel
[merge] bzr.dev 2009
422
5425.4.3 by Martin Pool
Represent lock held info as an object, not just a dict
423
    def test_display_form(self):
1957.1.5 by John Arbash Meinel
Create a helper function for formatting lock information
424
        ld1 = self.get_lock()
425
        ld1.create()
426
        ld1.lock_write()
427
        try:
5425.4.18 by Martin Pool
Cleaner and consistent user-orientend representation of LockHeldInfo
428
            info_list = ld1.peek().to_readable_dict()
1957.1.5 by John Arbash Meinel
Create a helper function for formatting lock information
429
        finally:
430
            ld1.unlock()
5425.4.18 by Martin Pool
Cleaner and consistent user-orientend representation of LockHeldInfo
431
        self.assertEqual(info_list['user'], u'jrandom@example.com')
5425.4.27 by Martin Pool
pep8 cleanups
432
        self.assertContainsRe(info_list['pid'], '^\d+$')
433
        self.assertContainsRe(info_list['time_ago'], r'^\d+ seconds? ago$')
2055.2.1 by John Arbash Meinel
Make LockDir less sensitive to invalid configuration of email
434
435
    def test_lock_without_email(self):
6449.6.1 by Jelmer Vernooij
Use config stacks in a few more places in the test suite.
436
        global_config = config.GlobalStack()
2055.2.1 by John Arbash Meinel
Make LockDir less sensitive to invalid configuration of email
437
        # Intentionally has no email address
6449.6.1 by Jelmer Vernooij
Use config stacks in a few more places in the test suite.
438
        global_config.set('email', 'User Identity')
2055.2.1 by John Arbash Meinel
Make LockDir less sensitive to invalid configuration of email
439
        ld1 = self.get_lock()
440
        ld1.create()
441
        ld1.lock_write()
442
        ld1.unlock()
1551.10.3 by Aaron Bentley
Lock attempts don't treat permission problems as lock contention
443
444
    def test_lock_permission(self):
4797.70.1 by Vincent Ladeuil
Skip chmodbits dependent tests when running as root
445
        self.requireFeature(features.not_running_as_root)
1551.10.4 by Aaron Bentley
Update to skip on win32
446
        if not osutils.supports_posix_readonly():
3107.2.2 by John Arbash Meinel
feedback from Martin.
447
            raise tests.TestSkipped('Cannot induce a permission failure')
1551.10.3 by Aaron Bentley
Lock attempts don't treat permission problems as lock contention
448
        ld1 = self.get_lock()
449
        lock_path = ld1.transport.local_abspath('test_lock')
450
        os.mkdir(lock_path)
451
        osutils.make_readonly(lock_path)
2872.5.1 by Martin Pool
Avoid internal error tracebacks on failure to lock on readonly transport (#129701).
452
        self.assertRaises(errors.LockFailed, ld1.attempt_lock)
2555.3.5 by Martin Pool
Return token directly from LockDir.acquire to avoid unnecessary peek()
453
454
    def test_lock_by_token(self):
455
        ld1 = self.get_lock()
456
        token = ld1.lock_write()
4327.1.1 by Vincent Ladeuil
Start addressing test failing when run with -Dlock.
457
        self.addCleanup(ld1.unlock)
2555.3.5 by Martin Pool
Return token directly from LockDir.acquire to avoid unnecessary peek()
458
        self.assertNotEqual(None, token)
459
        ld2 = self.get_lock()
460
        t2 = ld2.lock_write(token)
4327.1.1 by Vincent Ladeuil
Start addressing test failing when run with -Dlock.
461
        self.addCleanup(ld2.unlock)
2555.3.5 by Martin Pool
Return token directly from LockDir.acquire to avoid unnecessary peek()
462
        self.assertEqual(token, t2)
2555.3.9 by Martin Pool
Add test and fix for locking robustly when rename of directories doesn't act as a mutex (thank John)
463
464
    def test_lock_with_buggy_rename(self):
465
        # test that lock acquisition handles servers which pretend they
466
        # renamed correctly but that actually fail
6083.1.1 by Jelmer Vernooij
Use get_transport_from_{url,path} in more places.
467
        t = transport.get_transport_from_url(
468
            'brokenrename+' + self.get_url())
2555.3.9 by Martin Pool
Add test and fix for locking robustly when rename of directories doesn't act as a mutex (thank John)
469
        ld1 = LockDir(t, 'test_lock')
470
        ld1.create()
471
        ld1.attempt_lock()
472
        ld2 = LockDir(t, 'test_lock')
2555.3.14 by Martin Pool
Better handling in LockDir of rename that moves one directory within another
473
        # we should fail to lock
474
        e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
475
        # now the original caller should succeed in unlocking
476
        ld1.unlock()
477
        # and there should be nothing left over
478
        self.assertEquals([], t.list_dir('test_lock'))
2555.3.12 by Martin Pool
Add test for https://bugs.launchpad.net/bzr/+bug/109169 -- test_failed_lock_leaves_no_trash
479
480
    def test_failed_lock_leaves_no_trash(self):
481
        # if we fail to acquire the lock, we don't leave pending directories
482
        # behind -- https://bugs.launchpad.net/bzr/+bug/109169
483
        ld1 = self.get_lock()
484
        ld2 = self.get_lock()
485
        # should be nothing before we start
486
        ld1.create()
487
        t = self.get_transport().clone('test_lock')
5425.4.27 by Martin Pool
pep8 cleanups
488
2555.3.12 by Martin Pool
Add test for https://bugs.launchpad.net/bzr/+bug/109169 -- test_failed_lock_leaves_no_trash
489
        def check_dir(a):
490
            self.assertEquals(a, t.list_dir('.'))
5425.4.27 by Martin Pool
pep8 cleanups
491
2555.3.12 by Martin Pool
Add test for https://bugs.launchpad.net/bzr/+bug/109169 -- test_failed_lock_leaves_no_trash
492
        check_dir([])
493
        # when held, that's all we see
494
        ld1.attempt_lock()
4327.1.1 by Vincent Ladeuil
Start addressing test failing when run with -Dlock.
495
        self.addCleanup(ld1.unlock)
2555.3.12 by Martin Pool
Add test for https://bugs.launchpad.net/bzr/+bug/109169 -- test_failed_lock_leaves_no_trash
496
        check_dir(['held'])
497
        # second guy should fail
498
        self.assertRaises(errors.LockContention, ld2.attempt_lock)
499
        # no kibble
500
        check_dir(['held'])
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
501
4634.138.1 by Martin Pool
Add failing test for \#185103
502
    def test_no_lockdir_info(self):
503
        """We can cope with empty info files."""
504
        # This seems like a fairly common failure case - see
5243.1.2 by Martin
Point launchpad links in comments at production server rather than edge
505
        # <https://bugs.launchpad.net/bzr/+bug/185103> and all its dupes.
4634.138.1 by Martin Pool
Add failing test for \#185103
506
        # Processes are often interrupted after opening the file
507
        # before the actual contents are committed.
508
        t = self.get_transport()
509
        t.mkdir('test_lock')
510
        t.mkdir('test_lock/held')
511
        t.put_bytes('test_lock/held/info', '')
512
        lf = LockDir(t, 'test_lock')
4634.138.2 by Martin Pool
Copy with lock info file being empty
513
        info = lf.peek()
5425.4.18 by Martin Pool
Cleaner and consistent user-orientend representation of LockHeldInfo
514
        formatted_info = info.to_readable_dict()
4634.138.2 by Martin Pool
Copy with lock info file being empty
515
        self.assertEquals(
5425.4.18 by Martin Pool
Cleaner and consistent user-orientend representation of LockHeldInfo
516
            dict(user='<unknown>', hostname='<unknown>', pid='<unknown>',
517
                time_ago='(unknown)'),
4634.138.2 by Martin Pool
Copy with lock info file being empty
518
            formatted_info)
4634.138.1 by Martin Pool
Add failing test for \#185103
519
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
520
    def test_corrupt_lockdir_info(self):
521
        """We can cope with corrupt (and thus unparseable) info files."""
522
        # This seems like a fairly common failure case too - see
4634.165.4 by Vincent Ladeuil
Fix all comments where bugs.edge.launchpad.net was used.
523
        # <https://bugs.launchpad.net/bzr/+bug/619872> for instance.
4634.161.1 by Andrew Bennetts
Add LockCorrupt error, and use it to provide nicer handling of unparseable lock/held/info files.
524
        # In particular some systems tend to fill recently created files with
525
        # nul bytes after recovering from a system crash.
526
        t = self.get_transport()
527
        t.mkdir('test_lock')
528
        t.mkdir('test_lock/held')
529
        t.put_bytes('test_lock/held/info', '\0')
530
        lf = LockDir(t, 'test_lock')
531
        self.assertRaises(errors.LockCorrupt, lf.peek)
532
        # Currently attempt_lock gives LockContention, but LockCorrupt would be
533
        # a reasonable result too.
534
        self.assertRaises(
535
            (errors.LockCorrupt, errors.LockContention), lf.attempt_lock)
536
        self.assertRaises(errors.LockCorrupt, lf.validate_token, 'fake token')
537
538
    def test_missing_lockdir_info(self):
539
        """We can cope with absent info files."""
540
        t = self.get_transport()
541
        t.mkdir('test_lock')
542
        t.mkdir('test_lock/held')
543
        lf = LockDir(t, 'test_lock')
544
        # In this case we expect the 'not held' result from peek, because peek
545
        # cannot be expected to notice that there is a 'held' directory with no
546
        # 'info' file.
547
        self.assertEqual(None, lf.peek())
548
        # And lock/unlock may work or give LockContention (but not any other
549
        # error).
550
        try:
551
            lf.attempt_lock()
552
        except LockContention:
553
            # LockContention is ok, and expected on Windows
554
            pass
555
        else:
556
            # no error is ok, and expected on POSIX (because POSIX allows
557
            # os.rename over an empty directory).
558
            lf.unlock()
559
        # Currently raises TokenMismatch, but LockCorrupt would be reasonable
560
        # too.
561
        self.assertRaises(
562
            (errors.TokenMismatch, errors.LockCorrupt),
563
            lf.validate_token, 'fake token')
564
4327.1.2 by Vincent Ladeuil
Introduce a new lock_broken hook.
565
566
class TestLockDirHooks(TestCaseWithTransport):
567
568
    def setUp(self):
569
        super(TestLockDirHooks, self).setUp()
570
        self._calls = []
571
572
    def get_lock(self):
573
        return LockDir(self.get_transport(), 'test_lock')
574
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
575
    def record_hook(self, result):
576
        self._calls.append(result)
577
3331.3.12 by Martin Pool
Remove PhysicalLock class
578
    def test_LockDir_acquired_success(self):
579
        # the LockDir.lock_acquired hook fires when a lock is acquired.
3331.3.11 by Martin Pool
Move LockDir hooks onto LockDir
580
        LockDir.hooks.install_named_hook('lock_acquired',
4327.1.2 by Vincent Ladeuil
Introduce a new lock_broken hook.
581
                                         self.record_hook, 'record_hook')
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
582
        ld = self.get_lock()
583
        ld.create()
584
        self.assertEqual([], self._calls)
585
        result = ld.attempt_lock()
3331.3.2 by Robert Collins
Polish on lock hooks to be easier to use.
586
        lock_path = ld.transport.abspath(ld.path)
587
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
588
        ld.unlock()
3331.3.2 by Robert Collins
Polish on lock hooks to be easier to use.
589
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
590
3331.3.12 by Martin Pool
Remove PhysicalLock class
591
    def test_LockDir_acquired_fail(self):
592
        # the LockDir.lock_acquired hook does not fire on failure.
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
593
        ld = self.get_lock()
594
        ld.create()
595
        ld2 = self.get_lock()
596
        ld2.attempt_lock()
597
        # install a lock hook now, when the disk lock is locked
3331.3.11 by Martin Pool
Move LockDir hooks onto LockDir
598
        LockDir.hooks.install_named_hook('lock_acquired',
4327.1.2 by Vincent Ladeuil
Introduce a new lock_broken hook.
599
                                         self.record_hook, 'record_hook')
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
600
        self.assertRaises(errors.LockContention, ld.attempt_lock)
601
        self.assertEqual([], self._calls)
602
        ld2.unlock()
603
        self.assertEqual([], self._calls)
604
3331.3.12 by Martin Pool
Remove PhysicalLock class
605
    def test_LockDir_released_success(self):
606
        # the LockDir.lock_released hook fires when a lock is acquired.
3331.3.11 by Martin Pool
Move LockDir hooks onto LockDir
607
        LockDir.hooks.install_named_hook('lock_released',
4327.1.2 by Vincent Ladeuil
Introduce a new lock_broken hook.
608
                                         self.record_hook, 'record_hook')
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
609
        ld = self.get_lock()
610
        ld.create()
611
        self.assertEqual([], self._calls)
612
        result = ld.attempt_lock()
613
        self.assertEqual([], self._calls)
614
        ld.unlock()
3331.3.2 by Robert Collins
Polish on lock hooks to be easier to use.
615
        lock_path = ld.transport.abspath(ld.path)
616
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
617
3331.3.12 by Martin Pool
Remove PhysicalLock class
618
    def test_LockDir_released_fail(self):
619
        # the LockDir.lock_released hook does not fire on failure.
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
620
        ld = self.get_lock()
621
        ld.create()
622
        ld2 = self.get_lock()
623
        ld.attempt_lock()
624
        ld2.force_break(ld2.peek())
3331.3.11 by Martin Pool
Move LockDir hooks onto LockDir
625
        LockDir.hooks.install_named_hook('lock_released',
4327.1.2 by Vincent Ladeuil
Introduce a new lock_broken hook.
626
                                         self.record_hook, 'record_hook')
3331.3.1 by Robert Collins
* ``LockDir`` lock acquisition and release now trigger hooks allowing
627
        self.assertRaises(LockBroken, ld.unlock)
628
        self.assertEqual([], self._calls)
4327.1.2 by Vincent Ladeuil
Introduce a new lock_broken hook.
629
630
    def test_LockDir_broken_success(self):
631
        # the LockDir.lock_broken hook fires when a lock is broken.
632
        ld = self.get_lock()
633
        ld.create()
634
        ld2 = self.get_lock()
635
        result = ld.attempt_lock()
636
        LockDir.hooks.install_named_hook('lock_broken',
637
                                         self.record_hook, 'record_hook')
638
        ld2.force_break(ld2.peek())
639
        lock_path = ld.transport.abspath(ld.path)
640
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
641
642
    def test_LockDir_broken_failure(self):
643
        # the LockDir.lock_broken hook does not fires when a lock is already
644
        # released.
645
        ld = self.get_lock()
646
        ld.create()
647
        ld2 = self.get_lock()
648
        result = ld.attempt_lock()
649
        holder_info = ld2.peek()
650
        ld.unlock()
651
        LockDir.hooks.install_named_hook('lock_broken',
652
                                         self.record_hook, 'record_hook')
653
        ld2.force_break(holder_info)
654
        lock_path = ld.transport.abspath(ld.path)
655
        self.assertEqual([], self._calls)
5425.4.1 by Martin Pool
add xfail tests for stale locks
656
657
6362.2.5 by Martin Packman
Tweaks including those suggested by vila in review
658
class TestLockHeldInfo(TestCaseInTempDir):
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
659
    """Can get information about the lock holder, and detect whether they're
660
    still alive."""
5425.4.1 by Martin Pool
add xfail tests for stale locks
661
5425.4.17 by Martin Pool
Add test for LockHeldInfo repr
662
    def test_repr(self):
663
        info = LockHeldInfo.for_this_process(None)
5425.4.18 by Martin Pool
Cleaner and consistent user-orientend representation of LockHeldInfo
664
        self.assertContainsRe(repr(info), r"LockHeldInfo\(.*\)")
665
666
    def test_unicode(self):
667
        info = LockHeldInfo.for_this_process(None)
668
        self.assertContainsRe(unicode(info),
669
            r'held by .* on .* \(process #\d+\), acquired .* ago')
5425.4.17 by Martin Pool
Add test for LockHeldInfo repr
670
5425.4.7 by Martin Pool
Add and test is_locked_by_this_process
671
    def test_is_locked_by_this_process(self):
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
672
        info = LockHeldInfo.for_this_process(None)
5425.4.7 by Martin Pool
Add and test is_locked_by_this_process
673
        self.assertTrue(info.is_locked_by_this_process())
5425.4.6 by Martin Pool
Move preparation of new locks into LockHeldInfo
674
5425.4.8 by Martin Pool
Basic detection of known dead lock holders
675
    def test_is_not_locked_by_this_process(self):
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
676
        info = LockHeldInfo.for_this_process(None)
5425.4.27 by Martin Pool
pep8 cleanups
677
        info.info_dict['pid'] = '123123123123123'
5425.4.8 by Martin Pool
Basic detection of known dead lock holders
678
        self.assertFalse(info.is_locked_by_this_process())
679
680
    def test_lock_holder_live_process(self):
681
        """Detect that the holder (this process) is still running."""
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
682
        info = LockHeldInfo.for_this_process(None)
5425.4.8 by Martin Pool
Basic detection of known dead lock holders
683
        self.assertFalse(info.is_lock_holder_known_dead())
5425.4.27 by Martin Pool
pep8 cleanups
684
5425.4.8 by Martin Pool
Basic detection of known dead lock holders
685
    def test_lock_holder_dead_process(self):
686
        """Detect that the holder (this process) is still running."""
6060.3.1 by Jelmer Vernooij
Fix lockdir tests when the hostname is set to 'localhost'.
687
        self.overrideAttr(lockdir, 'get_host_name',
688
            lambda: 'aproperhostname')
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
689
        info = LockHeldInfo.for_this_process(None)
5425.4.27 by Martin Pool
pep8 cleanups
690
        info.info_dict['pid'] = '123123123'
5425.4.8 by Martin Pool
Basic detection of known dead lock holders
691
        self.assertTrue(info.is_lock_holder_known_dead())
5425.4.27 by Martin Pool
pep8 cleanups
692
5425.4.1 by Martin Pool
add xfail tests for stale locks
693
    def test_lock_holder_other_machine(self):
694
        """The lock holder isn't here so we don't know if they're alive."""
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
695
        info = LockHeldInfo.for_this_process(None)
5425.6.1 by Martin Pool
Only detect as stale locks from the same user
696
        info.info_dict['hostname'] = 'egg.example.com'
5425.4.27 by Martin Pool
pep8 cleanups
697
        info.info_dict['pid'] = '123123123'
5425.6.1 by Martin Pool
Only detect as stale locks from the same user
698
        self.assertFalse(info.is_lock_holder_known_dead())
699
700
    def test_lock_holder_other_user(self):
701
        """Only auto-break locks held by this user."""
702
        info = LockHeldInfo.for_this_process(None)
703
        info.info_dict['user'] = 'notme@example.com'
5425.4.27 by Martin Pool
pep8 cleanups
704
        info.info_dict['pid'] = '123123123'
5425.4.8 by Martin Pool
Basic detection of known dead lock holders
705
        self.assertFalse(info.is_lock_holder_known_dead())
5425.4.1 by Martin Pool
add xfail tests for stale locks
706
707
    def test_no_good_hostname(self):
708
        """Correctly handle ambiguous hostnames.
709
710
        If the lock's recorded with just 'localhost' we can't really trust
5425.4.9 by Martin Pool
Defensively handle 'localhost' in detecting dead locks
711
        it's the same 'localhost'.  (There are quite a few of them. :-)
712
        So even if the process is known not to be alive, we can't say that's
713
        known for sure.
5425.4.1 by Martin Pool
add xfail tests for stale locks
714
        """
5425.4.9 by Martin Pool
Defensively handle 'localhost' in detecting dead locks
715
        self.overrideAttr(lockdir, 'get_host_name',
716
            lambda: 'localhost')
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
717
        info = LockHeldInfo.for_this_process(None)
5425.4.9 by Martin Pool
Defensively handle 'localhost' in detecting dead locks
718
        info.info_dict['pid'] = '123123123'
719
        self.assertFalse(info.is_lock_holder_known_dead())
5425.4.1 by Martin Pool
add xfail tests for stale locks
720
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
721
722
class TestStaleLockDir(TestCaseWithTransport):
723
    """Can automatically break stale locks.
724
725
    :see: https://bugs.launchpad.net/bzr/+bug/220464
726
    """
5425.4.25 by Martin Pool
Support auto-stealing dead locks, but turn it off by default.
727
5425.4.1 by Martin Pool
add xfail tests for stale locks
728
    def test_auto_break_stale_lock(self):
729
        """Locks safely known to be stale are just cleaned up.
730
731
        This generates a warning but no other user interaction.
732
        """
6060.3.1 by Jelmer Vernooij
Fix lockdir tests when the hostname is set to 'localhost'.
733
        self.overrideAttr(lockdir, 'get_host_name',
734
            lambda: 'aproperhostname')
5425.4.25 by Martin Pool
Support auto-stealing dead locks, but turn it off by default.
735
        # This is off by default at present; see the discussion in the bug.
736
        # If you change the default, don't forget to update the docs.
737
        config.GlobalConfig().set_user_option('locks.steal_dead', True)
5425.4.10 by Martin Pool
Allow storing extra info into lockdir info files to aid testing
738
        # Create a lock pretending to come from a different nonexistent
739
        # process on the same machine.
740
        l1 = LockDir(self.get_transport(), 'a',
741
            extra_holder_info={'pid': '12312313'})
742
        token_1 = l1.attempt_lock()
743
        l2 = LockDir(self.get_transport(), 'a')
5425.4.13 by Martin Pool
Steal locks of dead local processes, with a user warning
744
        token_2 = l2.attempt_lock()
745
        # l1 will notice its lock was stolen.
746
        self.assertRaises(errors.LockBroken,
747
            l1.unlock)
748
        l2.unlock()
5425.4.1 by Martin Pool
add xfail tests for stale locks
749
750
    def test_auto_break_stale_lock_configured_off(self):
5425.4.15 by Martin Pool
Add steal_dead_locks option letting automatic lock-breaking be turned off
751
        """Automatic breaking can be turned off"""
752
        l1 = LockDir(self.get_transport(), 'a',
753
            extra_holder_info={'pid': '12312313'})
754
        token_1 = l1.attempt_lock()
755
        self.addCleanup(l1.unlock)
756
        l2 = LockDir(self.get_transport(), 'a')
5425.4.25 by Martin Pool
Support auto-stealing dead locks, but turn it off by default.
757
        # This fails now, because dead lock breaking is off by default.
5425.4.15 by Martin Pool
Add steal_dead_locks option letting automatic lock-breaking be turned off
758
        self.assertRaises(LockContention,
759
            l2.attempt_lock)
760
        # and it's in fact not broken
761
        l1.confirm()