~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: Robert Collins
  • Date: 2006-05-24 08:14:45 UTC
  • mfrom: (1725.1.1 benchmark)
  • mto: (1725.2.6 commit)
  • mto: This revision was merged to the branch mainline in revision 1729.
  • Revision ID: robertc@robertcollins.net-20060524081445-c046b4406ffc8dfa
(rbc)Merge in benchmark --lsprof-timed lsprofiling feature. (Robert Collins, Martin Pool).

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from cStringIO import StringIO
 
18
import codecs
 
19
#import traceback
 
20
 
 
21
import bzrlib
 
22
from bzrlib.decorators import *
 
23
import bzrlib.errors as errors
 
24
from bzrlib.errors import BzrError
 
25
from bzrlib.osutils import file_iterator, safe_unicode
 
26
from bzrlib.symbol_versioning import *
 
27
from bzrlib.trace import mutter, note
 
28
import bzrlib.transactions as transactions
 
29
 
 
30
# XXX: The tracking here of lock counts and whether the lock is held is
 
31
# somewhat redundant with what's done in LockDir; the main difference is that
 
32
# LockableFiles permits reentrancy.
 
33
 
 
34
class LockableFiles(object):
 
35
    """Object representing a set of related files locked within the same scope.
 
36
 
 
37
    These files are used by a WorkingTree, Repository or Branch, and should
 
38
    generally only be touched by that object.
 
39
 
 
40
    LockableFiles also provides some policy on top of Transport for encoding
 
41
    control files as utf-8.
 
42
 
 
43
    LockableFiles manage a lock count and can be locked repeatedly by
 
44
    a single caller.  (The underlying lock implementation generally does not
 
45
    support this.)
 
46
 
 
47
    Instances of this class are often called control_files.
 
48
    
 
49
    This object builds on top of a Transport, which is used to actually write
 
50
    the files to disk, and an OSLock or LockDir, which controls how access to
 
51
    the files is controlled.  The particular type of locking used is set when
 
52
    the object is constructed.  In older formats OSLocks are used everywhere.
 
53
    in newer formats a LockDir is used for Repositories and Branches, and 
 
54
    OSLocks for the local filesystem.
 
55
    """
 
56
 
 
57
    # _lock_mode: None, or 'r' or 'w'
 
58
 
 
59
    # _lock_count: If _lock_mode is true, a positive count of the number of
 
60
    # times the lock has been taken *by this process*.   
 
61
    
 
62
    # If set to False (by a plugin, etc) BzrBranch will not set the
 
63
    # mode on created files or directories
 
64
    _set_file_mode = True
 
65
    _set_dir_mode = True
 
66
 
 
67
    def __init__(self, transport, lock_name, lock_class):
 
68
        """Create a LockableFiles group
 
69
 
 
70
        :param transport: Transport pointing to the directory holding the 
 
71
            control files and lock.
 
72
        :param lock_name: Name of the lock guarding these files.
 
73
        :param lock_class: Class of lock strategy to use: typically
 
74
            either LockDir or TransportLock.
 
75
        """
 
76
        object.__init__(self)
 
77
        self._transport = transport
 
78
        self.lock_name = lock_name
 
79
        self._transaction = None
 
80
        self._find_modes()
 
81
        self._lock_mode = None
 
82
        self._lock_count = 0
 
83
        esc_name = self._escape(lock_name)
 
84
        self._lock = lock_class(transport, esc_name,
 
85
                                file_modebits=self._file_mode,
 
86
                                dir_modebits=self._dir_mode)
 
87
 
 
88
    def create_lock(self):
 
89
        """Create the lock.
 
90
 
 
91
        This should normally be called only when the LockableFiles directory
 
92
        is first created on disk.
 
93
        """
 
94
        self._lock.create(mode=self._dir_mode)
 
95
 
 
96
    def __repr__(self):
 
97
        return '%s(%r)' % (self.__class__.__name__,
 
98
                           self._transport)
 
99
    def __str__(self):
 
100
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
 
101
 
 
102
    def __del__(self):
 
103
        if self.is_locked():
 
104
            # XXX: This should show something every time, and be suitable for
 
105
            # headless operation and embedding
 
106
            from warnings import warn
 
107
            warn("file group %r was not explicitly unlocked" % self)
 
108
            self._lock.unlock()
 
109
 
 
110
    def break_lock(self):
 
111
        """Break the lock of this lockable files group if it is held.
 
112
 
 
113
        The current ui factory will be used to prompt for user conformation.
 
114
        """
 
115
        self._lock.break_lock()
 
116
 
 
117
    def _escape(self, file_or_path):
 
