← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: John Arbash Meinel
  • Date: 2008-09-09 15:09:12 UTC
  • mto: This revision was merged to the branch mainline in revision 3699.
  • Revision ID: john@arbash-meinel.com-20080909150912-wyttm8he1zsls2ck
Use the right timing function on win32

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockable_files.py
1
 
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
2
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
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from cStringIO import StringIO
16
18
 
17
19
from bzrlib.lazy_import import lazy_import
18
20
lazy_import(globals(), """
20
22
import warnings
21
23
 
22
24
from bzrlib import (
23
 
    counted_lock,
24
25
    errors,
25
 
    lock,
26
26
    osutils,
27
27
    transactions,
28
28
    urlutils,
30
30
""")
31
31
 
32
32
from bzrlib.decorators import (
33
 
    only_raises,
 
33
    needs_read_lock,
 
34
    needs_write_lock,
 
35
    )
 
36
from bzrlib.symbol_versioning import (
 
37
    deprecated_in,
 
38
    deprecated_method,
34
39
    )
35
40
 
36
41
 
38
43
# somewhat redundant with what's done in LockDir; the main difference is that
39
44
# LockableFiles permits reentrancy.
40
45
 
41
 
class _LockWarner(object):
42
 
    """Hold a counter for a lock and warn if GCed while the count is >= 1.
43
 
 
44
 
    This is separate from LockableFiles because putting a __del__ on
45
 
    LockableFiles can result in uncollectable cycles.
46
 
    """
47
 
 
48
 
    def __init__(self, repr):
49
 
        self.lock_count = 0
50
 
        self.repr = repr
51
 
 
52
 
    def __del__(self):
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)
56
 
 
57
 
 
58
46
class LockableFiles(object):
59
47
    """Object representing a set of related files locked within the same scope.
60
48
 
61
 
    This coordinates access to the lock along with providing a transaction.
 
49
    These files are used by a WorkingTree, Repository or Branch, and should
 
50
    generally only be touched by that object.
 
51
 
 
52
    LockableFiles also provides some policy on top of Transport for encoding
 
53
    control files as utf-8.
62
54
 
63
55
    LockableFiles manage a lock count and can be locked repeatedly by
64
56
    a single caller.  (The underlying lock implementation generally does not
65
57
    support this.)
66
58
 
67
59
    Instances of this class are often called control_files.
 
60
    
 
61
    This object builds on top of a Transport, which is used to actually write
 
62
    the files to disk, and an OSLock or LockDir, which controls how access to
 
63
    the files is controlled.  The particular type of locking used is set when
 
64
    the object is constructed.  In older formats OSLocks are used everywhere.
 
65
    in newer formats a LockDir is used for Repositories and Branches, and 
 
66
    OSLocks for the local filesystem.
68
67
 
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
 
68
    This class is now deprecated; code should move to using the Transport 
 
69
    directly for file operations and using the lock or CountedLock for 
71
70
    locking.
72
 
    
73
 
    :ivar _lock: The real underlying lock (e.g. a LockDir)
74
 
    :ivar _counted_lock: A lock decorated with a semaphore, so that it 
75
 
        can be re-entered.
76
71
    """
77
72
 
78
73
    # _lock_mode: None, or 'r' or 'w'
79
74
 
80
75
    # _lock_count: If _lock_mode is true, a positive count of the number of
81
 
    # times the lock has been taken *by this process*.
82
 
 
 
76
    # times the lock has been taken *by this process*.   
 
77
    
83
78
    def __init__(self, transport, lock_name, lock_class):
84
79
        """Create a LockableFiles group
85
80
 
86
 
        :param transport: Transport pointing to the directory holding the
 
81
        :param transport: Transport pointing to the directory holding the 
87
82
            control files and lock.
88
83
        :param lock_name: Name of the lock guarding these files.
89
84
        :param lock_class: Class of lock strategy to use: typically
93
88
        self.lock_name = lock_name
94
89
        self._transaction = None
95
90
        self._lock_mode = None
96
 
        self._lock_warner = _LockWarner(repr(self))
 
91
        self._lock_count = 0
97
92
        self._find_modes()
98
93
        esc_name = self._escape(lock_name)
99
94
        self._lock = lock_class(transport, esc_name,
100
95
                                file_modebits=self._file_mode,
101
96
                                dir_modebits=self._dir_mode)
102
 
        self._counted_lock = counted_lock.CountedLock(self._lock)
103
97
 
104
98
    def create_lock(self):
105
99
        """Create the lock.
