/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

merge bzr.dev r3564

Show diffs side-by-side

added added

removed removed

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