~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: John Arbash Meinel
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
from cStringIO import StringIO
 
18
 
 
19
from bzrlib.lazy_import import lazy_import
 
20
lazy_import(globals(), """
18
21
import codecs
19
 
 
20
 
import bzrlib
21
 
from bzrlib.decorators import *
22
 
import bzrlib.errors as errors
23
 
from bzrlib.errors import LockError, ReadOnlyError
24
 
from bzrlib.osutils import file_iterator, safe_unicode
25
 
from bzrlib.symbol_versioning import *
26
 
from bzrlib.symbol_versioning import deprecated_method, zero_eight
27
 
from bzrlib.trace import mutter
28
 
import bzrlib.transactions as transactions
29
 
 
 
22
import warnings
 
23
 
 
24
from bzrlib import (
 
25
    errors,
 
26
    osutils,
 
27
    transactions,
 
28
    urlutils,
 
29
    )
 
30
""")
 
31
 
 
32
from bzrlib.decorators import (
 
33
    needs_read_lock,
 
34
    needs_write_lock,
 
35
    )
 
36
from bzrlib.symbol_versioning import (
 
37
    deprecated_in,
 
38
    deprecated_method,
 
39
    )
 
40
 
 
41
 
 
42
# XXX: The tracking here of lock counts and whether the lock is held is
 
43
# somewhat redundant with what's done in LockDir; the main difference is that
 
44
# LockableFiles permits reentrancy.
30
45
 
31
46
class LockableFiles(object):
32
 
    """Object representing a set of files locked within the same scope
33
 
 
34
 
    _lock_mode
35
 
        None, or 'r' or 'w'
36
 
 
37
 
    _lock_count
38
 
        If _lock_mode is true, a positive count of the number of times the
39
 
        lock has been taken *by this process*.  Others may have compatible 
40
 
        read locks.
41
 
 
42
 
    _lock
43
 
        Lock object from bzrlib.lock.
 
47
    """Object representing a set of related files locked within the same scope.
 
48
 
 
49
    These files are used by a WorkingTree, Repository or Branch, and should
 
50
    generally only be touched by that object.
 
51
 
 
52
    LockableFiles also provides some policy on top of Transport for encoding
 
53
    control files as utf-8.
 
54
 
 
55
    LockableFiles manage a lock count and can be locked repeatedly by
 
56
    a single caller.  (The underlying lock implementation generally does not
 
57
    support this.)
 
58
 
 
59
    Instances of this class are often called control_files.
 
60
    
 
61
    This object builds on top of a Transport, which is used to actually write
 
62
    the files to disk, and an OSLock or LockDir, which controls how access to
 
63
    the files is controlled.  The particular type of locking used is set when
 
64
    the object is constructed.  In older formats OSLocks are used everywhere.
 
65
    in newer formats a LockDir is used for Repositories and Branches, and 
 
66
    OSLocks for the local filesystem.
 
67
 
 
68
    This class is now deprecated; code should move to using the Transport 
 
69
    directly for file operations and using the lock or CountedLock for 
 
70
    locking.
44
71
    """
45
72
 
46
 
    _lock_mode = None
47
 
    _lock_count = None
48
 
    _lock = None
49
 
    # If set to False (by a plugin, etc) BzrBranch will not set the
50
 
    # mode on created files or directories
51
 
    _set_file_mode = True
52
 
    _set_dir_mode = True
53
 
 
54
 
    def __init__(self, transport, lock_name):
55
 
        object.__init__(self)
 
73
    # _lock_mode: None, or 'r' or 'w'
 
74
 
 
75
    # _lock_count: If _lock_mode is true, a positive count of the number of
 
76
    # times the lock has been taken *by this process*.   
 
77
    
 
78
    def __init__(self, transport, lock_name, lock_class):
 
79
        """Create a LockableFiles group
 
80
 
 
81
        :param transport: Transport pointing to the directory holding the 
 
82
            control files and lock.
 
83
        :param lock_name: Name of the lock guarding these files.
 
84
        :param lock_class: Class of lock strategy to use: typically
 
85
            either LockDir or TransportLock.
 
86
        """
56
87
        self._transport = transport
57
88
        self.lock_name = lock_name
58
89
        self._transaction = None
 
90
        self._lock_mode = None
 
91
        self._lock_count = 0
59
92
        self._find_modes()
 
93
        esc_name = self._escape(lock_name)
 
94
        self._lock = lock_class(transport, esc_name,
 
95
                                file_modebits=self._file_mode,
 
96
                                dir_modebits=self._dir_mode)
 
97
 
 
98
    def create_lock(self):
 
99
        """Create the lock.
 
100
 
 
101
        This should normally be called only when the LockableFiles directory
 
102
        is first created on disk.
 
