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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-05-02 11:53:00 UTC
  • mfrom: (3400.2.1 integrate-1.3)
  • Revision ID: pqm@pqm.ubuntu.com-20080502115300-98iunzq9437108n5
(mbp) merge 1.3.1 news into trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockable_files.py
 
1
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
 
2
#
 
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.
 
7
#
 
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.
 
12
#
 
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
 
 
17
from cStringIO import StringIO
 
18
import codecs
 
19
#import traceback
 
20
from warnings import warn
 
21
 
 
22
import bzrlib
 
23
from bzrlib.decorators import (needs_read_lock,
 
24
        needs_write_lock)
 
25
import bzrlib.errors as errors
 
26
from bzrlib.errors import BzrError
 
27
from bzrlib.osutils import file_iterator, safe_unicode
 
28
from bzrlib.symbol_versioning import (deprecated_method,
 
29
        )
 
30
from bzrlib.trace import mutter, note
 
31
import bzrlib.transactions as transactions
 
32
import bzrlib.urlutils as urlutils
 
33
 
 
34
 
 
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.
 
38
 
 
39
class LockableFiles(object):
 
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
 
 
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
 
 
52
    Instances of this class are often called control_files.
 
53
    
 
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.
 
60
    """
 
61
 
 
62
    # _lock_mode: None, or 'r' or 'w'
 
63
 
 
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
    
 
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
 
71
 
 
72
    def __init__(self, transport, lock_name, lock_class):
 
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.
 
78
        :param lock_class: Class of lock strategy to use: typically
 
79
            either LockDir or TransportLock.
 
80
        """
 
81
        self._transport = transport
 
82
        self.lock_name = lock_name
 
83
        self._transaction = None
 
84
        self._lock_mode = None
 
85
        self._lock_count = 0
 
86
        self._find_modes()
 
87
        esc_name = self._escape(lock_name)
 
88
        self._lock = lock_class(transport, esc_name,
 
89
                                file_modebits=self._file_mode,
 
90
                                dir_modebits=self._dir_mode)
 
91
 
 
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
        """
 
98
        self._lock.create(mode=self._dir_mode)
 
99
 
 
100
    def __repr__(self):
 
101
        return '%s(%r)' % (self.__class__.__name__,
 
102
                           self._transport)
 
103
    def __str__(self):
 
104
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
 
105
 
 
106
    def __del__(self):
 
107
        if self.is_locked():
 
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)
 
111
 
 
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
 
 
119
    def _escape(self, file_or_path):
 
120
        if not isinstance(file_or_path, basestring):
 
121
            file_or_path = '/'.join(file_or_path)
 
122
        if file_or_path == '':
 
123
            return u''
 
124
        return urlutils.escape(safe_unicode(file_or_path))
 
125
 
 
126
    def _find_modes(self):
 
127
        """Determine the appropriate modes for files and directories."""
 
128
        try:
 
129
            st = self._transport.stat('.')
 
130
        except errors.TransportNotPossible:
 
131
            self._dir_mode = 0755
 
132
            self._file_mode = 0644
 
133
        else:
 
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
 
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
 
145
 
 
146
    def controlfilename(self, file_or_path):
 
147
        """Return location relative to branch."""
 
148
        return self._transport.abspath(self._escape(file_or_path))
 
149
 
 
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
 
 
163
    @needs_write_lock
 
164
    def put(self, path, file):
 
165
        """Write a file.
 
166
        
 
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
        """
 
171
        self._transport.put_file(self._escape(path), file, mode=self._file_mode)
 
172
 
 
173
    @needs_write_lock
 
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
 
184
    def put_utf8(self, path, a_string):
 
185
        """Write a string, encoding as utf-8.
 
186
 
 
187
        :param path: The path to put the string, relative to the transport root.
 
188
        :param string: A string or unicode object whose contents should be copied.
 
189
        """
 
190
        # IterableFile would not be needed if Transport.put took iterables
 
191
        # instead of files.  ADHB 2005-12-25
 
192
        # RBC 20060103 surely its not needed anyway, with codecs transcode
 
193
        # file support ?
 
194
        # JAM 20060103 We definitely don't want encode(..., 'replace')
 
195
        # these are valuable files which should have exact contents.
 
196
        if not isinstance(a_string, basestring):
 
197
            raise errors.BzrBadParameterNotString(a_string)
 
198
        self.put_bytes(path, a_string.encode('utf-8'))
 
199
 
 
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
 
 
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.
 
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.
 
222
        """
 
223
        # mutter("lock write: %s (%s)", self, self._lock_count)
 
224
        # TODO: Upgrade locking to support using a Transport,
 
225
        # and potentially a remote locking protocol
 
226
        if self._lock_mode:
 
227
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
 
228
                raise errors.ReadOnlyError(self)
 
229
            self._lock.validate_token(token)
 
230
            self._lock_count += 1
 
231
            return self._token_from_lock
 
232
        else:
 
233
            token_from_lock = self._lock.lock_write(token=token)
 
234
            #note('write locking %s', self)
 
235
            #traceback.print_stack()
 
236
            self._lock_mode = 'w'
 
237
            self._lock_count = 1
 
238
            self._set_transaction(transactions.WriteTransaction())
 
239
            self._token_from_lock = token_from_lock
 
240
            return token_from_lock
 
241
 
 
242
    def lock_read(self):
 
243
        # mutter("lock read: %s (%s)", self, self._lock_count)
 
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:
 
249
            self._lock.lock_read()
 
250
            #note('read locking %s', self)
 
251
            #traceback.print_stack()
 
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):
 
259
        # mutter("unlock: %s (%s)", self, self._lock_count)
 
260
        if not self._lock_mode:
 
261
            raise errors.LockNotHeld(self)
 
262
        if self._lock_count > 1:
 
263
            self._lock_count -= 1
 
264
        else:
 
265
            #note('unlocking %s', self)
 
266
            #traceback.print_stack()
 
267
            self._finish_transaction()
 
268
            try:
 
269
                self._lock.unlock()
 
270
            finally:
 
271
                self._lock_mode = self._lock_count = None
 
272
 
 
273
    def is_locked(self):
 
274
        """Return true if this LockableFiles group is locked"""
 
275
        return self._lock_count >= 1
 
276
 
 
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
 
 
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()
 
315
 
 
316
 
 
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).
 
327
    """
 
328
    def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
 
329
        self._transport = transport
 
330
        self._escaped_name = escaped_name
 
331
        self._file_modebits = file_modebits
 
332
        self._dir_modebits = dir_modebits
 
333
 
 
334
    def break_lock(self):
 
335
        raise NotImplementedError(self.break_lock)
 
336
 
 
337
    def leave_in_place(self):
 
338
        raise NotImplementedError(self.leave_in_place)
 
339
 
 
340
    def dont_leave_in_place(self):
 
341
        raise NotImplementedError(self.dont_leave_in_place)
 
342
 
 
343
    def lock_write(self, token=None):
 
344
        if token is not None:
 
345
            raise errors.TokenLockingNotSupported(self)
 
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
 
 
355
    def peek(self):
 
356
        raise NotImplementedError()
 
357
 
 
358
    def create(self, mode=None):
 
359
        """Create lock mechanism"""
 
360
        # for old-style locks, create the file now
 
361
        self._transport.put_bytes(self._escaped_name, '',
 
362
                            mode=self._file_modebits)
 
363
 
 
364
    def validate_token(self, token):
 
365
        if token is not None:
 
366
            raise errors.TokenLockingNotSupported(self)
 
367