← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-12-20 16:16:34 UTC
  • mfrom: (3123.5.18 hardlinks)
  • Revision ID: pqm@pqm.ubuntu.com-20071220161634-2kcjb650o21ydko4
Accelerate build_tree using similar workingtrees (abentley)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockable_files.py
1
 
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
from cStringIO import StringIO
18
 
 
19
 
from bzrlib.lazy_import import lazy_import
20
 
lazy_import(globals(), """
21
18
import codecs
22
 
import warnings
23
 
 
24
 
from bzrlib import (
25
 
    errors,
26
 
    osutils,
27
 
    transactions,
28
 
    urlutils,
29
 
    )
30
 
""")
31
 
 
32
 
from bzrlib.decorators import (
33
 
    needs_read_lock,
34
 
    needs_write_lock,
35
 
    )
36
 
from bzrlib.symbol_versioning import (
37
 
    deprecated_in,
38
 
    deprecated_method,
39
 
    )
 
19
#import traceback
 
20
 
 
21
import bzrlib
 
22
from bzrlib.decorators import (needs_read_lock,
 
23
        needs_write_lock)
 
24
import bzrlib.errors as errors
 
25
from bzrlib.errors import BzrError
 
26
from bzrlib.osutils import file_iterator, safe_unicode
 
27
from bzrlib.symbol_versioning import (deprecated_method,
 
28
        )
 
29
from bzrlib.trace import mutter, note
 
30
import bzrlib.transactions as transactions
 
31
import bzrlib.urlutils as urlutils
40
32
 
41
33
 
42
34
# XXX: The tracking here of lock counts and whether the lock is held is
64
56
    the object is constructed.  In older formats OSLocks are used everywhere.
65
57
    in newer formats a LockDir is used for Repositories and Branches, and 
66
58
    OSLocks for the local filesystem.
67
 
 
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 
70
 
    locking.
71
59
    """
72
60
 
73
61
    # _lock_mode: None, or 'r' or 'w'
75
63
    # _lock_count: If _lock_mode is true, a positive count of the number of
76
64
    # times the lock has been taken *by this process*.   
77
65
    
 
66
    # If set to False (by a plugin, etc) BzrBranch will not set the
 
67
    # mode on created files or directories
 
68
    _set_file_mode = True
 
69
    _set_dir_mode = True
 
70
 
78
71
    def __init__(self, transport, lock_name, lock_class):
79
72
        """Create a LockableFiles group
80
73
 
111
104
 
112
105
    def __del__(self):
113
106
        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)
 
107
            # XXX: This should show something every time, and be suitable for
 
108
            # headless operation and embedding
 
109
            from warnings import warn
 
110
            warn("file group %r was not explicitly unlocked" % self)
 
111
            self._lock.unlock()
117
112
 
118
113
    def break_lock(self):
119
114
        """Break the lock of this lockable files group if it is held.
127
122
            file_or_path = '/'.join(file_or_path)
128
123
        if file_or_path == '':
129
124
            return u''
130
 
        return urlutils.escape(osutils.safe_unicode(file_or_path))
 
125
        return urlutils.escape(safe_unicode(file_or_path))
131
126
 
132
127
    def _find_modes(self):
133
 
        """Determine the appropriate modes for files and directories.
134
 
        
135
 
        :deprecated: Replaced by BzrDir._find_modes.
136
 
        """
 
128
        """Determine the appropriate modes for files and directories."""
137
129
        try:
138
130
            st = self._transport.stat('.')
139
131
        except errors.TransportNotPossible:
147
139
            self._dir_mode = (st.st_mode & 07777) | 00700
148
140
            # Remove the sticky and execute bits for files
149
141
            self._file_mode = self._dir_mode & ~07111
 
142
        if not self._set_dir_mode:
 
143
            self._dir_mode = None
 
144
        if not self._set_file_mode:
 
145
            self._file_mode = None
150
146
 
151
 
    @deprecated_method(deprecated_in((1, 6, 0)))
152
147
    def controlfilename(self, file_or_path):
153
 
        """Return location relative to branch.
154
 
        
155
 
        :deprecated: Use Transport methods instead.
156
 
        """
 
148
        """Return location relative to branch."""
157
149
        return self._transport.abspath(self._escape(file_or_path))
158
150
 
159
151
    @needs_read_lock
160
 
    @deprecated_method(deprecated_in((1, 5, 0)))
161
152
    def get(self, relpath):
162
 
        """Get a file as a bytestream.