118
        if not isinstance(file_or_path, basestring):
 
119
            file_or_path = '/'.join(file_or_path)
 
120
        if file_or_path == '':
 
121
            return u''
 
122
        return bzrlib.transport.urlescape(safe_unicode(file_or_path))
 
123
 
 
124
    def _find_modes(self):
 
125
        """Determine the appropriate modes for files and directories."""
 
126
        try:
 
127
            st = self._transport.stat('.')
 
128
        except errors.TransportNotPossible:
 
129
            self._dir_mode = 0755
 
130
            self._file_mode = 0644
 
131
        else:
 
132
            self._dir_mode = st.st_mode & 07777
 
133
            # Remove the sticky and execute bits for files
 
134
            self._file_mode = self._dir_mode & ~07111
 
135
        if not self._set_dir_mode:
 
136
            self._dir_mode = None
 
137
        if not self._set_file_mode:
 
138
            self._file_mode = None
 
139
 
 
140
    def controlfilename(self, file_or_path):
 
141
        """Return location relative to branch."""
 
142
        return self._transport.abspath(self._escape(file_or_path))
 
143
 
 
144
    @deprecated_method(zero_eight)
 
145
    def controlfile(self, file_or_path, mode='r'):
 
146
        """Open a control file for this branch.
 
147
 
 
148
        There are two classes of file in a lockable directory: text
 
149
        and binary.  binary files are untranslated byte streams.  Text
 
150
        control files are stored with Unix newlines and in UTF-8, even
 
151
        if the platform or locale defaults are different.
 
152
 
 
153
        Such files are not openable in write mode : they are managed via
 
154
        put and put_utf8 which atomically replace old versions using
 
155
        atomicfile.
 
156
        """
 
157
 
 
158
        relpath = self._escape(file_or_path)
 
159
        # TODO: codecs.open() buffers linewise, so it was overloaded with
 
160
        # a much larger buffer, do we need to do the same for getreader/getwriter?
 
161
        if mode == 'rb': 
 
162
            return self.get(relpath)
 
163
        elif mode == 'wb':
 
164
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put[_utf8]")
 
165
        elif mode == 'r':
 
166
            return self.get_utf8(relpath)
 
167
        elif mode == 'w':
 
168
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put[_utf8]")
 
169
        else:
 
170
            raise BzrError("invalid controlfile mode %r" % mode)
 
171
 
 
172
    @needs_read_lock
 
173
    def get(self, relpath):
 
174
        """Get a file as a bytestream."""
 
175
        relpath = self._escape(relpath)
 
176
        return self._transport.get(relpath)
 
177
 
 
178
    @needs_read_lock
 
179
    def get_utf8(self, relpath):
 
180
        """Get a file as a unicode stream."""
 
181
        relpath = self._escape(relpath)
 
182
        # DO NOT introduce an errors=replace here.
 
183
        return codecs.getreader('utf-8')(self._transport.get(relpath))
 
184
 
 
185
    @needs_write_lock
 
186
    def put(self, path, file):
 
187
        """Write a file.
 
188
        
 
189
        :param path: The path to put the file, relative to the .bzr control
 
190
                     directory
 
191
        :param f: A file-like or string object whose contents should be copied.
 
192
        """
 
193
        self._transport.put(self._escape(path), file, mode=self._file_mode)
 
194
 
 
195
    @needs_write_lock
 
196
    def put_utf8(self, path, a_string):
 
197
        """Write a string, encoding as utf-8.
 
198
 
 
199
        :param path: The path to put the string, relative to the transport root.
 
200
        :param string: A file-like or string object whose contents should be copied.
 
201
        """
 
202
        # IterableFile would not be needed if Transport.put took iterables
 
203
        # instead of files.  ADHB 2005-12-25
 
204
        # RBC 20060103 surely its not needed anyway, with codecs transcode
 
205
        # file support ?
 
206
        # JAM 20060103 We definitely don't want encode(..., 'replace')
 
207
        # these are valuable files which should have exact contents.
 
208
        if not isinstance(a_string, basestring):
 
209
            raise errors.BzrBadParameterNotString(a_string)
 
210
        self.put(path, StringIO(a_string.encode('utf-8')))
 
211
 
 
212
    def lock_write(self):
 
213
        # mutter("lock write: %s (%s)", self, self._lock_count)
 
214
        # TODO: Upgrade locking to support using a Transport,
 
215
        # and potentially a remote locking protocol
 
216
        if self._lock_mode:
 
217
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
 
218
                raise errors.ReadOnlyError(self)
 
219
            self._lock_count += 1
 
220
        else:
 
