~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-30 07:23:36 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730072336-3e9fd7ddb67b5f47
More branding: bazaar-ng -> Bazaar; bazaar-ng.org -> bazaar-vcs.org

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
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.
7
 
 
 
7
#
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.
12
 
 
 
12
#
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
from cStringIO import StringIO
18
18
import codecs
 
19
#import traceback
19
20
 
20
21
import bzrlib
21
 
from bzrlib.decorators import *
 
22
from bzrlib.decorators import (needs_read_lock,
 
23
        needs_write_lock)
22
24
import bzrlib.errors as errors
23
 
from bzrlib.errors import LockError, ReadOnlyError
 
25
from bzrlib.errors import BzrError
24
26
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
 
27
from bzrlib.symbol_versioning import (deprecated_method, 
 
28
        zero_eight)
 
29
from bzrlib.trace import mutter, note
28
30
import bzrlib.transactions as transactions
29
 
 
 
31
import bzrlib.urlutils as urlutils
 
32
 
 
33
 
 
34
# XXX: The tracking here of lock counts and whether the lock is held is
 
35
# somewhat redundant with what's done in LockDir; the main difference is that
 
36
# LockableFiles permits reentrancy.
30
37
 
31
38
class LockableFiles(object):
32
 
    """Object representing a set of files locked within the same scope
33
 
 
34
 
    _lock_mode
35
 
        None, or 'r' or 'w'
36
 
 
37
 
    _lock_count
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 
40
 
        read locks.
41
 
 
42
 
    _lock
43
 
        Lock object from bzrlib.lock.
 
39
    """Object representing a set of related files locked within the same scope.
 
40
 
 
41
    These files are used by a WorkingTree, Repository or Branch, and should
 
42
    generally only be touched by that object.
 
43
 
 
44
    LockableFiles also provides some policy on top of Transport for encoding
 
45
    control files as utf-8.
 
46
 
 
47
    LockableFiles manage a lock count and can be locked repeatedly by
 
48
    a single caller.  (The underlying lock implementation generally does not
 
49
    support this.)
 
50
 
 
51
    Instances of this class are often called control_files.
 
52
    
 
53
    This object builds on top of a Transport, which is used to actually write
 
54
    the files to disk, and an OSLock or LockDir, which controls how access to
 
55
    the files is controlled.  The particular type of locking used is set when
 
56
    the object is constructed.  In older formats OSLocks are used everywhere.
 
57
    in newer formats a LockDir is used for Repositories and Branches, and 
 
58
    OSLocks for the local filesystem.
44
59
    """
45
60
 
46
 
    _lock_mode = None
47
 
    _lock_count = None
48
 
    _lock = None
 
61
    # _lock_mode: None, or 'r' or 'w'
 
62
 
 
63
    # _lock_count: If _lock_mode is true, a positive count of the number of
 
64
    # times the lock has been taken *by this process*.   
 
65
    
49
66
    # If set to False (by a plugin, etc) BzrBranch will not set the
50
67
    # mode on created files or directories
51
68
    _set_file_mode = True
52
69
    _set_dir_mode = True
53
70
 
54
 
    def __init__(self, transport, lock_name):
55
 
        object.__init__(self)
 
71
    def __init__(self, transport, lock_name, lock_class):
 
72
        """Create a LockableFiles group
 
73
 
 
74
        :param transport: Transport pointing to the directory holding the 
 
75
            control files and lock.
 
76
        :param lock_name: Name of the lock guarding these files.
 
77
        :param lock_class: Class of lock strategy to use: typically
 
78
            either LockDir or TransportLock.
 
79
        """
56
80
        self._transport = transport
57
81
        self.lock_name = lock_name
58
82
        self._transaction = None
 
83
        self._lock_mode = None
 
84
        self._lock_count = 0
59
85
        self._find_modes()
 
86
        esc_name = self._escape(lock_name)
 
87
        self._lock = lock_class(transport, esc_name,
 
88
                                file_modebits=self._file_mode,
 
89
                                dir_modebits=self._dir_mode)
 
90
 
 
91
    def create_lock(self):
 
92
        """Create the lock.
 
