/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: Martin Pool
  • Date: 2006-01-13 06:38:56 UTC
  • mto: (1185.65.28 storage)
  • mto: This revision was merged to the branch mainline in revision 1550.
  • Revision ID: mbp@sourcefrog.net-20060113063856-484eed116191727b
Pass through wrapped function name and docstrign 
in needs_read_lock and needs_write_lock decorators.  Test this works.
(Suggestion from John)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from bzrlib.lazy_import import lazy_import
18
 
lazy_import(globals(), """
19
 
import codecs
20
 
import warnings
21
 
 
22
 
from bzrlib import (
23
 
    counted_lock,
24
 
    errors,
25
 
    lock,
26
 
    osutils,
27
 
    transactions,
28
 
    urlutils,
29
 
    )
30
 
""")
31
 
 
32
 
from bzrlib.decorators import (
33
 
    only_raises,
34
 
    )
35
 
 
36
 
 
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.
40
 
 
41
 
class _LockWarner(object):
42
 
    """Hold a counter for a lock and warn if GCed while the count is >= 1.
43
 
 
44
 
    This is separate from LockableFiles because putting a __del__ on
45
 
    LockableFiles can result in uncollectable cycles.
46
 
    """
47
 
 
48
 
    def __init__(self, repr):
49
 
        self.lock_count = 0
50
 
        self.repr = repr
51
 
 
52
 
    def __del__(self):
53
 
        if self.lock_count >= 1:
54
 
            # There should have been a try/finally to unlock this.
55
 
            warnings.warn("%r was gc'd while locked" % self.repr)
56
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
from osutils import file_iterator
 
19
 
 
20
import bzrlib
 
21
import bzrlib.errors as errors
 
22
from bzrlib.errors import LockError, ReadOnlyError
 
23
from bzrlib.trace import mutter
 
24
import bzrlib.transactions as transactions
57
25
 
58
26
class LockableFiles(object):
59
 
    """Object representing a set of related files locked within the same scope.
60
 
 
61
 
    This coordinates access to the lock along with providing a transaction.
62
 
 
63
 
    LockableFiles manage a lock count and can be locked repeatedly by
64
 
    a single caller.  (The underlying lock implementation generally does not
65
 
    support this.)
66
 
 
67
 
    Instances of this class are often called control_files.
68
 
 
69
 
    This class is now deprecated; code should move to using the Transport
70
 
    directly for file operations and using the lock or CountedLock for
71
 
    locking.
72
 
    
73
 
    :ivar _lock: The real underlying lock (e.g. a LockDir)
74
 
    :ivar _counted_lock: A lock decorated with a semaphore, so that it 
75
 
        can be re-entered.
 
27
    """Object representing a set of files locked within the same scope
 
28
 
 
29
    _lock_mode
 
30
        None, or 'r' or 'w'
 
31
 
 
32
    _lock_count
 
33
        If _lock_mode is true, a positive count of the number of times the
 
34
        lock has been taken *by this process*.  Others may have compatible 
 
35
        read locks.
 
36
 
 
37
    _lock
 
38
        Lock object from bzrlib.lock.
76
39
    """
77
40
 
78
 
    # _lock_mode: None, or 'r' or 'w'
79
 
 
80
 
    # _lock_count: If _lock_mode is true, a positive count of the number of
81
 
    # times the lock has been taken *by this process*.
82
 
 
83
 
    def __init__(self, transport, lock_name, lock_class):
84
 
        """Create a LockableFiles group
85
 
 
86
 
        :param transport: Transport pointing to the directory holding the
87
 
            control files and lock.
88
 
        :param lock_name: Name of the lock guarding these files.
89
 
        :param lock_class: Class of lock strategy to use: typically
90
 
            either LockDir or TransportLock.
91
 
        """
 
41
    _lock_mode = None
 
42
    _lock_count = None
 
43
    _lock = None
 
44
    # If set to False (by a plugin, etc) BzrBranch will not set the
 
45
    # mode on created files or directories
 
46
    _set_file_mode = True
 
47
    _set_dir_mode = True
 
48
 
 
49
    def __init__(self, transport, lock_name):
 
50
        object.__init__(self)
92
51
        self._transport = transport
93
52
        self.lock_name = lock_name
94
53
        self._transaction = None
95
 
        self._lock_mode = None
96
 
        self._lock_warner = _LockWarner(repr(self))
97
54
        self._find_modes()
98
 
        esc_name = self._escape(lock_name)
99
 
        self._lock = lock_class(transport, esc_name,
100
 
                                file_modebits=self._file_mode,
101
 
                                dir_modebits=self._dir_mode)
102
 
        self._counted_lock = counted_lock.CountedLock(self._lock)
103
 
 
104
 
    def create_lock(self):
105
 
        """Create the lock.
