/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
3296.1.1 by Martin Pool
If LockableFiles is destroyed while locked, just mutter
1
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
1887.1.1 by Adeodato Simó
Do not separate paragraphs in the copyright statement with blank lines,
2
#
1185.65.22 by Robert Collins
lockable_files was extracted from branch.py - give it a copyright statement
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
#
1185.65.22 by Robert Collins
lockable_files was extracted from branch.py - give it a copyright statement
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
#
1185.65.22 by Robert Collins
lockable_files was extracted from branch.py - give it a copyright statement
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
1185.65.29 by Robert Collins
Implement final review suggestions.
17
from cStringIO import StringIO
18
import codecs
1185.80.2 by John Arbash Meinel
Traced double locking code to WorkingTree creating its own control files.
19
#import traceback
3296.1.2 by Martin Pool
LockableFiles should warn but not automatically unlock
20
from warnings import warn
1185.70.3 by Martin Pool
Various updates to make storage branch mergeable:
21
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
22
import bzrlib
1773.4.1 by Martin Pool
Add pyflakes makefile target; fix many warnings
23
from bzrlib.decorators import (needs_read_lock,
24
        needs_write_lock)
1185.65.10 by Robert Collins
Rename Controlfiles to LockableFiles.
25
import bzrlib.errors as errors
1694.2.6 by Martin Pool
[merge] bzr.dev
26
from bzrlib.errors import BzrError
1185.65.27 by Robert Collins
Tweak storage towards mergability.
27
from bzrlib.osutils import file_iterator, safe_unicode
2696.1.1 by Martin Pool
Remove things deprecated in 0.11 and earlier
28
from bzrlib.symbol_versioning import (deprecated_method,
29
        )
1185.80.2 by John Arbash Meinel
Traced double locking code to WorkingTree creating its own control files.
30
from bzrlib.trace import mutter, note
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
31
import bzrlib.transactions as transactions
1685.1.45 by John Arbash Meinel
Moved url functions into bzrlib.urlutils
32
import bzrlib.urlutils as urlutils
33
1185.65.10 by Robert Collins
Rename Controlfiles to LockableFiles.
34
1553.5.41 by Martin Pool
Add new LockableFiles.LockDirStrategy; not used yet
35
# XXX: The tracking here of lock counts and whether the lock is held is
36
# somewhat redundant with what's done in LockDir; the main difference is that
37
# LockableFiles permits reentrancy.
1185.65.27 by Robert Collins
Tweak storage towards mergability.
38
1185.66.3 by Aaron Bentley
Renamed ControlFiles to LockableFiles
39
class LockableFiles(object):
1553.5.38 by Martin Pool
More explanation for LockableFiles
40
    """Object representing a set of related files locked within the same scope.
41
42
    These files are used by a WorkingTree, Repository or Branch, and should
43
    generally only be touched by that object.
44
45
    LockableFiles also provides some policy on top of Transport for encoding
46
    control files as utf-8.
47
1553.5.39 by Martin Pool
More lock docs
48
    LockableFiles manage a lock count and can be locked repeatedly by
49
    a single caller.  (The underlying lock implementation generally does not
50
    support this.)
51
1553.5.38 by Martin Pool
More explanation for LockableFiles
52
    Instances of this class are often called control_files.
53
    
1553.5.43 by Martin Pool
Get LockableFiles tests running against LockDir
54
    This object builds on top of a Transport, which is used to actually write
55
    the files to disk, and an OSLock or LockDir, which controls how access to
56
    the files is controlled.  The particular type of locking used is set when
57
    the object is constructed.  In older formats OSLocks are used everywhere.
58
    in newer formats a LockDir is used for Repositories and Branches, and 
59
    OSLocks for the local filesystem.
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
60
    """
1185.65.10 by Robert Collins
Rename Controlfiles to LockableFiles.
61
1553.5.47 by Martin Pool
cleanup LockableFiles
62
    # _lock_mode: None, or 'r' or 'w'
