/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/lockdir.py

  • Committer: John Arbash Meinel
  • Date: 2007-07-11 23:45:20 UTC
  • mfrom: (2601 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2643.
  • Revision ID: john@arbash-meinel.com-20070711234520-do3h7zw8skbathpz
[merge] bzr.dev 2601

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockdir.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
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
88
88
>>> t = MemoryTransport()
89
89
>>> l = LockDir(t, 'sample-lock')
90
90
>>> l.create()
91
 
>>> l.wait_lock()
 
91
>>> token = l.wait_lock()
92
92
>>> # do something here
93
93
>>> l.unlock()
94
94
 
95
95
"""
96
96
 
 
97
 
 
98
# TODO: We sometimes have the problem that our attempt to rename '1234' to
 
99
# 'held' fails because the transport server moves into an existing directory,
 
100
# rather than failing the rename.  If we made the info file name the same as
 
101
# the locked directory name we would avoid this problem because moving into
 
102
# the held directory would implicitly clash.  However this would not mesh with
 
103
# the existing locking code and needs a new format of the containing object.
 
104
# -- robertc, mbp 20070628
 
105
 
97
106
import os
98
107
import time
99
108
from cStringIO import StringIO
100
109
 
101
110
from bzrlib import (
 
111
    debug,
102
112
    errors,
103
113
    )
104
114
import bzrlib.config
184
194
        """
185
195
        if self.transport.is_readonly():
186
196
            raise UnlockableTransport(self.transport)
 
197
        self._trace("create lock directory")
187
198
        self.transport.mkdir(self.path, mode=mode)
188
199
 
189
 
    def attempt_lock(self):
190
 
        """Take the lock; fail if it's already held.
 
200
    def _attempt_lock(self):
 
201
        """Make the pending directory and attempt to rename into place.
191
202
        
192
 
        If you wish to block until the lock can be obtained, call wait_lock()
193
 
        instead.
 
203
        If the rename succeeds, we read back the info file to check that we
 
204
        really got the lock.
 
205
 
 
206
        If we fail to acquire the lock, this method is responsible for
 
207
        cleaning up the pending directory if possible.  (But it doesn't do
 
208
        that yet.)
 
209
 
 
210
        :returns: The nonce of the lock, if it was successfully acquired.
 
211
 
 
212
        :raises LockContention: If the lock is held by someone else.  The exception
 
213
            contains the info of the current holder of the lock.
194
214
        """
195
 
        if self._fake_read_lock:
196
 
            raise LockContention(self)
197
 
        if self.transport.is_readonly():
198
 
            raise UnlockableTransport(self.transport)
 
215
        self._trace("lock_write...")
 
216
        start_time = time.time()
 
217
        tmpname = self._create_pending_dir()
199
218
        try:
200
 
            tmpname = '%s/pending.%s.tmp' % (self.path, rand_chars(20))
201
 
            try:
202
 
                self.transport.mkdir(tmpname)
203
 
            except NoSuchFile:
204
 
                # This may raise a FileExists exception
205
 
                # which is okay, it will be caught later and determined
206
 
                # to be a LockContention.
207
 
                self.create(mode=self._dir_modebits)
208
 
                
209
 
                # After creating the lock directory, try again
210
 
                self.transport.mkdir(tmpname)
211
 
 
212
 
            self.nonce = rand_chars(20)
213
 
            info_bytes = self._prepare_info()
214
 
            # We use put_file_non_atomic because we just created a new unique
215
 
            # directory so we don't have to worry about files existing there.
216
 
            # We'll rename the whole directory into place to get atomic
217
 
            # properties
218
 
            self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
219
 
                                                info_bytes)
220
 
 
221
219
            self.transport.rename(tmpname, self._held_dir)
222
 
            self._lock_held = True
223
 
            self.confirm()
224
 
        except errors.PermissionDenied:
 
220
        except (PathError, DirectoryNotEmpty, FileExists, ResourceBusy), e:
 
221
            self._trace("... contention, %s", e)
 
222
            self._remove_pending_dir(tmpname)
 
223
            raise LockContention(self)
 
224
        except Exception, e:
 
225
            self._trace("... lock failed, %s", e)
 
226
            self._remove_pending_dir(tmpname)
225
227
            raise
226
 
        except (PathError, DirectoryNotEmpty, FileExists, ResourceBusy), e:
227
 
            mutter("contention on %r: %s", self, e)
 
228
        # We must check we really got the lock, because Launchpad's sftp
 
229
        # server at one time had a bug were the rename would successfully
 
230
        # move the new directory into the existing directory, which was
 
231
        # incorrect.  It's possible some other servers or filesystems will
 
232
        # have a similar bug allowing someone to think they got the lock
 
233
        # when it's already held.
 
234
        info = self.peek()
 
235
        self._trace("after locking, info=%r", info)
 
236
        if info['nonce'] != self.nonce:
 
237
            self._trace("rename succeeded, "
 
238
                "but lock is still held by someone else")
228
239
            raise LockContention(self)
 
240
        self._lock_held = True
 
241
        self._trace("... lock succeeded after %dms",
 
242
                (time.time() - start_time) * 1000)
 
243
        return self.nonce
 
244
 
 
245
    def _remove_pending_dir(self, tmpname):
 
246
        """Remove the pending directory
 
247
 
 
248
        This is called if we failed to rename into place, so that the pending 
 
249
        dirs don't clutter up the lockdir.
 
250
        """
 
251
        self._trace("remove %s", tmpname)
 
252
        try:
 
253
            self.transport.delete(tmpname + self.__INFO_NAME)
 
254
            self.transport.rmdir(tmpname)
 
255
        except PathError, e:
 
256
            note("error removing pending lock: %s", e)
 
257
 
 
258
    def _create_pending_dir(self):
 
259
        tmpname = '%s/%s.tmp' % (self.path, rand_chars(10))
 
260
        try:
 
261
            self.transport.mkdir(tmpname)
 
262
        except NoSuchFile:
 
263
            # This may raise a FileExists exception
 
264
            # which is okay, it will be caught later and determined
 
265
            # to be a LockContention.
 
266
            self._trace("lock directory does not exist, creating it")
 
267
            self.create(mode=self._dir_modebits)
 
268
            # After creating the lock directory, try again
 
269
            self.transport.mkdir(tmpname)
 
270
        self.nonce = rand_chars(20)
 
271
        info_bytes = self._prepare_info()
 
272
        # We use put_file_non_atomic because we just created a new unique
 
273
        # directory so we don't have to worry about files existing there.
 
274
        # We'll rename the whole directory into place to get atomic
 
275
        # properties
 
276
        self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
 
277
                                            info_bytes)
 
278
        return tmpname
229
279
 
230
280
    def unlock(self):
231
281
        """Release a held lock
241
291
        else:
242
292
            # rename before deleting, because we can't atomically remove the
243
293
            # whole tree
 
294
            start_time = time.time()
 
295
            self._trace("unlocking")
244
296
            tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
245
297
            # gotta own it to unlock
246
298
            self.confirm()
247
299
            self.transport.rename(self._held_dir, tmpname)
248
300
            self._lock_held = False
249
301
            self.transport.delete(tmpname + self.__INFO_NAME)
250
 
            self.transport.rmdir(tmpname)
 
302
            try:
 
303
                self.transport.rmdir(tmpname)
 
304
            except DirectoryNotEmpty, e:
 
305
                # There might have been junk left over by a rename that moved
 
306
                # another locker within the 'held' directory.  do a slower
 
307
                # deletion where we list the directory and remove everything
 
308
                # within it.
 
309
                #
 
310
                # Maybe this should be broader to allow for ftp servers with
 
311
                # non-specific error messages?
 
312
                self._trace("doing recursive deletion of non-empty directory "
 
313
                        "%s", tmpname)
 
314
                self.transport.delete_tree(tmpname)
 
315
            self._trace("... unlock succeeded after %dms",
 
316
                    (time.time() - start_time) * 1000)
251
317
 
252
318
    def break_lock(self):
253
319
        """Break a lock not held by this instance of LockDir.
341
407
        """
342
408
        try:
343
409
            info = self._read_info_file(self._held_info_path)
 
410
            self._trace("peek -> held")
344
411
            assert isinstance(info, dict), \
345
412
                    "bad parse result %r" % info
346
413
            return info
347
414
        except NoSuchFile, e:
348
 
            return None
 
415
            self._trace("peek -> not held")
349
416
 
350
417
    def _prepare_info(self):
351
418
        """Write information about a pending lock to a temporary file.
368
435
    def _parse_info(self, info_file):
369
436
        return read_stanza(info_file.readlines()).as_dict()
370
437
 
371
 
    def wait_lock(self, timeout=None, poll=None):
 
438
    def attempt_lock(self):
 
439
        """Take the lock; fail if it's already held.
 
440
        
 
441
        If you wish to block until the lock can be obtained, call wait_lock()
 
442
        instead.
 
443
 
 
444
        :return: The lock token.
 
445
        :raises LockContention: if the lock is held by someone else.
 
446
        """
 
447
        if self._fake_read_lock:
 
448
            raise LockContention(self)
 
449
        if self.transport.is_readonly():
 
450
            raise UnlockableTransport(self.transport)
 
451
        return self._attempt_lock()
 
452
 
 
453
    def wait_lock(self, timeout=None, poll=None, max_attempts=None):
372
454
        """Wait a certain period for a lock.
373
455
 
374
456
        If the lock can be acquired within the bounded time, it
376
458
        is raised.  Either way, this function should return within
377
459
        approximately `timeout` seconds.  (It may be a bit more if
378
460
        a transport operation takes a long time to complete.)
 
461
 
 
462
        :param timeout: Approximate maximum amount of time to wait for the
 
463
        lock, in seconds.
 
464
         
 
465
        :param poll: Delay in seconds between retrying the lock.
 
466
 
 
467
        :param max_attempts: Maximum number of times to try to lock.
 
468
 
 
469
        :return: The lock token.
379
470
        """
380
471
        if timeout is None:
381
472
            timeout = _DEFAULT_TIMEOUT_SECONDS
382
473
        if poll is None:
383
474
            poll = _DEFAULT_POLL_SECONDS
384
 
 
385
 
        # XXX: the transport interface doesn't let us guard 
386
 
        # against operations there taking a long time.
 
475
        # XXX: the transport interface doesn't let us guard against operations
 
476
        # there taking a long time, so the total elapsed time or poll interval
 
477
        # may be more than was requested.
387
478
        deadline = time.time() + timeout
388
479
        deadline_str = None
389
480
        last_info = None
 
481
        attempt_count = 0
390
482
        while True:
 
483
            attempt_count += 1
391
484
            try:
392
 
                self.attempt_lock()
393
 
                return
 
485
                return self.attempt_lock()
394
486
            except LockContention:
 
487
                # possibly report the blockage, then try again
395
488
                pass
 
489
            # TODO: In a few cases, we find out that there's contention by
 
490
            # reading the held info and observing that it's not ours.  In
 
491
            # those cases it's a bit redundant to read it again.  However,
 
492
            # the normal case (??) is that the rename fails and so we
 
493
            # don't know who holds the lock.  For simplicity we peek
 
494
            # always.
396
495
            new_info = self.peek()
397
 
            mutter('last_info: %s, new info: %s', last_info, new_info)
398
496
            if new_info is not None and new_info != last_info:
399
497
                if last_info is None:
400
498
                    start = 'Unable to obtain'
415
513
                                      formatted_info[2],
416
514
                                      deadline_str)
417
515
 
 
516
            if (max_attempts is not None) and (attempt_count >= max_attempts):
 
517
                self._trace("exceeded %d attempts")
 
518
                raise LockContention(self)
418
519
            if time.time() + poll < deadline:
 
520
                self._trace("waiting %ss", poll)
419
521
                time.sleep(poll)
420
522
            else:
 
523
                self._trace("timeout after waiting %ss", timeout)
421
524
                raise LockContention(self)
422
525
    
423
526
    def leave_in_place(self):
450
553
            self._locked_via_token = True
451
554
            return token
452
555
        else:
453
 
            self.wait_lock()
454
 
            return self.peek().get('nonce')
 
556
            return self.wait_lock()
455
557
 
456
558
    def lock_read(self):
457
559
        """Compatibility-mode shared lock.
468
570
            raise LockContention(self)
469
571
        self._fake_read_lock = True
470
572
 
471
 
    def wait(self, timeout=20, poll=0.5):
472
 
        """Wait a certain period for a lock to be released."""
473
 
        # XXX: the transport interface doesn't let us guard 
474
 
        # against operations there taking a long time.
475
 
        deadline = time.time() + timeout
476
 
        while True:
477
 
            if self.peek():
478
 
                return
479
 
            if time.time() + poll < deadline:
480
 
                time.sleep(poll)
481
 
            else:
482
 
                raise LockContention(self)
483
 
 
484
573
    def _format_lock_info(self, info):
485
574
        """Turn the contents of peek() into something for the user"""
486
575
        lock_url = self.transport.abspath(self.path)
501
590
                lock_token = info.get('nonce')
502
591
            if token != lock_token:
503
592
                raise errors.TokenMismatch(token, lock_token)
 
593
            else:
 
594
                self._trace("revalidated by token %r", token)
504
595
 
 
596
    def _trace(self, format, *args):
 
597
        if 'lock' not in debug.debug_flags:
 
598
            return
 
599
        mutter(str(self) + ": " + (format % args))