115
109
    def __str__(self):
116
110
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
117
111
 
 
112
    def __del__(self):
 
113
        if self.is_locked():
 
114
            # do not automatically unlock; there should have been a
 
115
            # try/finally to unlock this.
 
116
            warnings.warn("%r was gc'd while locked" % self)
 
117
 
118
118
    def break_lock(self):
119
119
        """Break the lock of this lockable files group if it is held.
120
120
 
123
123
        self._lock.break_lock()
124
124
 
125
125
    def _escape(self, file_or_path):
126
 
        """DEPRECATED: Do not use outside this class"""
127
126
        if not isinstance(file_or_path, basestring):
128
127
            file_or_path = '/'.join(file_or_path)
129
128
        if file_or_path == '':
132
131
 
133
132
    def _find_modes(self):
134
133
        """Determine the appropriate modes for files and directories.
135
 
 
136
 
        :deprecated: Replaced by BzrDir._find_creation_modes.
 
134
        
 
135
        :deprecated: Replaced by BzrDir._find_modes.
137
136
        """
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.
140
 
        # -- mbp 20080512
141
137
        try:
142
138
            st = self._transport.stat('.')
143
139
        except errors.TransportNotPossible:
152
148
            # Remove the sticky and execute bits for files
153
149
            self._file_mode = self._dir_mode & ~07111
154
150
 
 
151
    @deprecated_method(deprecated_in((1, 6, 0)))
 
152
    def controlfilename(self, file_or_path):
 
153
        """Return location relative to branch.
 
154
        
 
155
        :deprecated: Use Transport methods instead.
 
156
        """
 
157
        return self._transport.abspath(self._escape(file_or_path))
 
158
 
 
159
    @needs_read_lock
 
160
    @deprecated_method(deprecated_in((1, 5, 0)))
 
161
    def get(self, relpath):
 
162
        """Get a file as a bytestream.
 
163
        
 
164
        :deprecated: Use a Transport instead of LockableFiles.
 
165
        """
 
166
        relpath = self._escape(relpath)
 
167
        return self._transport.get(relpath)
 
168
 
 
169
    @needs_read_lock
 
170
    @deprecated_method(deprecated_in((1, 5, 0)))
 
171
    def get_utf8(self, relpath):
 
172
        """Get a file as a unicode stream.
 
173
        
 
174
        :deprecated: Use a Transport instead of LockableFiles.
 
175
        """
 
176
        relpath = self._escape(relpath)
 
177
        # DO NOT introduce an errors=replace here.
 
178
        return codecs.getreader('utf-8')(self._transport.get(relpath))
 
179
 
 
180
    @needs_write_lock
 
181
    @deprecated_method(deprecated_in((1, 6, 0)))
 
182
    def put(self, path, file):
 
183
        """Write a file.
 
184
        
 
185
        :param path: The path to put the file, relative to the .bzr control
 
186
                     directory
 
187
        :param file: A file-like or string object whose contents should be copied.
 
188
 
 
189
        :deprecated: Use Transport methods instead.
 
190
        """
 
191
        self._transport.put_file(self._escape(path), file, mode=self._file_mode)
 
192
 
 
193
    @needs_write_lock
 
194
    @deprecated_method(deprecated_in((1, 6, 0)))
 
195
    def put_bytes(self, path, a_string):
 
196
        """Write a string of bytes.
 
197
 
 
198
        :param path: The path to put the bytes, relative to the transport root.
 
199
        :param a_string: A string object, whose exact bytes are to be copied.
 
200
 
 
201
        :deprecated: Use Transport methods instead.
 
202
        """
 
203
        self._transport.put_bytes(self._escape(path), a_string,
 
204
                                  mode=self._file_mode)
 
205
 
 
206
    @needs_write_lock
 
207
    @deprecated_method(deprecated_in((1, 6, 0)))
 
208
    def put_utf8(self, path, a_string):
 
209
        """Write a string, encoding as utf-8.
 
210
 
 
211
        :param path: The path to put the string, relative to the transport root.
 
212
        :param string: A string or unicode object whose contents should be copied.
 
