1
# Copyright (C) 2005-2011 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 __future__ import absolute_import
19
from .lazy_import import lazy_import
20
lazy_import(globals(), """
33
from .decorators import (
38
class LockableFiles(object):
39
"""Object representing a set of related files locked within the same scope.
41
This coordinates access to the lock along with providing a transaction.
43
LockableFiles manage a lock count and can be locked repeatedly by
44
a single caller. (The underlying lock implementation generally does not
47
Instances of this class are often called control_files.
49
This class is now deprecated; code should move to using the Transport
50
directly for file operations and using the lock or CountedLock for
53
:ivar _lock: The real underlying lock (e.g. a LockDir)
54
:ivar _lock_count: If _lock_mode is true, a positive count of the number
55
of times the lock has been taken (and not yet released) *by this
56
process*, through this particular object instance.
57
:ivar _lock_mode: None, or 'r' or 'w'
60
def __init__(self, transport, lock_name, lock_class):
61
"""Create a LockableFiles group
63
:param transport: Transport pointing to the directory holding the
64
control files and lock.
65
:param lock_name: Name of the lock guarding these files.
66
:param lock_class: Class of lock strategy to use: typically
67
either LockDir or TransportLock.
69
self._transport = transport
70
self.lock_name = lock_name
71
self._transaction = None
72
self._lock_mode = None
75
esc_name = self._escape(lock_name)
76
self._lock = lock_class(transport, esc_name,
77
file_modebits=self._file_mode,
78
dir_modebits=self._dir_mode)
79
self._counted_lock = counted_lock.CountedLock(self._lock)
81
def create_lock(self):
84
This should normally be called only when the LockableFiles directory
85
is first created on disk.
87
self._lock.create(mode=self._dir_mode)
90
return '%s(%r)' % (self.__class__.__name__,
94
return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
97
"""Break the lock of this lockable files group if it is held.
99
The current ui factory will be used to prompt for user conformation.
101
self._lock.break_lock()
103
def _escape(self, file_or_path):
104
"""DEPRECATED: Do not use outside this class"""
105
if file_or_path == '':
107
return urlutils.escape(file_or_path)
109
def _find_modes(self):
110
"""Determine the appropriate modes for files and directories.
112
:deprecated: Replaced by BzrDir._find_creation_modes.
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.
118
st = self._transport.stat('.')
119
except errors.TransportNotPossible:
120
self._dir_mode = 0o755
121
self._file_mode = 0o644
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 & 0o7777) | 0o0700
128
# Remove the sticky and execute bits for files
129
self._file_mode = self._dir_mode & ~0o7111
131
def leave_in_place(self):
132
"""Set this LockableFiles to not clear the physical lock on unlock."""
133
self._lock.leave_in_place()
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()
139
def lock_write(self, token=None):
140
"""Lock this group of files for writing.
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.
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
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
162
token_from_lock = self._lock.lock_write(token=token)
163
#traceback.print_stack()
164
self._lock_mode = 'w'
166
self._set_write_transaction()
167
self._token_from_lock = token_from_lock
168
return token_from_lock
172
if self._lock_mode not in ('r', 'w'):
173
raise ValueError("invalid lock mode %r" % (self._lock_mode,))
174
self._lock_count += 1
176
self._lock.lock_read()
177
#traceback.print_stack()
178
self._lock_mode = 'r'
180
self._set_read_transaction()
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)
188
def _set_write_transaction(self):
189
"""Setup a write transaction."""
190
self._set_transaction(transactions.WriteTransaction())
192
@only_raises(errors.LockNotHeld, errors.LockBroken)
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
199
#traceback.print_stack()
200
self._finish_transaction()
205
self._lock_mode = None
208
"""Return true if this LockableFiles group is locked"""
209
return self._lock_count >= 1
211
def get_physical_lock_status(self):
212
"""Return physical lock status.
214
Returns true if a lock is held on the transport. If no lock is held, or
215
the underlying locking mechanism does not support querying lock
216
status, false is returned.
219
return self._lock.peek() is not None
220
except NotImplementedError:
223
def get_transaction(self):
224
"""Return the current active transaction.
226
If no transaction is active, this returns a passthrough object
227
for which all data is immediately flushed and no caching happens.
229
if self._transaction is None:
230
return transactions.PassThroughTransaction()
232
return self._transaction
234
def _set_transaction(self, new_transaction):
235
"""Set a new active transaction."""
236
if self._transaction is not None:
237
raise errors.LockError('Branch %s is in a transaction already.' %
239
self._transaction = new_transaction
241
def _finish_transaction(self):
242
"""Exit the current transaction."""
243
if self._transaction is None:
244
raise errors.LockError('Branch %s is not in a transaction' %
246
transaction = self._transaction
247
self._transaction = None
251
class TransportLock(object):
252
"""Locking method which uses transport-dependent locks.
254
On the local filesystem these transform into OS-managed locks.
256
These do not guard against concurrent access via different
259
This is suitable for use only in WorkingTrees (which are at present
262
def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
263
self._transport = transport
264
self._escaped_name = escaped_name
265
self._file_modebits = file_modebits
266
self._dir_modebits = dir_modebits
268
def break_lock(self):
269
raise NotImplementedError(self.break_lock)
271
def leave_in_place(self):
272
raise NotImplementedError(self.leave_in_place)
274
def dont_leave_in_place(self):
275
raise NotImplementedError(self.dont_leave_in_place)
277
def lock_write(self, token=None):
278
if token is not None:
279
raise errors.TokenLockingNotSupported(self)
280
self._lock = self._transport.lock_write(self._escaped_name)
283
self._lock = self._transport.lock_read(self._escaped_name)
290
raise NotImplementedError()
292
def create(self, mode=None):
293
"""Create lock mechanism"""
294
# for old-style locks, create the file now
295
self._transport.put_bytes(self._escaped_name, b'',
296
mode=self._file_modebits)
298
def validate_token(self, token):
299
if token is not None:
300
raise errors.TokenLockingNotSupported(self)
added
removed
breezy/lockable_files.py