1553.5.43 by Martin Pool
Get LockableFiles tests running against LockDir
63
1553.5.47 by Martin Pool
cleanup LockableFiles
64
    # _lock_count: If _lock_mode is true, a positive count of the number of
65
    # times the lock has been taken *by this process*.   
66
    
1185.69.2 by John Arbash Meinel
Changed LockableFiles to take the root directory directly. Moved mode information into LockableFiles instead of Branch
67
    # If set to False (by a plugin, etc) BzrBranch will not set the
68
    # mode on created files or directories
69
    _set_file_mode = True
70
    _set_dir_mode = True
1185.65.10 by Robert Collins
Rename Controlfiles to LockableFiles.
71
1553.5.63 by Martin Pool
Lock type is now mandatory for LockableFiles constructor
72
    def __init__(self, transport, lock_name, lock_class):
1553.5.43 by Martin Pool
Get LockableFiles tests running against LockDir
73
        """Create a LockableFiles group
74
75
        :param transport: Transport pointing to the directory holding the 
76
            control files and lock.
77
        :param lock_name: Name of the lock guarding these files.
1553.5.47 by Martin Pool
cleanup LockableFiles
78
        :param lock_class: Class of lock strategy to use: typically
79
            either LockDir or TransportLock.
1553.5.43 by Martin Pool
Get LockableFiles tests running against LockDir
80
        """
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
81
        self._transport = transport
82
        self.lock_name = lock_name
83
        self._transaction = None
1553.5.47 by Martin Pool
cleanup LockableFiles
84
        self._lock_mode = None
85
        self._lock_count = 0
1685.1.43 by John Arbash Meinel
Bug in lockable files when _find_mode throws
86
        self._find_modes()
1553.5.43 by Martin Pool
Get LockableFiles tests running against LockDir
87
        esc_name = self._escape(lock_name)
1608.2.1 by Martin Pool
[merge] Storage filename escaping
88
        self._lock = lock_class(transport, esc_name,
1553.5.59 by Martin Pool
Pass file/mode bits through to creation of lock files/dirs
89
                                file_modebits=self._file_mode,
90
                                dir_modebits=self._dir_mode)
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
91
1553.5.60 by Martin Pool
New LockableFiles.create_lock() method
92
    def create_lock(self):
93
        """Create the lock.
94
95
        This should normally be called only when the LockableFiles directory
96
        is first created on disk.
97
        """
1666.1.4 by Robert Collins
* 'Metadir' is now the default disk format. This improves behaviour in
98
        self._lock.create(mode=self._dir_mode)
1553.5.60 by Martin Pool
New LockableFiles.create_lock() method
99
1553.5.53 by Martin Pool
Add LockableFiles __repr__
100
    def __repr__(self):
101
        return '%s(%r)' % (self.__class__.__name__,
102
                           self._transport)
1185.80.2 by John Arbash Meinel
Traced double locking code to WorkingTree creating its own control files.
103
    def __str__(self):
104
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
105
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
106
    def __del__(self):
1608.2.1 by Martin Pool
[merge] Storage filename escaping
107
        if self.is_locked():
3296.1.2 by Martin Pool
LockableFiles should warn but not automatically unlock
108
            # do not automatically unlock; there should have been a
109
            # try/finally to unlock this.
110
            warn("%r was gc'd while locked" % self)
1553.5.53 by Martin Pool
Add LockableFiles __repr__
111
1687.1.6 by Robert Collins
Extend LockableFiles to support break_lock() calls.
112
    def break_lock(self):
113
        """Break the lock of this lockable files group if it is held.
114
115
        The current ui factory will be used to prompt for user conformation.
116
        """
117
        self._lock.break_lock()
118
1185.69.2 by John Arbash Meinel
Changed LockableFiles to take the root directory directly. Moved mode information into LockableFiles instead of Branch
119
    def _escape(self, file_or_path):
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
120
        if not isinstance(file_or_path, basestring):