93
 
 
94
        This should normally be called only when the LockableFiles directory
 
95
        is first created on disk.
 
96
        """
 
97
        self._lock.create(mode=self._dir_mode)
 
98
 
 
99
    def __repr__(self):
 
100
        return '%s(%r)' % (self.__class__.__name__,
 
101
                           self._transport)
 
102
    def __str__(self):
 
103
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
60
104
 
61
105
    def __del__(self):
62
 
        if self._lock_mode or self._lock:
 
106
        if self.is_locked():
63
107
            # XXX: This should show something every time, and be suitable for
64
108
            # headless operation and embedding
65
109
            from warnings import warn
66
110
            warn("file group %r was not explicitly unlocked" % self)
67
111
            self._lock.unlock()
68
112
 
 
113
    def break_lock(self):
 
114
        """Break the lock of this lockable files group if it is held.
 
115
 
 
116
        The current ui factory will be used to prompt for user conformation.
 
117
        """
 
118
        self._lock.break_lock()
 
119
 
69
120
    def _escape(self, file_or_path):
70
121
        if not isinstance(file_or_path, basestring):
71
122
            file_or_path = '/'.join(file_or_path)
72
123
        if file_or_path == '':
73
124
            return u''
74
 
        return bzrlib.transport.urlescape(safe_unicode(file_or_path))
 
125
        return urlutils.escape(safe_unicode(file_or_path))
75
126
 
76
127
    def _find_modes(self):
77
128
        """Determine the appropriate modes for files and directories."""
78
129
        try:
79
 
            try:
80
 
                st = self._transport.stat('.')
81
 
            except errors.NoSuchFile:
82
 
                # The .bzr/ directory doesn't exist, try to
83
 
                # inherit the permissions from the parent directory
84
 
                # but only try 1 level up
85
 
                temp_transport = self._transport.clone('..')
86
 
                st = temp_transport.stat('.')
87
 
        except (errors.TransportNotPossible, errors.NoSuchFile):
 
130
            st = self._transport.stat('.')
 
131
        except errors.TransportNotPossible:
88
132
            self._dir_mode = 0755
89
133
            self._file_mode = 0644
90
134
        else:
115
159
        """
116
160
 
117
161
        relpath = self._escape(file_or_path)
118
 
        #TODO: codecs.open() buffers linewise, so it was overloaded with
 
162
        # TODO: codecs.open() buffers linewise, so it was overloaded with
119
163
        # a much larger buffer, do we need to do the same for getreader/getwriter?
120
164
        if mode == 'rb': 
121
165
            return self.get(relpath)
169
213
        self.put(path, StringIO(a_string.encode('utf-8')))
170
214
 
171
215
    def lock_write(self):
172
 
        mutter("lock write: %s (%s)", self, self._lock_count)
 
216
        # mutter("lock write: %s (%s)", self, self._lock_count)
173
217
        # TODO: Upgrade locking to support using a Transport,
174
218
        # and potentially a remote locking protocol
175
219
        if self._lock_mode:
176
 
            if self._lock_mode != 'w':
177
 
                raise ReadOnlyError("can't upgrade to a write lock from %r" %
178
 
                                self._lock_mode)
 
220
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
 
221
                raise errors.ReadOnlyError(self)
179
222
            self._lock_count += 1
180
223
        else:
181
 
            self._lock = self._transport.lock_write(
182
 
                    self._escape(self.lock_name))
 
224
            self._lock.lock_write()
 
225
            #note('write locking %s', self)
 
226
            #traceback.print_stack()
183
227
            self._lock_mode = 'w'
184
228
            self._lock_count = 1
185
 
            self._set_transaction(transactions.PassThroughTransaction())
 
229
            self._set_transaction(transactions.WriteTransaction())
