1
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
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.
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.
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
17
from cStringIO import StringIO
19
from bzrlib.lazy_import import lazy_import
20
lazy_import(globals(), """
34
from bzrlib.decorators import (
37
from bzrlib.symbol_versioning import (
43
# XXX: The tracking here of lock counts and whether the lock is held is
44
# somewhat redundant with what's done in LockDir; the main difference is that
45
# LockableFiles permits reentrancy.
47
class _LockWarner(object):
48
"""Hold a counter for a lock and warn if GCed while the count is >= 1.
50
This is separate from LockableFiles because putting a __del__ on
51
LockableFiles can result in uncollectable cycles.
54
def __init__(self, repr):
59
if self.lock_count >= 1:
60
# There should have been a try/finally to unlock this.
61
warnings.warn("%r was gc'd while locked" % self.repr)
64
class LockableFiles(object):
65
"""Object representing a set of related files locked within the same scope.
67
This coordinates access to the lock along with providing a transaction.
69
LockableFiles manage a lock count and can be locked repeatedly by
70
a single caller. (The underlying lock implementation generally does not
73
Instances of this class are often called control_files.
75
This class is now deprecated; code should move to using the Transport
76
directly for file operations and using the lock or CountedLock for
79
:ivar _lock: The real underlying lock (e.g. a LockDir)
80
:ivar _counted_lock: A lock decorated with a semaphore, so that it
84
# _lock_mode: None, or 'r' or 'w'
86
# _lock_count: If _lock_mode is true, a positive count of the number of
87
# times the lock has been taken *by this process*.
89
def __init__(self, transport, lock_name, lock_class):
90
"""Create a LockableFiles group
92
:param transport: Transport pointing to the directory holding the
93
control files and lock.
94
:param lock_name: Name of the lock guarding these files.
95
:param lock_class: Class of lock strategy to use: typically
96
either LockDir or TransportLock.
98
self._transport = transport
99
self.lock_name = lock_name
100
self._transaction = None
101
self._lock_mode = None
102
self._lock_warner = _LockWarner(repr(self))
104
esc_name = self._escape(lock_name)
105
self._lock = lock_class(transport, esc_name,
106
file_modebits=self._file_mode,
107
dir_modebits=self._dir_mode)
108
self._counted_lock = counted_lock.CountedLock(self._lock)
110
def create_lock(self):
113
This should normally be called only when the LockableFiles directory
114
is first created on disk.
116
self._lock.create(mode=self._dir_mode)
119
return '%s(%r)' % (self.__class__.__name__,
122
return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
124
def break_lock(self):
125
"""Break the lock of this lockable files group if it is held.
127
The current ui factory will be used to prompt for user conformation.
129
self._lock.break_lock()
131
def _escape(self, file_or_path):
132
"""DEPRECATED: Do not use outside this class"""
133
if not isinstance(file_or_path, basestring):
134
file_or_path = '/'.join(file_or_path)
135
if file_or_path == '':
137
return urlutils.escape(osutils.safe_unicode(file_or_path))
139
def _find_modes(self):
140
"""Determine the appropriate modes for files and directories.
142
:deprecated: Replaced by BzrDir._find_creation_modes.
144
# XXX: The properties created by this can be removed or deprecated
145
# once all the _get_text_store methods etc no longer use them.
148
st = self._transport.stat('.')
149
except errors.TransportNotPossible:
150
self._dir_mode = 0755
151
self._file_mode = 0644
153
# Check the directory mode, but also make sure the created
154
# directories and files are read-write for this user. This is
155
# mostly a workaround for filesystems which lie about being able to
156
# write to a directory (cygwin & win32)
157
self._dir_mode = (st.st_mode & 07777) | 00700
158
# Remove the sticky and execute bits for files
159
self._file_mode = self._dir_mode & ~07111
161
def leave_in_place(self):
162
"""Set this LockableFiles to not clear the physical lock on unlock."""
163
self._lock.leave_in_place()
165
def dont_leave_in_place(self):
166
"""Set this LockableFiles to clear the physical lock on unlock."""
167
self._lock.dont_leave_in_place()
169
def lock_write(self, token=None):
170
"""Lock this group of files for writing.
172
:param token: if this is already locked, then lock_write will fail
173
unless the token matches the existing lock.
174
:returns: a token if this instance supports tokens, otherwise None.
175
:raises TokenLockingNotSupported: when a token is given but this
176
instance doesn't support using token locks.
177
:raises MismatchedToken: if the specified token doesn't match the token
178
of the existing lock.
180
A token should be passed in if you know that you have locked the object
181
some other way, and need to synchronise this object's state with that
184
# TODO: Upgrade locking to support using a Transport,
185
# and potentially a remote locking protocol
187
if self._lock_mode != 'w' or not self.get_transaction().writeable():
188
raise errors.ReadOnlyError(self)
189
self._lock.validate_token(token)
190
self._lock_warner.lock_count += 1
191
return self._token_from_lock
193
token_from_lock = self._lock.lock_write(token=token)
194
#traceback.print_stack()
195
self._lock_mode = 'w'
196
self._lock_warner.lock_count = 1
197
self._set_write_transaction()
198
self._token_from_lock = token_from_lock
199
return token_from_lock
203
if self._lock_mode not in ('r', 'w'):
204
raise ValueError("invalid lock mode %r" % (self._lock_mode,))
205
self._lock_warner.lock_count += 1
207
self._lock.lock_read()
208
#traceback.print_stack()
209
self._lock_mode = 'r'
210
self._lock_warner.lock_count = 1
211
self._set_read_transaction()
213
def _set_read_transaction(self):
214
"""Setup a read transaction."""
215
self._set_transaction(transactions.ReadOnlyTransaction())
216
# 5K may be excessive, but hey, its a knob.
217
self.get_transaction().set_cache_size(5000)
219
def _set_write_transaction(self):
220
"""Setup a write transaction."""
221
self._set_transaction(transactions.WriteTransaction())
223
@only_raises(errors.LockNotHeld, errors.LockBroken)
225
if not self._lock_mode:
226
return lock.cant_unlock_not_held(self)
227
if self._lock_warner.lock_count > 1:
228
self._lock_warner.lock_count -= 1
230
#traceback.print_stack()
231
self._finish_transaction()
235
self._lock_mode = self._lock_warner.lock_count = None
238
def _lock_count(self):
239
return self._lock_warner.lock_count
242
"""Return true if this LockableFiles group is locked"""
243
return self._lock_warner.lock_count >= 1
245
def get_physical_lock_status(self):
246
"""Return physical lock status.
248
Returns true if a lock is held on the transport. If no lock is held, or
249
the underlying locking mechanism does not support querying lock
250
status, false is returned.
253
return self._lock.peek() is not None
254
except NotImplementedError:
257
def get_transaction(self):
258
"""Return the current active transaction.
260
If no transaction is active, this returns a passthrough object
261
for which all data is immediately flushed and no caching happens.
263
if self._transaction is None:
264
return transactions.PassThroughTransaction()
266
return self._transaction
268
def _set_transaction(self, new_transaction):
269
"""Set a new active transaction."""
270
if self._transaction is not None:
271
raise errors.LockError('Branch %s is in a transaction already.' %
273
self._transaction = new_transaction
275
def _finish_transaction(self):
276
"""Exit the current transaction."""
277
if self._transaction is None:
278
raise errors.LockError('Branch %s is not in a transaction' %
280
transaction = self._transaction
281
self._transaction = None
285
class TransportLock(object):
286
"""Locking method which uses transport-dependent locks.
288
On the local filesystem these transform into OS-managed locks.
290
These do not guard against concurrent access via different
293
This is suitable for use only in WorkingTrees (which are at present
296
def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
297
self._transport = transport
298
self._escaped_name = escaped_name
299
self._file_modebits = file_modebits
300
self._dir_modebits = dir_modebits
302
def break_lock(self):
303
raise NotImplementedError(self.break_lock)
305
def leave_in_place(self):
306
raise NotImplementedError(self.leave_in_place)
308
def dont_leave_in_place(self):
309
raise NotImplementedError(self.dont_leave_in_place)
311
def lock_write(self, token=None):
312
if token is not None:
313
raise errors.TokenLockingNotSupported(self)
314
self._lock = self._transport.lock_write(self._escaped_name)
317
self._lock = self._transport.lock_read(self._escaped_name)
324
raise NotImplementedError()
326
def create(self, mode=None):
327
"""Create lock mechanism"""
328
# for old-style locks, create the file now
329
self._transport.put_bytes(self._escaped_name, '',
330
mode=self._file_modebits)
332
def validate_token(self, token):
333
if token is not None:
334
raise errors.TokenLockingNotSupported(self)
added
removed
bzrlib/lockable_files.py