121
            file_or_path = '/'.join(file_or_path)
122
        if file_or_path == '':
1185.69.2 by John Arbash Meinel
Changed LockableFiles to take the root directory directly. Moved mode information into LockableFiles instead of Branch
123
            return u''
1685.1.45 by John Arbash Meinel
Moved url functions into bzrlib.urlutils
124
        return urlutils.escape(safe_unicode(file_or_path))
1185.69.2 by John Arbash Meinel
Changed LockableFiles to take the root directory directly. Moved mode information into LockableFiles instead of Branch
125
126
    def _find_modes(self):
127
        """Determine the appropriate modes for files and directories."""
128
        try:
1534.4.28 by Robert Collins
first cut at merge from integration.
129
            st = self._transport.stat('.')
130
        except errors.TransportNotPossible:
1185.69.2 by John Arbash Meinel
Changed LockableFiles to take the root directory directly. Moved mode information into LockableFiles instead of Branch
131
            self._dir_mode = 0755
132
            self._file_mode = 0644
133
        else:
3107.2.1 by John Arbash Meinel
Fix LockableFiles to not use modes that allow the user to write to things they create.
134
            # Check the directory mode, but also make sure the created
135
            # directories and files are read-write for this user. This is
136
            # mostly a workaround for filesystems which lie about being able to
137
            # write to a directory (cygwin & win32)
138
            self._dir_mode = (st.st_mode & 07777) | 00700
1185.69.2 by John Arbash Meinel
Changed LockableFiles to take the root directory directly. Moved mode information into LockableFiles instead of Branch
139
            # Remove the sticky and execute bits for files
140
            self._file_mode = self._dir_mode & ~07111
141
        if not self._set_dir_mode:
142
            self._dir_mode = None
143
        if not self._set_file_mode:
144
            self._file_mode = None
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
145
146
    def controlfilename(self, file_or_path):
147
        """Return location relative to branch."""
1185.69.2 by John Arbash Meinel
Changed LockableFiles to take the root directory directly. Moved mode information into LockableFiles instead of Branch
148
        return self._transport.abspath(self._escape(file_or_path))
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
149
1185.65.29 by Robert Collins
Implement final review suggestions.
150
    @needs_read_lock
151
    def get(self, relpath):
152
        """Get a file as a bytestream."""
153
        relpath = self._escape(relpath)
154
        return self._transport.get(relpath)
155
156
    @needs_read_lock
157
    def get_utf8(self, relpath):
158
        """Get a file as a unicode stream."""
159
        relpath = self._escape(relpath)
160
        # DO NOT introduce an errors=replace here.
161
        return codecs.getreader('utf-8')(self._transport.get(relpath))
162
1185.65.27 by Robert Collins
Tweak storage towards mergability.
163
    @needs_write_lock
1185.65.12 by Robert Collins
Remove the only-used-once put_controlfiles, and change put_controlfile to put and put_utf8.
164
    def put(self, path, file):
165
        """Write a file.
166
        
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
167
        :param path: The path to put the file, relative to the .bzr control
168
                     directory
169
        :param f: A file-like or string object whose contents should be copied.
170
        """
1955.3.8 by John Arbash Meinel
avoid some deprecation warnings in other parts of the code
171
        self._transport.put_file(self._escape(path), file, mode=self._file_mode)
1185.65.12 by Robert Collins
Remove the only-used-once put_controlfiles, and change put_controlfile to put and put_utf8.
172
1185.65.27 by Robert Collins
Tweak storage towards mergability.
173
    @needs_write_lock
2249.5.11 by John Arbash Meinel
Audit Branch to ensure utf8 revision ids.
174
    def put_bytes(self, path, a_string):
175
        """Write a string of bytes.
176
177
        :param path: The path to put the bytes, relative to the transport root.
178
        :param string: A string object, whose exact bytes are to be copied.
179
        """