106
 
 
107
 
        This should normally be called only when the LockableFiles directory
108
 
        is first created on disk.
109
 
        """
110
 
        self._lock.create(mode=self._dir_mode)
111
 
 
112
 
    def __repr__(self):
113
 
        return '%s(%r)' % (self.__class__.__name__,
114
 
                           self._transport)
115
 
    def __str__(self):
116
 
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
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()
 
55
 
 
56
    def __del__(self):
 
57
        if self._lock_mode or self._lock:
 
58
            # XXX: This should show something every time, and be suitable for
 
59
            # headless operation and embedding
 
60
            from warnings import warn
 
61
            warn("file group %r was not explicitly unlocked" % self)
 
62
            self._lock.unlock()
124
63
 
125
64
    def _escape(self, file_or_path):
126
 
        """DEPRECATED: Do not use outside this class"""
127
65
        if not isinstance(file_or_path, basestring):
128
66
            file_or_path = '/'.join(file_or_path)
129
67
        if file_or_path == '':
130
68
            return u''
131
 
        return urlutils.escape(osutils.safe_unicode(file_or_path))
 
69
        return bzrlib.transport.urlescape(unicode(file_or_path))
132
70
 
133
71
    def _find_modes(self):
134
 
        """Determine the appropriate modes for files and directories.
135
 
 
136
 
        :deprecated: Replaced by BzrDir._find_creation_modes.
137
 
        """
138
 
        # XXX: The properties created by this can be removed or deprecated
139
 
        # once all the _get_text_store methods etc no longer use them.
140
 
        # -- mbp 20080512
 
72
        """Determine the appropriate modes for files and directories."""
141
73
        try:
142
 
            st = self._transport.stat('.')
143
 
        except errors.TransportNotPossible:
 
74
            try:
 
75
                st = self._transport.stat(u'.')
 
76
            except errors.NoSuchFile:
 
77
                # The .bzr/ directory doesn't exist, try to
 
78
                # inherit the permissions from the parent directory
 
79
                # but only try 1 level up
 
80
                temp_transport = self._transport.clone('..')
 
81
                st = temp_transport.stat(u'.')
 
82
        except (errors.TransportNotPossible, errors.NoSuchFile):
144
83
            self._dir_mode = 0755
145
84
            self._file_mode = 0644
146
85
        else:
147
 
            # Check the directory mode, but also make sure the created
148
 
            # directories and files are read-write for this user. This is
149
 
            # mostly a workaround for filesystems which lie about being able to
150
 
            # write to a directory (cygwin & win32)
151
 
            self._dir_mode = (st.st_mode & 07777) | 00700
 
86
            self._dir_mode = st.st_mode & 07777
152
87
            # Remove the sticky and execute bits for files
153
88
            self._file_mode = self._dir_mode & ~07111
154
 
 
155
 
    def leave_in_place(self):
156
 
        """Set this LockableFiles to not clear the physical lock on unlock."""
157
 
        self._lock.leave_in_place()
158
 
 
159
 
    def dont_leave_in_place(self):
160
 
        """Set this LockableFiles to clear the physical lock on unlock."""
161
 
        self._lock.dont_leave_in_place()
162
 
 
163
 
    def lock_write(self, token=None):
164
 
        """Lock this group of files for writing.
165
 
 
166
 
        :param token: if this is already locked, then lock_write will fail
167
 
            unless the token matches the existing lock.
168
 
        :returns: a token if this instance supports tokens, otherwise None.
169
 
        :raises TokenLockingNotSupported: when a token is given but this
170
 
            instance doesn't support using token locks.
171
 
        :raises MismatchedToken: if the specified token doesn't match the token
172
 
            of the existing lock.
173
 
 
174
 
        A token should be passed in if you know that you have locked the object
175
 
        some other way, and need to synchronise this object's state with that
176
 
        fact.
177
 
        """
 
89
        if not self._set_dir_mode:
 
90
            self._dir_mode = None
 
91
        if not self._set_file_mode:
 
92
            self._file_mode = None
 
93
 
 
94
    def controlfilename(self, file_or_path):
 
95
        """Return location relative to branch."""
 
96
        return self._transport.abspath(self._escape(file_or_path))
 
97
 
 
98
    def controlfile(self, file_or_path, mode='r'):
 
99
        """Open a control file for this branch.
 
100
 
 
101
        There are two classes of file in the control directory: text
 
102
        and binary.  binary files are untranslated byte streams.  Text
 