213
 
 
214
        :deprecated: Use Transport methods instead.
 
215
        """
 
216
        # IterableFile would not be needed if Transport.put took iterables
 
217
        # instead of files.  ADHB 2005-12-25
 
218
        # RBC 20060103 surely its not needed anyway, with codecs transcode
 
219
        # file support ?
 
220
        # JAM 20060103 We definitely don't want encode(..., 'replace')
 
221
        # these are valuable files which should have exact contents.
 
222
        if not isinstance(a_string, basestring):
 
223
            raise errors.BzrBadParameterNotString(a_string)
 
224
        self.put_bytes(path, a_string.encode('utf-8'))
 
225
 
155
226
    def leave_in_place(self):
156
227
        """Set this LockableFiles to not clear the physical lock on unlock."""
157
228
        self._lock.leave_in_place()
162
233
 
163
234
    def lock_write(self, token=None):
164
235
        """Lock this group of files for writing.
165
 
 
 
236
        
166
237
        :param token: if this is already locked, then lock_write will fail
167
238
            unless the token matches the existing lock.
168
239
        :returns: a token if this instance supports tokens, otherwise None.
181
252
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
182
253
                raise errors.ReadOnlyError(self)
183
254
            self._lock.validate_token(token)
184
 
            self._lock_warner.lock_count += 1
 
255
            self._lock_count += 1
185
256
            return self._token_from_lock
186
257
        else:
187
258
            token_from_lock = self._lock.lock_write(token=token)
188
259
            #traceback.print_stack()
189
260
            self._lock_mode = 'w'
190
 
            self._lock_warner.lock_count = 1
191
 
            self._set_write_transaction()
 
261
            self._lock_count = 1
 
262
            self._set_transaction(transactions.WriteTransaction())
192
263
            self._token_from_lock = token_from_lock
193
264
            return token_from_lock
194
265
 
196
267
        if self._lock_mode:
197
268
            if self._lock_mode not in ('r', 'w'):
198
269
                raise ValueError("invalid lock mode %r" % (self._lock_mode,))
199
 
            self._lock_warner.lock_count += 1
 
270
            self._lock_count += 1
200
271
        else:
201
272
            self._lock.lock_read()
202
273
            #traceback.print_stack()
203
274
            self._lock_mode = 'r'
204
 
            self._lock_warner.lock_count = 1
205
 
            self._set_read_transaction()
206
 
 
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)
212
 
 
213
 
    def _set_write_transaction(self):
214
 
        """Setup a write transaction."""
215
 
        self._set_transaction(transactions.WriteTransaction())
216
 
 
217
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
275
            self._lock_count = 1
 
276
            self._set_transaction(transactions.ReadOnlyTransaction())
 
277
            # 5K may be excessive, but hey, its a knob.
 
278
            self.get_transaction().set_cache_size(5000)
 
279
                        
218
280
    def unlock(self):
219
281
        if not self._lock_mode:
220
 
            return lock.cant_unlock_not_held(self)
221
 
        if self._lock_warner.lock_count > 1:
222
 
            self._lock_warner.lock_count -= 1
 
282
            raise errors.LockNotHeld(self)
 
283
        if self._lock_count > 1:
 
284
            self._lock_count -= 1
223
285
        else:
224
286
            #traceback.print_stack()
225
287
            self._finish_transaction()
226
288
            try:
227
289
                self._lock.unlock()
228
290
            finally:
229
 
                self._lock_mode = self._lock_warner.lock_count = None
230
 
 
231
 
    @property
232
 
    def _lock_count(self):
233
 
        return self._lock_warner.lock_count
 
291
                self._lock_mode = self._lock_count = None
234
292
 
235
293
    def is_locked(self):
236
294
        """Return true if this LockableFiles group is locked"""
237
 
        return self._lock_warner.lock_count >= 1
 
295
        return self._lock_count >= 1
238
296
 
239
297
    def get_physical_lock_status(self):
240
298
        """Return physical lock status.
241
 
 
 
299
        
242
300
        Returns true if a lock is held on the transport. If no lock is held, or
243
301
        the underlying locking mechanism does not support querying lock
244
302
        status, false is returned.
326
384
    def validate_token(self, token):
327
385
        if token is not None:
328
386
            raise errors.TokenLockingNotSupported(self)
329
 
 
 
387