180
        self._transport.put_bytes(self._escape(path), a_string,
181
                                  mode=self._file_mode)
182
183
    @needs_write_lock
1185.65.29 by Robert Collins
Implement final review suggestions.
184
    def put_utf8(self, path, a_string):
185
        """Write a string, encoding as utf-8.
1185.65.12 by Robert Collins
Remove the only-used-once put_controlfiles, and change put_controlfile to put and put_utf8.
186
1185.65.29 by Robert Collins
Implement final review suggestions.
187
        :param path: The path to put the string, relative to the transport root.
2249.5.11 by John Arbash Meinel
Audit Branch to ensure utf8 revision ids.
188
        :param string: A string or unicode object whose contents should be copied.
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
189
        """
1185.67.7 by Aaron Bentley
Refactored a bit
190
        # IterableFile would not be needed if Transport.put took iterables
191
        # instead of files.  ADHB 2005-12-25
1185.65.17 by Robert Collins
Merge from integration, mode-changes are broken.
192
        # RBC 20060103 surely its not needed anyway, with codecs transcode
193
        # file support ?
1185.69.2 by John Arbash Meinel
Changed LockableFiles to take the root directory directly. Moved mode information into LockableFiles instead of Branch
194
        # JAM 20060103 We definitely don't want encode(..., 'replace')
195
        # these are valuable files which should have exact contents.
1185.65.29 by Robert Collins
Implement final review suggestions.
196
        if not isinstance(a_string, basestring):
197
            raise errors.BzrBadParameterNotString(a_string)
2249.5.11 by John Arbash Meinel
Audit Branch to ensure utf8 revision ids.
198
        self.put_bytes(path, a_string.encode('utf-8'))
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
199
2018.5.75 by Andrew Bennetts
Add Repository.{dont_,}leave_lock_in_place.
200
    def leave_in_place(self):
201
        """Set this LockableFiles to not clear the physical lock on unlock."""
202
        self._lock.leave_in_place()
203
204
    def dont_leave_in_place(self):
205
        """Set this LockableFiles to clear the physical lock on unlock."""
206
        self._lock.dont_leave_in_place()
207
2279.7.1 by Andrew Bennetts
``LockableFiles.lock_write()`` now accepts a ``token`` keyword argument, so that
208
    def lock_write(self, token=None):
209
        """Lock this group of files for writing.
210
        
211
        :param token: if this is already locked, then lock_write will fail
212
            unless the token matches the existing lock.
213
        :returns: a token if this instance supports tokens, otherwise None.
214
        :raises TokenLockingNotSupported: when a token is given but this
215
            instance doesn't support using token locks.
216
        :raises MismatchedToken: if the specified token doesn't match the token
217
            of the existing lock.
2018.5.145 by Andrew Bennetts
Add a brief explanation of what tokens are used for to lock_write docstrings.
218
219
        A token should be passed in if you know that you have locked the object
220
        some other way, and need to synchronise this object's state with that
221
        fact.
2279.7.1 by Andrew Bennetts
``LockableFiles.lock_write()`` now accepts a ``token`` keyword argument, so that
222
        """
1551.2.3 by Aaron Bentley
Removed lock-related log spam [recommit]
223
        # mutter("lock write: %s (%s)", self, self._lock_count)
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
224
        # TODO: Upgrade locking to support using a Transport,
225
        # and potentially a remote locking protocol
226
        if self._lock_mode:
1594.2.22 by Robert Collins
Ensure that lockable files calls finish() on transactions.:
227
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
1694.2.6 by Martin Pool
[merge] bzr.dev
228
                raise errors.ReadOnlyError(self)
2279.7.1 by Andrew Bennetts
``LockableFiles.lock_write()`` now accepts a ``token`` keyword argument, so that
229
            self._lock.validate_token(token)
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
230
            self._lock_count += 1
2018.14.1 by Andrew Bennetts
Update to current hpss branch? Fix lots of test failures.
231
            return self._token_from_lock
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
232
        else:
