1
# Copyright (C) 2005 Canonical Ltd
1
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from cStringIO import StringIO
17
from bzrlib.lazy_import import lazy_import
18
lazy_import(globals(), """
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
32
from bzrlib.decorators import (
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.
41
class _LockWarner(object):
42
"""Hold a counter for a lock and warn if GCed while the count is >= 1.
44
This is separate from LockableFiles because putting a __del__ on
45
LockableFiles can result in uncollectable cycles.
48
def __init__(self, repr):
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)
31
58
class LockableFiles(object):
32
"""Object representing a set of files locked within the same scope
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
43
Lock object from bzrlib.lock.
59
"""Object representing a set of related files locked within the same scope.
61
This coordinates access to the lock along with providing a transaction.
63
LockableFiles manage a lock count and can be locked repeatedly by
64
a single caller. (The underlying lock implementation generally does not
67
Instances of this class are often called control_files.
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
73
:ivar _lock: The real underlying lock (e.g. a LockDir)
74
:ivar _counted_lock: A lock decorated with a semaphore, so that it
49
# If set to False (by a plugin, etc) BzrBranch will not set the
50
# mode on created files or directories
54
def __init__(self, transport, lock_name):
78
# _lock_mode: None, or 'r' or 'w'
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*.
83
def __init__(self, transport, lock_name, lock_class):
84
"""Create a LockableFiles group
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.
56
92
self._transport = transport
57
93
self.lock_name = lock_name
58
94
self._transaction = None
95
self._lock_mode = None
96
self._lock_warner = _LockWarner(repr(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)
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)
104
def create_lock(self):
107
This should normally be called only when the LockableFiles directory
108
is first created on disk.
110
self._lock.create(mode=self._dir_mode)
113
return '%s(%r)' % (self.__class__.__name__,
116
return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
118
def break_lock(self):
119
"""Break the lock of this lockable files group if it is held.
121
The current ui factory will be used to prompt for user conformation.
123
self._lock.break_lock()
69
125
def _escape(self, file_or_path):
126
"""DEPRECATED: Do not use outside this class"""
70
127
if not isinstance(file_or_path, basestring):
71
128
file_or_path = '/'.join(file_or_path)
72
129
if file_or_path == '':
74
return bzrlib.transport.urlescape(safe_unicode(file_or_path))
131
return urlutils.escape(osutils.safe_unicode(file_or_path))
76
133
def _find_modes(self):
77
"""Determine the appropriate modes for files and directories."""
134
"""Determine the appropriate modes for files and directories.
136
:deprecated: Replaced by BzrDir._find_creation_modes.
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.
79
142
st = self._transport.stat('.')
80
143
except errors.TransportNotPossible:
81
144
self._dir_mode = 0755
82
145
self._file_mode = 0644
84
self._dir_mode = st.st_mode & 07777
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
85
152
# Remove the sticky and execute bits for files
86
153
self._file_mode = self._dir_mode & ~07111
87
if not self._set_dir_mode:
89
if not self._set_file_mode:
90
self._file_mode = None
92
def controlfilename(self, file_or_path):
93
"""Return location relative to branch."""
94
return self._transport.abspath(self._escape(file_or_path))
96
@deprecated_method(zero_eight)
97
def controlfile(self, file_or_path, mode='r'):
98
"""Open a control file for this branch.
100
There are two classes of file in a lockable directory: text
101
and binary. binary files are untranslated byte streams. Text
102
control files are stored with Unix newlines and in UTF-8, even
103
if the platform or locale defaults are different.
105
Such files are not openable in write mode : they are managed via
106
put and put_utf8 which atomically replace old versions using
110
relpath = self._escape(file_or_path)
111
#TODO: codecs.open() buffers linewise, so it was overloaded with
112
# a much larger buffer, do we need to do the same for getreader/getwriter?
114
return self.get(relpath)
116
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put[_utf8]")
118
return self.get_utf8(relpath)
120
raise BzrError("Branch.controlfile(mode='w') is not supported, use put[_utf8]")
122
raise BzrError("invalid controlfile mode %r" % mode)
125
def get(self, relpath):
126
"""Get a file as a bytestream."""
127
relpath = self._escape(relpath)
128
return self._transport.get(relpath)
131
def get_utf8(self, relpath):
132
"""Get a file as a unicode stream."""
133
relpath = self._escape(relpath)
134
# DO NOT introduce an errors=replace here.
135
return codecs.getreader('utf-8')(self._transport.get(relpath))
138
def put(self, path, file):
141
:param path: The path to put the file, relative to the .bzr control
143
:param f: A file-like or string object whose contents should be copied.
145
self._transport.put(self._escape(path), file, mode=self._file_mode)
148
def put_utf8(self, path, a_string):
149
"""Write a string, encoding as utf-8.
151
:param path: The path to put the string, relative to the transport root.
152
:param string: A file-like or string object whose contents should be copied.
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
158
# JAM 20060103 We definitely don't want encode(..., 'replace')
159
# these are valuable files which should have exact contents.
160
if not isinstance(a_string, basestring):
161
raise errors.BzrBadParameterNotString(a_string)
162
self.put(path, StringIO(a_string.encode('utf-8')))
164
def lock_write(self):
165
# mutter("lock write: %s (%s)", self, self._lock_count)
155
def leave_in_place(self):
156
"""Set this LockableFiles to not clear the physical lock on unlock."""
157
self._lock.leave_in_place()
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()
163
def lock_write(self, token=None):
164
"""Lock this group of files for writing.
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.
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
166
178
# TODO: Upgrade locking to support using a Transport,
167
179
# and potentially a remote locking protocol
168
180
if self._lock_mode:
169
if self._lock_mode != 'w':
170
raise ReadOnlyError("can't upgrade to a write lock from %r" %
172
self._lock_count += 1
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
174
self._lock = self._transport.lock_write(
175
self._escape(self.lock_name))
187
token_from_lock = self._lock.lock_write(token=token)
188
#traceback.print_stack()
176
189
self._lock_mode = 'w'
178
self._set_transaction(transactions.PassThroughTransaction())
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
180
195
def lock_read(self):
181
# mutter("lock read: %s (%s)", self, self._lock_count)
182
196
if self._lock_mode:
183
assert self._lock_mode in ('r', 'w'), \
184
"invalid lock mode %r" % self._lock_mode
185
self._lock_count += 1
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
187
self._lock = self._transport.lock_read(
188
self._escape(self.lock_name))
201
self._lock.lock_read()
202
#traceback.print_stack()
189
203
self._lock_mode = 'r'
191
self._set_transaction(transactions.ReadOnlyTransaction())
192
# 5K may be excessive, but hey, its a knob.
193
self.get_transaction().set_cache_size(5000)
204
self._lock_warner.lock_count = 1
205
self._set_read_transaction()
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)
213
def _set_write_transaction(self):
214
"""Setup a write transaction."""
215
self._set_transaction(transactions.WriteTransaction())
217
@only_raises(errors.LockNotHeld, errors.LockBroken)
195
218
def unlock(self):
196
# mutter("unlock: %s (%s)", self, self._lock_count)
197
219
if not self._lock_mode:
198
raise LockError('branch %r is not locked' % (self))
200
if self._lock_count > 1:
201
self._lock_count -= 1
220
return lock.cant_unlock_not_held(self)
221
if self._lock_warner.lock_count > 1:
222
self._lock_warner.lock_count -= 1
224
#traceback.print_stack()
203
225
self._finish_transaction()
206
self._lock_mode = self._lock_count = None
229
self._lock_mode = self._lock_warner.lock_count = None
232
def _lock_count(self):
233
return self._lock_warner.lock_count
236
"""Return true if this LockableFiles group is locked"""
237
return self._lock_warner.lock_count >= 1
239
def get_physical_lock_status(self):
240
"""Return physical lock status.
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.
247
return self._lock.peek() is not None
248
except NotImplementedError:
208
251
def get_transaction(self):
209
252
"""Return the current active transaction.
added
removed
bzrlib/lockable_files.py