163
 
        
164
 
        :deprecated: Use a Transport instead of LockableFiles.
165
 
        """
 
153
        """Get a file as a bytestream."""
166
154
        relpath = self._escape(relpath)
167
155
        return self._transport.get(relpath)
168
156
 
169
157
    @needs_read_lock
170
 
    @deprecated_method(deprecated_in((1, 5, 0)))
171
158
    def get_utf8(self, relpath):
172
 
        """Get a file as a unicode stream.
173
 
        
174
 
        :deprecated: Use a Transport instead of LockableFiles.
175
 
        """
 
159
        """Get a file as a unicode stream."""
176
160
        relpath = self._escape(relpath)
177
161
        # DO NOT introduce an errors=replace here.
178
162
        return codecs.getreader('utf-8')(self._transport.get(relpath))
179
163
 
180
164
    @needs_write_lock
181
 
    @deprecated_method(deprecated_in((1, 6, 0)))
182
165
    def put(self, path, file):
183
166
        """Write a file.
184
167
        
185
168
        :param path: The path to put the file, relative to the .bzr control
186
169
                     directory
187
 
        :param file: A file-like or string object whose contents should be copied.
188
 
 
189
 
        :deprecated: Use Transport methods instead.
 
170
        :param f: A file-like or string object whose contents should be copied.
190
171
        """
191
172
        self._transport.put_file(self._escape(path), file, mode=self._file_mode)
192
173
 
193
174
    @needs_write_lock
194
 
    @deprecated_method(deprecated_in((1, 6, 0)))
195
175
    def put_bytes(self, path, a_string):
196
176
        """Write a string of bytes.
197
177
 
198
178
        :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.
 
179
        :param string: A string object, whose exact bytes are to be copied.
202
180
        """
203
181
        self._transport.put_bytes(self._escape(path), a_string,
204
182
                                  mode=self._file_mode)
205
183
 
206
184
    @needs_write_lock
207
 
    @deprecated_method(deprecated_in((1, 6, 0)))
208
185
    def put_utf8(self, path, a_string):
209
186
        """Write a string, encoding as utf-8.
210
187
 
211
188
        :param path: The path to put the string, relative to the transport root.
212
189
        :param string: A string or unicode object whose contents should be copied.
213
 
 
214
 
        :deprecated: Use Transport methods instead.
215
190
        """
216
191
        # IterableFile would not be needed if Transport.put took iterables
217
192
        # instead of files.  ADHB 2005-12-25
246
221
        some other way, and need to synchronise this object's state with that
247
222
        fact.
248
223
        """
 
224
        # mutter("lock write: %s (%s)", self, self._lock_count)
249
225
        # TODO: Upgrade locking to support using a Transport,
250
226
        # and potentially a remote locking protocol
251
227
        if self._lock_mode:
256
232
            return self._token_from_lock
257
233
        else:
258
234
            token_from_lock = self._lock.lock_write(token=token)
 
235
            #note('write locking %s', self)
259
236
            #traceback.print_stack()
260
237
            self._lock_mode = 'w'
261
238
            self._lock_count = 1
264
241
            return token_from_lock
265
242
 
266
243
    def lock_read(self):
 
244
        # mutter("lock read: %s (%s)", self, self._lock_count)
267
245
        if self._lock_mode:
268
 
            if self._lock_mode not in ('r', 'w'):
269
 
                raise ValueError("invalid lock mode %r" % (self._lock_mode,))
 
246
            assert self._lock_mode in ('r', 'w'), \
 
247
                   "invalid lock mode %r" % self._lock_mode
270
248
            self._lock_count += 1
271
249
        else:
272
250
            self._lock.lock_read()
 
251
            #note('read locking %s', self)
273
252
            #traceback.print_stack()
274
253
            self._lock_mode = 'r'
275
254
            self._lock_count = 1
278
257
            self.get_transaction().set_cache_size(5000)
279
258
                        
280
259
    def unlock(self):
 
260
        # mutter("unlock: %s (%s)", self, self._lock_count)
281
261
        if not self._lock_mode:
282
262
            raise errors.LockNotHeld(self)
283
263
        if self._lock_count > 1:
284
264
            self._lock_count -= 1
285
265
        else:
 
266
            #note('unlocking %s', self)
286
267
            #traceback.print_stack()
287
268
            self._finish_transaction()
288
269
            try: