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