← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: Martin Pool
  • Date: 2005-09-15 08:37:41 UTC
  • Revision ID: mbp@sourcefrog.net-20050915083741-70d7550b97c7b580
- some updates for fetch/update function

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockable_files.py
1
 
# Copyright (C) 2005-2011 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., 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 warnings
20
 
 
21
 
from bzrlib import (
22
 
    counted_lock,
23
 
    errors,
24
 
    lock,
25
 
    osutils,
26
 
    transactions,
27
 
    urlutils,
28
 
    )
29
 
""")
30
 
 
31
 
from bzrlib.decorators import (
32
 
    only_raises,
33
 
    )
34
 
 
35
 
 
36
 
class LockableFiles(object):
37
 
    """Object representing a set of related files locked within the same scope.
38
 
 
39
 
    This coordinates access to the lock along with providing a transaction.
40
 
 
41
 
    LockableFiles manage a lock count and can be locked repeatedly by
42
 
    a single caller.  (The underlying lock implementation generally does not
43
 
    support this.)
44
 
 
45
 
    Instances of this class are often called control_files.
46
 
 
47
 
    This class is now deprecated; code should move to using the Transport
48
 
    directly for file operations and using the lock or CountedLock for
49
 
    locking.
50
 
 
51
 
    :ivar _lock: The real underlying lock (e.g. a LockDir)
52
 
    :ivar _lock_count: If _lock_mode is true, a positive count of the number
53
 
        of times the lock has been taken (and not yet released) *by this
54
 
        process*, through this particular object instance.
55
 
    :ivar _lock_mode: None, or 'r' or 'w'
56
 
    """
57
 
 
58
 
    def __init__(self, transport, lock_name, lock_class):
59
 
        """Create a LockableFiles group
60
 
 
61
 
        :param transport: Transport pointing to the directory holding the
62
 
            control files and lock.
63
 
        :param lock_name: Name of the lock guarding these files.
64
 
        :param lock_class: Class of lock strategy to use: typically
65
 
            either LockDir or TransportLock.
66
 
        """
67
 
        self._transport = transport
68
 
        self.lock_name = lock_name
69
 
        self._transaction = None
70
 
        self._lock_mode = None
71
 
        self._lock_count = 0
72
 
        self._find_modes()
73
 
        esc_name = self._escape(lock_name)
74
 
        self._lock = lock_class(transport, esc_name,
75
 
                                file_modebits=self._file_mode,
76
 
                                dir_modebits=self._dir_mode)
77
 
        self._counted_lock = counted_lock.CountedLock(self._lock)
78
 
 
79
 
    def create_lock(self):
80
 
        """Create the lock.
81
 
 
82
 
        This should normally be called only when the LockableFiles directory
83
 
        is first created on disk.
84
 
        """
85
 
        self._lock.create(mode=self._dir_mode)
86
 
 
87
 
    def __repr__(self):
88
 
        return '%s(%r)' % (self.__class__.__name__,
89
 
                           self._transport)
90
 
 
91
 
    def __str__(self):
92
 
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
93
 
 
94
 
    def break_lock(self):
95
 
        """Break the lock of this lockable files group if it is held.
96
 
 
97
 
        The current ui factory will be used to prompt for user conformation.
98
 
        """
99
 
        self._lock.break_lock()
100
 
 
101
 
    def _escape(self, file_or_path):
102
 
        """DEPRECATED: Do not use outside this class"""
103
 
        if not isinstance(file_or_path, basestring):
104
 
            file_or_path = '/'.join(file_or_path)
105
 
        if file_or_path == '':
106
 
            return u''
107
 
        return urlutils.escape(osutils.safe_unicode(file_or_path))
108
 
 
109
 
    def _find_modes(self):
110
 
        """Determine the appropriate modes for files and directories.
111
 
 
112
 
        :deprecated: Replaced by BzrDir._find_creation_modes.
113
 
        """
114
 
        # XXX: The properties created by this can be removed or deprecated
115
 
        # once all the _get_text_store methods etc no longer use them.
116
 
        # -- mbp 20080512
117
 
        try:
118
 
            st = self._transport.stat('.')
119
 
        except errors.TransportNotPossible:
120
 
            self._dir_mode = 0755
121
 
            self._file_mode = 0644
122
 
        else:
123
 
            # Check the directory mode, but also make sure the created
124
 
            # directories and files are read-write for this user. This is
125
 
            # mostly a workaround for filesystems which lie about being able to
126
 
            # write to a directory (cygwin & win32)
127
 
            self._dir_mode = (st.st_mode & 07777) | 00700
128
 
            # Remove the sticky and execute bits for files
129
 
            self._file_mode = self._dir_mode & ~07111
130
 
 
131
 
    def leave_in_place(self):
132
 
        """Set this LockableFiles to not clear the physical lock on unlock."""
133
 
        self._lock.leave_in_place()
134
 
 
135
 
    def dont_leave_in_place(self):
136
 
        """Set this LockableFiles to clear the physical lock on unlock."""
137
 
        self._lock.dont_leave_in_place()
138
 
 
139
 
    def lock_write(self, token=None):
140
 
        """Lock this group of files for writing.
141
 
 
142
 
        :param token: if this is already locked, then lock_write will fail
143
 
            unless the token matches the existing lock.
144
 
        :returns: a token if this instance supports tokens, otherwise None.
145
 
        :raises TokenLockingNotSupported: when a token is given but this
146
 
            instance doesn't support using token locks.
147
 
        :raises MismatchedToken: if the specified token doesn't match the token
148
 
            of the existing lock.
149
 
 
150
 
        A token should be passed in if you know that you have locked the object