2279.7.1 by Andrew Bennetts
``LockableFiles.lock_write()`` now accepts a ``token`` keyword argument, so that
233
            token_from_lock = self._lock.lock_write(token=token)
1185.80.2 by John Arbash Meinel
Traced double locking code to WorkingTree creating its own control files.
234
            #note('write locking %s', self)
235
            #traceback.print_stack()
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
236
            self._lock_mode = 'w'
237
            self._lock_count = 1
1563.2.34 by Robert Collins
Remove the commit and rollback transaction methods as misleading, and implement a WriteTransaction
238
            self._set_transaction(transactions.WriteTransaction())
2018.14.1 by Andrew Bennetts
Update to current hpss branch? Fix lots of test failures.
239
            self._token_from_lock = token_from_lock
2279.7.1 by Andrew Bennetts
``LockableFiles.lock_write()`` now accepts a ``token`` keyword argument, so that
240
            return token_from_lock
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
241
242
    def lock_read(self):
1551.2.3 by Aaron Bentley
Removed lock-related log spam [recommit]
243
        # mutter("lock read: %s (%s)", self, self._lock_count)
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
244
        if self._lock_mode:
245
            assert self._lock_mode in ('r', 'w'), \
246
                   "invalid lock mode %r" % self._lock_mode
247
            self._lock_count += 1
248
        else:
1553.5.47 by Martin Pool
cleanup LockableFiles
249
            self._lock.lock_read()
1185.80.2 by John Arbash Meinel
Traced double locking code to WorkingTree creating its own control files.
250
            #note('read locking %s', self)
251
            #traceback.print_stack()
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
252
            self._lock_mode = 'r'
253
            self._lock_count = 1
254
            self._set_transaction(transactions.ReadOnlyTransaction())
255
            # 5K may be excessive, but hey, its a knob.
256
            self.get_transaction().set_cache_size(5000)
257
                        
258
    def unlock(self):
1551.2.3 by Aaron Bentley
Removed lock-related log spam [recommit]
259
        # mutter("unlock: %s (%s)", self, self._lock_count)
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
260
        if not self._lock_mode:
1553.5.36 by Martin Pool
Clean up duplicate BranchNotLocked error and rename to ObjectNotLocked
261
            raise errors.LockNotHeld(self)
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
262
        if self._lock_count > 1:
263
            self._lock_count -= 1
264
        else:
1185.80.2 by John Arbash Meinel
Traced double locking code to WorkingTree creating its own control files.
265
            #note('unlocking %s', self)
266
            #traceback.print_stack()
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
267
            self._finish_transaction()
1687.1.6 by Robert Collins
Extend LockableFiles to support break_lock() calls.
268
            try:
269
                self._lock.unlock()
270
            finally:
271
                self._lock_mode = self._lock_count = None
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
272
1553.5.35 by Martin Pool
Start break-lock --show
273
    def is_locked(self):
274
        """Return true if this LockableFiles group is locked"""
275
        return self._lock_count >= 1
276
1694.2.6 by Martin Pool
[merge] bzr.dev
277
    def get_physical_lock_status(self):
278
        """Return physical lock status.
279
        
280
        Returns true if a lock is held on the transport. If no lock is held, or
281
        the underlying locking mechanism does not support querying lock
282
        status, false is returned.
283
        """
284
        try:
285
            return self._lock.peek() is not None
286
        except NotImplementedError:
287
            return False
288
1185.65.1 by Aaron Bentley
Refactored out ControlFiles and RevisionStore from _Branch
289
    def get_transaction(self):
290
        """Return the current active transaction.
291
292
        If no transaction is active, this returns a passthrough object
293
        for which all data is immediately flushed and no caching happens.
294
        """
295
        if self._transaction is None:
296
            return transactions.PassThroughTransaction()
297
        else:
298
            return self._transaction
299
300
    def _set_transaction(self, new_transaction):
301
        """Set a new active transaction."""