103
        control files are stored with Unix newlines and in UTF-8, even
 
104
        if the platform or locale defaults are different.
 
105
 
 
106
        Controlfiles should almost never be opened in write mode but
 
107
        rather should be atomically copied and replaced using atomicfile.
 
108
        """
 
109
        import codecs
 
110
 
 
111
        relpath = self._escape(file_or_path)
 
112
        #TODO: codecs.open() buffers linewise, so it was overloaded with
 
113
        # a much larger buffer, do we need to do the same for getreader/getwriter?
 
114
        if mode == 'rb': 
 
115
            return self._transport.get(relpath)
 
116
        elif mode == 'wb':
 
117
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put[_utf8]")
 
118
        elif mode == 'r':
 
119
            # XXX: Do we really want errors='replace'?   Perhaps it should be
 
120
            # an error, or at least reported, if there's incorrectly-encoded
 
121
            # data inside a file.
 
122
            # <https://launchpad.net/products/bzr/+bug/3823>
 
123
            return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
 
124
        elif mode == 'w':
 
125
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put[_utf8]")
 
126
        else:
 
127
            raise BzrError("invalid controlfile mode %r" % mode)
 
128
 
 
129
    def put(self, path, file):
 
130
        """Write a file.
 
131
        
 
132
        :param path: The path to put the file, relative to the .bzr control
 
133
                     directory
 
134
        :param f: A file-like or string object whose contents should be copied.
 
135
        """
 
136
        if not self._lock_mode == 'w':
 
137
            raise ReadOnlyError()
 
138
        self._transport.put(self._escape(path), file, mode=self._file_mode)
 
139
 
 
140
    def put_utf8(self, path, file, mode=None):
 
141
        """Write a file, encoding as utf-8.
 
142
 
 
143
        :param path: The path to put the file, relative to the .bzr control
 
144
                     directory
 
145
        :param f: A file-like or string object whose contents should be copied.
 
146
        """
 
147
        import codecs
 
148
        from iterablefile import IterableFile
 
149
        ctrl_files = []
 
150
        if hasattr(file, 'read'):
 
151
            iterator = file_iterator(file)
 
152
        else:
 
153
            iterator = file
 
154
        # IterableFile would not be needed if Transport.put took iterables
 
155
        # instead of files.  ADHB 2005-12-25
 
156
        # RBC 20060103 surely its not needed anyway, with codecs transcode
 
157
        # file support ?
 
158
        # JAM 20060103 We definitely don't want encode(..., 'replace')
 
159
        # these are valuable files which should have exact contents.
 
160
        encoded_file = IterableFile(b.encode('utf-8') for b in 
 
161
                                    iterator)
 
162
        self.put(path, encoded_file)
 
163
 
 
164
    def lock_write(self):
 
165
        mutter("lock write: %s (%s)", self, self._lock_count)
178
166
        # TODO: Upgrade locking to support using a Transport,
179
167
        # and potentially a remote locking protocol
180
168
        if self._lock_mode:
181
 
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
182
 
                raise errors.ReadOnlyError(self)
183
 
            self._lock.validate_token(token)
184
 
            self._lock_warner.lock_count += 1
185
 
            return self._token_from_lock
 
169
            if self._lock_mode != 'w':
 
170
                raise LockError("can't upgrade to a write lock from %r" %
 
171
                                self._lock_mode)
 
172
            self._lock_count += 1
186
173
        else:
187
 
            token_from_lock = self._lock.lock_write(token=token)
188
 
            #traceback.print_stack()
 
174
            self._lock = self._transport.lock_write(
 
175
                    self._escape(self.lock_name))
189
176
            self._lock_mode = 'w'
190
 
            self._lock_warner.lock_count = 1
191
 
            self._set_write_transaction()
192
 
            self._token_from_lock = token_from_lock
193
 
            return token_from_lock
 
177
            self._lock_count = 1
 
178
            self._set_transaction(transactions.PassThroughTransaction())
194
179
 
195
180
    def lock_read(self):
 
181
        mutter("lock read: %s (%s)", self, self._lock_count)
196
182
        if self._lock_mode:
197
 
            if self._lock_mode not in ('r', 'w'):
198
 
                raise ValueError("invalid lock mode %r" % (self._lock_mode,))
199
 
            self._lock_warner.lock_count += 1
 
183
            assert self._lock_mode in ('r', 'w'), \
 
184
                   "invalid lock mode %r" % self._lock_mode
 
185
            self._lock_count += 1
200
186
        else:
201
 
            self._lock.lock_read()
202
 
            #traceback.print_stack()
 
187
            self._lock = self._transport.lock_read(
 
188
                    self._escape(self.lock_name))
203
189
            self._lock_mode = 'r'
204
 
            self._lock_warner.lock_count = 1
205
 
            self._set_read_transaction()
206
 
 
207
 
    def _set_read_transaction(self):
208
 
        """Setup a read transaction."""
209
 
        self._set_transaction(transactions.ReadOnlyTransaction())
210
 
        # 5K may be excessive, but hey, its a knob.
211
 
        self.get_transaction().set_cache_size(5000)
212
 
 
213
 
    def _set_write_transaction(self):
214
 
        """Setup a write transaction."""
215
 
        self._set_transaction(transactions.WriteTransaction())
216
 
 
217
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
190
            self._lock_count = 1
 
191
            self._set_transaction(transactions.ReadOnlyTransaction())
 
192
            # 5K may be excessive, but hey, its a knob.
 
193
            self.get_transaction().set_cache_size(5000)
 
194
                        
218
195
    def unlock(self):
 
196
        mutter("unlock: %s (%s)", self, self._lock_count)
219
197
        if not self._lock_mode:
220
 
            return lock.cant_unlock_not_held(self)
221
 
        if self._lock_warner.lock_count > 1:
222
 
            self._lock_warner.lock_count -= 1
 
198
            raise LockError('branch %r is not locked' % (self))
 
199
 
 
200
        if self._lock_count > 1:
 
201
            self._lock_count -= 1
223
202
        else:
224
 
            #traceback.print_stack()
225
203
            self._finish_transaction()
226
 
            try:
227
 
                self._lock.unlock()
228
 
            finally:
229
 
                self._lock_mode = self._lock_warner.lock_count = None
230
 
 
231
 
    @property
232
 
    def _lock_count(self):
233
 
        return self._lock_warner.lock_count
234
 
 
235
 
    def is_locked(self):
236
 
        """Return true if this LockableFiles group is locked"""
237
 
        return self._lock_warner.lock_count >= 1
238
 
 
239
 
    def get_physical_lock_status(self):
240
 
        """Return physical lock status.