186
230
 
187
231
    def lock_read(self):
188
 
        mutter("lock read: %s (%s)", self, self._lock_count)
 
232
        # mutter("lock read: %s (%s)", self, self._lock_count)
189
233
        if self._lock_mode:
190
234
            assert self._lock_mode in ('r', 'w'), \
191
235
                   "invalid lock mode %r" % self._lock_mode
192
236
            self._lock_count += 1
193
237
        else:
194
 
            self._lock = self._transport.lock_read(
195
 
                    self._escape(self.lock_name))
 
238
            self._lock.lock_read()
 
239
            #note('read locking %s', self)
 
240
            #traceback.print_stack()
196
241
            self._lock_mode = 'r'
197
242
            self._lock_count = 1
198
243
            self._set_transaction(transactions.ReadOnlyTransaction())
200
245
            self.get_transaction().set_cache_size(5000)
201
246
                        
202
247
    def unlock(self):
203
 
        mutter("unlock: %s (%s)", self, self._lock_count)
 
248
        # mutter("unlock: %s (%s)", self, self._lock_count)
204
249
        if not self._lock_mode:
205
 
            raise LockError('branch %r is not locked' % (self))
206
 
 
 
250
            raise errors.LockNotHeld(self)
207
251
        if self._lock_count > 1:
208
252
            self._lock_count -= 1
209
253
        else:
 
254
            #note('unlocking %s', self)
 
255
            #traceback.print_stack()
210
256
            self._finish_transaction()
211
 
            self._lock.unlock()
212
 
            self._lock = None
213
 
            self._lock_mode = self._lock_count = None
 
257
            try:
 
258
                self._lock.unlock()
 
259
            finally:
 
260
                self._lock_mode = self._lock_count = None
 
261
 
 
262
    def is_locked(self):
 
263
        """Return true if this LockableFiles group is locked"""
 
264
        return self._lock_count >= 1
 
265
 
 
266
    def get_physical_lock_status(self):
 
267
        """Return physical lock status.
 
268
        
 
269
        Returns true if a lock is held on the transport. If no lock is held, or
 
270
        the underlying locking mechanism does not support querying lock
 
271
        status, false is returned.
 
272
        """
 
273
        try:
 
274
            return self._lock.peek() is not None
 
275
        except NotImplementedError:
 
276
            return False
214
277
 
215
278
    def get_transaction(self):
216
279
        """Return the current active transaction.
238
301
        transaction = self._transaction
239
302
        self._transaction = None
240
303
        transaction.finish()
 
304
 
 
305
 
 
306
class TransportLock(object):
 
307
    """Locking method which uses transport-dependent locks.
 
308
 
 
309
    On the local filesystem these transform into OS-managed locks.
 
310
 
 
311
    These do not guard against concurrent access via different
 
312
    transports.
 
313
 
 
314
    This is suitable for use only in WorkingTrees (which are at present
 
315
    always local).
 
316
    """
 
317
    def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
 
318
        self._transport = transport
 
319
        self._escaped_name = escaped_name
 
320
        self._file_modebits = file_modebits
 
321
        self._dir_modebits = dir_modebits
 
322
 
 
323
    def break_lock(self):
 
324
        raise NotImplementedError(self.break_lock)
 
325
 
 
326
    def lock_write(self):
 
327
        self._lock = self._transport.lock_write(self._escaped_name)
 
328
 
 
329
    def lock_read(self):
 
330
        self._lock = self._transport.lock_read(self._escaped_name)
 
331
 
 
332
    def unlock(self):
 
333
        self._lock.unlock()
 
334
        self._lock = None
 
335
 
 
336
    def peek(self):
 
337
        raise NotImplementedError()
 
338
 
 
339
    def create(self, mode=None):
 
340
        """Create lock mechanism"""
 
341
        # for old-style locks, create the file now
 
342
        self._transport.put(self._escaped_name, StringIO(), 
 
343
                            mode=self._file_modebits)