302
        if self._transaction is not None:
303
            raise errors.LockError('Branch %s is in a transaction already.' %
304
                                   self)
305
        self._transaction = new_transaction
306
307
    def _finish_transaction(self):
308
        """Exit the current transaction."""
309
        if self._transaction is None:
310
            raise errors.LockError('Branch %s is not in a transaction' %
311
                                   self)
312
        transaction = self._transaction
313
        self._transaction = None
314
        transaction.finish()
1553.5.40 by Martin Pool
Factor locking strategy out of LockableFiles so that we can use LockDirs in new formats.
315
316
1553.5.45 by Martin Pool
Clean up Transport-based locks for old branches
317
class TransportLock(object):
318
    """Locking method which uses transport-dependent locks.
319
320
    On the local filesystem these transform into OS-managed locks.
321
322
    These do not guard against concurrent access via different
323
    transports.
324
325
    This is suitable for use only in WorkingTrees (which are at present
326
    always local).
1553.5.40 by Martin Pool
Factor locking strategy out of LockableFiles so that we can use LockDirs in new formats.
327
    """
1553.5.59 by Martin Pool
Pass file/mode bits through to creation of lock files/dirs
328
    def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
1553.5.40 by Martin Pool
Factor locking strategy out of LockableFiles so that we can use LockDirs in new formats.
329
        self._transport = transport
330
        self._escaped_name = escaped_name
1553.5.59 by Martin Pool
Pass file/mode bits through to creation of lock files/dirs
331
        self._file_modebits = file_modebits
332
        self._dir_modebits = dir_modebits
1553.5.40 by Martin Pool
Factor locking strategy out of LockableFiles so that we can use LockDirs in new formats.
333
1687.1.6 by Robert Collins
Extend LockableFiles to support break_lock() calls.
334
    def break_lock(self):
335
        raise NotImplementedError(self.break_lock)
336
2018.5.75 by Andrew Bennetts
Add Repository.{dont_,}leave_lock_in_place.
337
    def leave_in_place(self):
338
        raise NotImplementedError(self.leave_in_place)
339
2018.5.76 by Andrew Bennetts
Testing that repository.{dont_,}leave_lock_in_place raises NotImplementedError if lock_write returns None.
340
    def dont_leave_in_place(self):
341
        raise NotImplementedError(self.dont_leave_in_place)
342
2279.7.1 by Andrew Bennetts
``LockableFiles.lock_write()`` now accepts a ``token`` keyword argument, so that
343
    def lock_write(self, token=None):
344
        if token is not None:
345
            raise errors.TokenLockingNotSupported(self)
1553.5.40 by Martin Pool
Factor locking strategy out of LockableFiles so that we can use LockDirs in new formats.
346
        self._lock = self._transport.lock_write(self._escaped_name)
347
348
    def lock_read(self):
349
        self._lock = self._transport.lock_read(self._escaped_name)
350
351
    def unlock(self):
352
        self._lock.unlock()
353
        self._lock = None
354
1694.2.6 by Martin Pool
[merge] bzr.dev
355
    def peek(self):
356
        raise NotImplementedError()
357
1666.1.4 by Robert Collins
* 'Metadir' is now the default disk format. This improves behaviour in
358
    def create(self, mode=None):
1553.5.59 by Martin Pool
Pass file/mode bits through to creation of lock files/dirs
359
        """Create lock mechanism"""
360
        # for old-style locks, create the file now
1955.3.8 by John Arbash Meinel
avoid some deprecation warnings in other parts of the code
361
        self._transport.put_bytes(self._escaped_name, '',
1553.5.60 by Martin Pool
New LockableFiles.create_lock() method
362
                            mode=self._file_modebits)
2279.7.1 by Andrew Bennetts
``LockableFiles.lock_write()`` now accepts a ``token`` keyword argument, so that
363
364
    def validate_token(self, token):
365
        if token is not None:
366
            raise errors.TokenLockingNotSupported(self)
367