151
 
        some other way, and need to synchronise this object's state with that
152
 
        fact.
153
 
        """
154
 
        if self._lock_mode:
155
 
            if (self._lock_mode != 'w'
156
 
                or not self.get_transaction().writeable()):
157
 
                raise errors.ReadOnlyError(self)
158
 
            self._lock.validate_token(token)
159
 
            self._lock_count += 1
160
 
            return self._token_from_lock
161
 
        else:
162
 
            token_from_lock = self._lock.lock_write(token=token)
163
 
            #traceback.print_stack()
164
 
            self._lock_mode = 'w'
165
 
            self._lock_count = 1
166
 
            self._set_write_transaction()
167
 
            self._token_from_lock = token_from_lock
168
 
            return token_from_lock
169
 
 
170
 
    def lock_read(self):
171
 
        if self._lock_mode:
172
 
            if self._lock_mode not in ('r', 'w'):
173
 
                raise ValueError("invalid lock mode %r" % (self._lock_mode,))
174
 
            self._lock_count += 1
175
 
        else:
176
 
            self._lock.lock_read()
177
 
            #traceback.print_stack()
178
 
            self._lock_mode = 'r'
179
 
            self._lock_count = 1
180
 
            self._set_read_transaction()
181
 
 
182
 
    def _set_read_transaction(self):
183
 
        """Setup a read transaction."""
184
 
        self._set_transaction(transactions.ReadOnlyTransaction())
185
 
        # 5K may be excessive, but hey, its a knob.
186
 
        self.get_transaction().set_cache_size(5000)
187
 
 
188
 
    def _set_write_transaction(self):
189
 
        """Setup a write transaction."""
190
 
        self._set_transaction(transactions.WriteTransaction())
191
 
 
192
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
193
 
    def unlock(self):
194
 
        if not self._lock_mode:
195
 
            return lock.cant_unlock_not_held(self)
196
 
        if self._lock_count > 1:
197
 
            self._lock_count -= 1
198
 
        else:
199
 
            #traceback.print_stack()
200
 
            self._finish_transaction()
201
 
            try:
202
 
                self._lock.unlock()
203
 
            finally:
204
 
                self._lock_mode = self._lock_count = None
205
 
 
206
 
    def is_locked(self):
207
 
        """Return true if this LockableFiles group is locked"""
208
 
        return self._lock_count >= 1
209
 
 
210
 
    def get_physical_lock_status(self):
211
 
        """Return physical lock status.
212
 
 
213
 
        Returns true if a lock is held on the transport. If no lock is held, or
214
 
        the underlying locking mechanism does not support querying lock
215
 
        status, false is returned.
216
 
        """
217
 
        try:
218
 
            return self._lock.peek() is not None
219
 
        except NotImplementedError:
220
 
            return False
221
 
 
222
 
    def get_transaction(self):
223
 
        """Return the current active transaction.
224
 
 
225
 
        If no transaction is active, this returns a passthrough object
226
 
        for which all data is immediately flushed and no caching happens.
227
 
        """
228
 
        if self._transaction is None:
229
 
            return transactions.PassThroughTransaction()
230
 
        else:
231
 
            return self._transaction
232
 
 
233
 
    def _set_transaction(self, new_transaction):
234
 
        """Set a new active transaction."""
235
 
        if self._transaction is not None:
236
 
            raise errors.LockError('Branch %s is in a transaction already.' %
237
 
                                   self)
238
 
        self._transaction = new_transaction
239
 
 
240
 
    def _finish_transaction(self):
241
 
        """Exit the current transaction."""
242
 
        if self._transaction is None:
243
 
            raise errors.LockError('Branch %s is not in a transaction' %
244
 
                                   self)
245
 
        transaction = self._transaction
246
 
        self._transaction = None
247
 
        transaction.finish()
248
 
 
249
 
 
250
 
class TransportLock(object):
251
 
    """Locking method which uses transport-dependent locks.
252
 
 
253
 
    On the local filesystem these transform into OS-managed locks.
254
 
 
255
 
    These do not guard against concurrent access via different
256
 
    transports.
257
 
 
258
 
    This is suitable for use only in WorkingTrees (which are at present
259
 
    always local).
260
 
    """
261
 
    def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
262
 
        self._transport = transport
263
 
        self._escaped_name = escaped_name
264
 
        self._file_modebits = file_modebits
265
 
        self._dir_modebits = dir_modebits
266
 
 
267
 
    def break_lock(self):
268
 
        raise NotImplementedError(self.break_lock)
269
 
 
270
 
    def leave_in_place(self):
271
 
        raise NotImplementedError(self.leave_in_place)
272
 
 
273
 
    def dont_leave_in_place(self):
274
 
        raise NotImplementedError(self.dont_leave_in_place)
275
 
 
276
 
    def lock_write(self, token=None):
277
 
        if token is not None:
278
 
            raise errors.TokenLockingNotSupported(self)
279
 
        self._lock = self._transport.lock_write(self._escaped_name)
280
 
 
281
 
    def lock_read(self):
282
 
        self._lock = self._transport.lock_read(self._escaped_name)
283
 
 
284
 
    def unlock(self):
285
 
        self._lock.unlock()
286
 
        self._lock = None
287
 
 
288
 
    def peek(self):
289
 
        raise NotImplementedError()
290
 
 
291
 
    def create(self, mode=None):
292
 
        """Create lock mechanism"""
293
 
        # for old-style locks, create the file now
294
 
        self._transport.put_bytes(self._escaped_name, '',
295
 
                            mode=self._file_modebits)
296
 
 
297
 
    def validate_token(self, token):
298
 
        if token is not None:
299
 
            raise errors.TokenLockingNotSupported(self)