103
        """
 
104
        self._lock.create(mode=self._dir_mode)
 
105
 
 
106
    def __repr__(self):
 
107
        return '%s(%r)' % (self.__class__.__name__,
 
108
                           self._transport)
 
109
    def __str__(self):
 
110
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
60
111
 
61
112
    def __del__(self):
62
 
        if self._lock_mode or self._lock:
63
 
            # XXX: This should show something every time, and be suitable for
64
 
            # headless operation and embedding
65
 
            from warnings import warn
66
 
            warn("file group %r was not explicitly unlocked" % self)
67
 
            self._lock.unlock()
 
113
        if self.is_locked():
 
114
            # do not automatically unlock; there should have been a
 
115
            # try/finally to unlock this.
 
116
            warnings.warn("%r was gc'd while locked" % self)
 
117
 
 
118
    def break_lock(self):
 
119
        """Break the lock of this lockable files group if it is held.
 
120
 
 
121
        The current ui factory will be used to prompt for user conformation.
 
122
        """
 
123
        self._lock.break_lock()
68
124
 
69
125
    def _escape(self, file_or_path):
70
126
        if not isinstance(file_or_path, basestring):
71
127
            file_or_path = '/'.join(file_or_path)
72
128
        if file_or_path == '':
73
129
            return u''
74
 
        return bzrlib.transport.urlescape(safe_unicode(file_or_path))
 
130
        return urlutils.escape(osutils.safe_unicode(file_or_path))
75
131
 
76
132
    def _find_modes(self):
77
 
        """Determine the appropriate modes for files and directories."""
 
133
        """Determine the appropriate modes for files and directories.
 
134
        
 
135
        :deprecated: Replaced by BzrDir._find_modes.
 
136
        """
78
137
        try:
79
 
            try:
80
 
                st = self._transport.stat('.')
81
 
            except errors.NoSuchFile:
82
 
                # The .bzr/ directory doesn't exist, try to
83
 
                # inherit the permissions from the parent directory
84
 
                # but only try 1 level up
85
 
                temp_transport = self._transport.clone('..')
86
 
                st = temp_transport.stat('.')
87
 
        except (errors.TransportNotPossible, errors.NoSuchFile):
 
138
            st = self._transport.stat('.')
 
139
        except errors.TransportNotPossible:
88
140
            self._dir_mode = 0755
89
141
            self._file_mode = 0644
90
142
        else:
91
 
            self._dir_mode = st.st_mode & 07777
 
143
            # Check the directory mode, but also make sure the created
 
144
            # directories and files are read-write for this user. This is
 
145
            # mostly a workaround for filesystems which lie about being able to
 
146
            # write to a directory (cygwin & win32)
 
147
            self._dir_mode = (st.st_mode & 07777) | 00700
92
148
            # Remove the sticky and execute bits for files
93
149
            self._file_mode = self._dir_mode & ~07111
94
 
        if not self._set_dir_mode:
95
 
            self._dir_mode = None
96
 
        if not self._set_file_mode:
97
 
            self._file_mode = None
98
150
 
 
151
    @deprecated_method(deprecated_in((1, 6, 0)))
99
152
    def controlfilename(self, file_or_path):
100
 
        """Return location relative to branch."""
 
153
        """Return location relative to branch.
 
154
        
 
155
        :deprecated: Use Transport methods instead.
 
156
        """
101
157
        return self._transport.abspath(self._escape(file_or_path))
102
158
 
103
 
    @deprecated_method(zero_eight)
104
 
    def controlfile(self, file_or_path, mode='r'):
105
 
        """Open a control file for this branch.
106
 
 
107
 
        There are two classes of file in a lockable directory: text
108
 
        and binary.  binary files are untranslated byte streams.  Text
109
 
        control files are stored with Unix newlines and in UTF-8, even
110
 
        if the platform or locale defaults are different.
111
 
 
112
 
        Such files are not openable in write mode : they are managed via
113
 
        put and put_utf8 which atomically replace old versions using
114
 
        atomicfile.
115
 
        """
116
 
 
117
 
        relpath = self._escape(file_or_path)
118
 
        #TODO: codecs.open() buffers linewise, so it was overloaded with
119
 
        # a much larger buffer, do we need to do the same for getreader/getwriter?
120
 
        if mode == 'rb': 
121
 
            return self.get(relpath)
122
 
        elif mode == 'wb':
123
 
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put[_utf8]")
124
 
        elif mode == 'r':
125
 
            return self.get_utf8(relpath)
126
 
        elif mode == 'w':
127
 
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put[_utf8]")
128
 
        else:
129
 
            raise BzrError("invalid controlfile mode %r" % mode)
130
 
 
131
159
    @needs_read_lock
 
160
    @deprecated_method(deprecated_in((1, 5, 0)))
132
161
    def get(self, relpath):
133
 
        """Get a file as a bytestream."""
 
162
        """Get a file as a bytestream.
 