241
 
 
242
 
        Returns true if a lock is held on the transport. If no lock is held, or
243
 
        the underlying locking mechanism does not support querying lock
244
 
        status, false is returned.
245
 
        """
246
 
        try:
247
 
            return self._lock.peek() is not None
248
 
        except NotImplementedError:
249
 
            return False
 
204
            self._lock.unlock()
 
205
            self._lock = None
 
206
            self._lock_mode = self._lock_count = None
250
207
 
251
208
    def get_transaction(self):
252
209
        """Return the current active transaction.
274
231
        transaction = self._transaction
275
232
        self._transaction = None
276
233
        transaction.finish()
277
 
 
278
 
 
279
 
class TransportLock(object):
280
 
    """Locking method which uses transport-dependent locks.
281
 
 
282
 
    On the local filesystem these transform into OS-managed locks.
283
 
 
284
 
    These do not guard against concurrent access via different
285
 
    transports.
286
 
 
287
 
    This is suitable for use only in WorkingTrees (which are at present
288
 
    always local).
289
 
    """
290
 
    def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
291
 
        self._transport = transport
292
 
        self._escaped_name = escaped_name
293
 
        self._file_modebits = file_modebits
294
 
        self._dir_modebits = dir_modebits
295
 
 
296
 
    def break_lock(self):
297
 
        raise NotImplementedError(self.break_lock)
298
 
 
299
 
    def leave_in_place(self):
300
 
        raise NotImplementedError(self.leave_in_place)
301
 
 
302
 
    def dont_leave_in_place(self):
303
 
        raise NotImplementedError(self.dont_leave_in_place)
304
 
 
305
 
    def lock_write(self, token=None):
306
 
        if token is not None:
307
 
            raise errors.TokenLockingNotSupported(self)
308
 
        self._lock = self._transport.lock_write(self._escaped_name)
309
 
 
310
 
    def lock_read(self):
311
 
        self._lock = self._transport.lock_read(self._escaped_name)
312
 
 
313
 
    def unlock(self):
314
 
        self._lock.unlock()
315
 
        self._lock = None
316
 
 
317
 
    def peek(self):
318
 
        raise NotImplementedError()
319
 
 
320
 
    def create(self, mode=None):
321
 
        """Create lock mechanism"""
322
 
        # for old-style locks, create the file now
323
 
        self._transport.put_bytes(self._escaped_name, '',
324
 
                            mode=self._file_modebits)
325
 
 
326
 
    def validate_token(self, token):
327
 
        if token is not None:
328
 
            raise errors.TokenLockingNotSupported(self)
329