221
            self._lock.lock_write()
 
222
            #note('write locking %s', self)
 
223
            #traceback.print_stack()
 
224
            self._lock_mode = 'w'
 
225
            self._lock_count = 1
 
226
            self._set_transaction(transactions.WriteTransaction())
 
227
 
 
228
    def lock_read(self):
 
229
        # mutter("lock read: %s (%s)", self, self._lock_count)
 
230
        if self._lock_mode:
 
231
            assert self._lock_mode in ('r', 'w'), \
 
232
                   "invalid lock mode %r" % self._lock_mode
 
233
            self._lock_count += 1
 
234
        else:
 
235
            self._lock.lock_read()
 
236
            #note('read locking %s', self)
 
237
            #traceback.print_stack()
 
238
            self._lock_mode = 'r'
 
239
            self._lock_count = 1
 
240
            self._set_transaction(transactions.ReadOnlyTransaction())
 
241
            # 5K may be excessive, but hey, its a knob.
 
242
            self.get_transaction().set_cache_size(5000)
 
243
                        
 
244
    def unlock(self):
 
245
        # mutter("unlock: %s (%s)", self, self._lock_count)
 
246
        if not self._lock_mode:
 
247
            raise errors.LockNotHeld(self)
 
248
        if self._lock_count > 1:
 
249
            self._lock_count -= 1
 
250
        else:
 
251
            #note('unlocking %s', self)
 
252
            #traceback.print_stack()
 
253
            self._finish_transaction()
 
254
            try:
 
255
                self._lock.unlock()
 
256
            finally:
 
257
                self._lock_mode = self._lock_count = None
 
258
 
 
259
    def is_locked(self):
 
260
        """Return true if this LockableFiles group is locked"""
 
261
        return self._lock_count >= 1
 
262
 
 
263
    def get_physical_lock_status(self):
 
264
        """Return physical lock status.
 
265
        
 
266
        Returns true if a lock is held on the transport. If no lock is held, or
 
267
        the underlying locking mechanism does not support querying lock
 
268
        status, false is returned.
 
269
        """
 
270
        try:
 
271
            return self._lock.peek() is not None
 
272
        except NotImplementedError:
 
273
            return False
 
274
 
 
275
    def get_transaction(self):
 
276
        """Return the current active transaction.
 
277
 
 
278
        If no transaction is active, this returns a passthrough object
 
279
        for which all data is immediately flushed and no caching happens.
 
280
        """
 
281
        if self._transaction is None:
 
282
            return transactions.PassThroughTransaction()
 
283
        else:
 
284
            return self._transaction
 
285
 
 
286
    def _set_transaction(self, new_transaction):
 
287
        """Set a new active transaction."""
 
288
        if self._transaction is not None:
 
289
            raise errors.LockError('Branch %s is in a transaction already.' %
 
290
                                   self)
 
291
        self._transaction = new_transaction
 
292
 
 
293
    def _finish_transaction(self):
 
294
        """Exit the current transaction."""
 
295
        if self._transaction is None:
 
296
            raise errors.LockError('Branch %s is not in a transaction' %
 
297
                                   self)
 
298
        transaction = self._transaction
 
299
        self._transaction = None
 
300
        transaction.finish()
 
301
 
 
302
 
 
303
class TransportLock(object):
 
304
    """Locking method which uses transport-dependent locks.
 
305
 
 
306
    On the local filesystem these transform into OS-managed locks.
 
307
 
 
308
    These do not guard against concurrent access via different
 
309
    transports.
 
310
 
 
311
    This is suitable for use only in WorkingTrees (which are at present
 
312
    always local).
 
313
    """
 
314
    def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
 
315
        self._transport = transport
 
316
        self._escaped_name = escaped_name
 
317
        self._file_modebits = file_modebits
 
318
        self._dir_modebits = dir_modebits
 
319
 
 
320
    def break_lock(self):
 
321
        raise NotImplementedError(self.break_lock)
 
322
 
 
323
    def lock_write(self):
 
324
        self._lock = self._transport.lock_write(self._escaped_name)
 
325
 
 
326
    def lock_read(self):
 
327
        self._lock = self._transport.lock_read(self._escaped_name)
 
328
 
 
329
    def unlock(self):
 
330
        self._lock.unlock()
 
331
        self._lock = None
 
332
 
 
333
    def peek(self):
 
334
        raise NotImplementedError()
 
335
 
 
336
    def create(self, mode=None):
 
337
        """Create lock mechanism"""
 
338
        # for old-style locks, create the file now
 
339
        self._transport.put(self._escaped_name, StringIO(), 
 
340
                            mode=self._file_modebits)