163
        
 
164
        :deprecated: Use a Transport instead of LockableFiles.
 
165
        """
134
166
        relpath = self._escape(relpath)
135
167
        return self._transport.get(relpath)
136
168
 
137
169
    @needs_read_lock
 
170
    @deprecated_method(deprecated_in((1, 5, 0)))
138
171
    def get_utf8(self, relpath):
139
 
        """Get a file as a unicode stream."""
 
172
        """Get a file as a unicode stream.
 
173
        
 
174
        :deprecated: Use a Transport instead of LockableFiles.
 
175
        """
140
176
        relpath = self._escape(relpath)
141
177
        # DO NOT introduce an errors=replace here.
142
178
        return codecs.getreader('utf-8')(self._transport.get(relpath))
143
179
 
144
180
    @needs_write_lock
 
181
    @deprecated_method(deprecated_in((1, 6, 0)))
145
182
    def put(self, path, file):
146
183
        """Write a file.
147
184
        
148
185
        :param path: The path to put the file, relative to the .bzr control
149
186
                     directory
150
 
        :param f: A file-like or string object whose contents should be copied.
151
 
        """
152
 
        self._transport.put(self._escape(path), file, mode=self._file_mode)
153
 
 
154
 
    @needs_write_lock
 
187
        :param file: A file-like or string object whose contents should be copied.
 
188
 
 
189
        :deprecated: Use Transport methods instead.
 
190
        """
 
191
        self._transport.put_file(self._escape(path), file, mode=self._file_mode)
 
192
 
 
193
    @needs_write_lock
 
194
    @deprecated_method(deprecated_in((1, 6, 0)))
 
195
    def put_bytes(self, path, a_string):
 
196
        """Write a string of bytes.
 
197
 
 
198
        :param path: The path to put the bytes, relative to the transport root.
 
199
        :param a_string: A string object, whose exact bytes are to be copied.
 
200
 
 
201
        :deprecated: Use Transport methods instead.
 
202
        """
 
203
        self._transport.put_bytes(self._escape(path), a_string,
 
204
                                  mode=self._file_mode)
 
205
 
 
206
    @needs_write_lock
 
207
    @deprecated_method(deprecated_in((1, 6, 0)))
155
208
    def put_utf8(self, path, a_string):
156
209
        """Write a string, encoding as utf-8.
157
210
 
158
211
        :param path: The path to put the string, relative to the transport root.
159
 
        :param string: A file-like or string object whose contents should be copied.
 
212
        :param string: A string or unicode object whose contents should be copied.
 
213
 
 
214
        :deprecated: Use Transport methods instead.
160
215
        """
161
216
        # IterableFile would not be needed if Transport.put took iterables
162
217
        # instead of files.  ADHB 2005-12-25
166
221
        # these are valuable files which should have exact contents.
167
222
        if not isinstance(a_string, basestring):
168
223
            raise errors.BzrBadParameterNotString(a_string)
169
 
        self.put(path, StringIO(a_string.encode('utf-8')))
170
 
 
171
 
    def lock_write(self):
172
 
        mutter("lock write: %s (%s)", self, self._lock_count)
 
224
        self.put_bytes(path, a_string.encode('utf-8'))
 
225
 
 
226
    def leave_in_place(self):
 
227
        """Set this LockableFiles to not clear the physical lock on unlock."""
 
228
        self._lock.leave_in_place()
 
229
 
 
230
    def dont_leave_in_place(self):
 
231
        """Set this LockableFiles to clear the physical lock on unlock."""
 
232
        self._lock.dont_leave_in_place()
 
233
 
 
234
    def lock_write(self, token=None):
 
235
        """Lock this group of files for writing.
 
236
        
 
237
        :param token: if this is already locked, then lock_write will fail
 
238
            unless the token matches the existing lock.
 
239
        :returns: a token if this instance supports tokens, otherwise None.
 
240
        :raises TokenLockingNotSupported: when a token is given but this
 
241
            instance doesn't support using token locks.
 
242
        :raises MismatchedToken: if the specified token doesn't match the token
 
243
            of the existing lock.
 
244
 
 
245
        A token should be passed in if you know that you have locked the object
 
246
        some other way, and need to synchronise this object's state with that
 
247
        fact.
 
248
        """
173
249
        # TODO: Upgrade locking to support using a Transport,
174
250
        # and potentially a remote locking protocol
175
251
        if self._lock_mode:
176
 
            if self._lock_mode != 'w':
177
 
                raise ReadOnlyError("can't upgrade to a write lock from %r" %
178
 
                                self._lock_mode)
 
252
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
 
253
                raise errors.ReadOnlyError(self)
 
254
            self._lock.validate_token(token)
179
255
            self._lock_count += 1
 
256
            return self._token_from_lock
180
257
        else:
181
 
            self._lock = self._transport.lock_write(
182
 
                    self._escape(self.lock_name))
 
258
            token_from_lock = self._lock.lock_write(token=token)
 
259
            #traceback.print_stack()
183
260
            self._lock_mode = 'w'
184
261
            self._lock_count = 1
185
 
            self._set_transaction(transactions.PassThroughTransaction())
 
262
            self._set_transaction(transactions.WriteTransaction())
 
263
            self._token_from_lock = token_from_lock
 
264
            return token_from_lock
186
265
 
187
266
    def lock_read(self):
188
 
        mutter("lock read: %s (%s)", self, self._lock_count)
189
267
        if self._lock_mode:
190
 
            assert self._lock_mode in ('r', 'w'), \
191
 
                   "invalid lock mode %r" % self._lock_mode
 
268
            if self._lock_mode not in ('r', 'w'):
 
269
                raise ValueError("invalid lock mode %r" % (self._lock_mode,))
192
270
            self._lock_count += 1
193
271
        else:
194
 
            self._lock = self._transport.lock_read(
195
 
                    self._escape(self.lock_name))
 
272
            self._lock.lock_read()
 
273
            #traceback.print_stack()
196
274
            self._lock_mode = 'r'
197
275
            self._lock_count = 1
198
276
            self._set_transaction(transactions.ReadOnlyTransaction())
200
278
            self.get_transaction().set_cache_size(5000)
201
279
                        
202
280
    def unlock(self):
203
 
        mutter("unlock: %s (%s)", self, self._lock_count)
204
281
        if not self._lock_mode:
205
 
            raise LockError('branch %r is not locked' % (self))
206
 
 
 
282
            raise errors.LockNotHeld(self)
207
283
        if self._lock_count > 1:
208
284
            self._lock_count -= 1
209
285
        else:
 
286
            #traceback.print_stack()
210
287
            self._finish_transaction()
211
 
            self._lock.unlock()
212
 
            self._lock = None
213
 
            self._lock_mode = self._lock_count = None
 
288
            try:
 
289
                self._lock.unlock()
 
290
            finally:
 
291
                self._lock_mode = self._lock_count = None
 
292
 
 
293
    def is_locked(self):
 
294
        """Return true if this LockableFiles group is locked"""
 
295
        return self._lock_count >= 1
 
296
 
 
297
    def get_physical_lock_status(self):
 
298
        """Return physical lock status.
 
299
        
 
300
        Returns true if a lock is held on the transport. If no lock is held, or
 
301
        the underlying locking mechanism does not support querying lock
 
302
        status, false is returned.
 
303
        """
 
304
        try:
 
305
            return self._lock.peek() is not None
 
306
        except NotImplementedError:
 
307
            return False
214
308
 
215
309
    def get_transaction(self):
216
310
        """Return the current active transaction.
238
332
        transaction = self._transaction
239
333
        self._transaction = None
240
334
        transaction.finish()
 
335
 
 
336
 
 
337
class TransportLock(object):
 
338
    """Locking method which uses transport-dependent locks.
 
339
 
 
340
    On the local filesystem these transform into OS-managed locks.
 
341
 
 
342
    These do not guard against concurrent access via different
 
343
    transports.
 
344
 
 
345
    This is suitable for use only in WorkingTrees (which are at present
 
346
    always local).
 
347
    """
 
348
    def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
 
349
        self._transport = transport
 
350
        self._escaped_name = escaped_name
 
351
        self._file_modebits = file_modebits
 
352
        self._dir_modebits = dir_modebits
 
353
 
 
354
    def break_lock(self):
 
355
        raise NotImplementedError(self.break_lock)
 
356
 
 
357
    def leave_in_place(self):
 
358
        raise NotImplementedError(self.leave_in_place)
 
359
 
 
360
    def dont_leave_in_place(self):
 
361
        raise NotImplementedError(self.dont_leave_in_place)
 
362
 
 
363
    def lock_write(self, token=None):
 
364
        if token is not None:
 
365
            raise errors.TokenLockingNotSupported(self)
 
366
        self._lock = self._transport.lock_write(self._escaped_name)
 
367
 
 
368
    def lock_read(self):
 
369
        self._lock = self._transport.lock_read(self._escaped_name)
 
370
 
 
371
    def unlock(self):
 
372
        self._lock.unlock()
 
373
        self._lock = None
 
374
 
 
375
    def peek(self):
 
376
        raise NotImplementedError()
 
377
 
 
378
    def create(self, mode=None):
 
379
        """Create lock mechanism"""
 
380
        # for old-style locks, create the file now
 
381
        self._transport.put_bytes(self._escaped_name, '',
 
382
                            mode=self._file_modebits)
 
383
 
 
384
    def validate_token(self, token):
 
385
        if token is not None:
 
386
            raise errors.TokenLockingNotSupported(self)
 
387