← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: Ian Clatworthy
  • Date: 2008-03-27 07:51:10 UTC
  • mto: (3311.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3312.
  • Revision ID: ian.clatworthy@canonical.com-20080327075110-afgd7x03ybju06ez
Reduce evangelism in the User Guide

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.
123
118
        self._lock.break_lock()
124
119
 
125
120
    def _escape(self, file_or_path):
126
 
        """DEPRECATED: Do not use outside this class"""
127
121
        if not isinstance(file_or_path, basestring):
128
122
            file_or_path = '/'.join(file_or_path)
129
123
        if file_or_path == '':
130
124
            return u''
131
 
        return urlutils.escape(osutils.safe_unicode(file_or_path))
 
125
        return urlutils.escape(safe_unicode(file_or_path))
132
126
 
133
127
    def _find_modes(self):
134
 
        """Determine the appropriate modes for files and directories.
135
 
        
136
 
        :deprecated: Replaced by BzrDir._find_modes.
137
 
        """
 
128
        """Determine the appropriate modes for files and directories."""
138
129
        try:
139
130
            st = self._transport.stat('.')
140
131
        except errors.TransportNotPossible:
148
139
            self._dir_mode = (st.st_mode & 07777) | 00700
149
140
            # Remove the sticky and execute bits for files
150
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
151
146
 
152
 
    @deprecated_method(deprecated_in((1, 6, 0)))
153
147
    def controlfilename(self, file_or_path):
154
 
        """Return location relative to branch.
155
 
        
156
 
        :deprecated: Use Transport methods instead.
157
 
        """
 
148
        """Return location relative to branch."""
158
149
        return self._transport.abspath(self._escape(file_or_path))
159
150
 
160
151
    @needs_read_lock
161
 
    @deprecated_method(deprecated_in((1, 5, 0)))
162
152
    def get(self, relpath):
163
 
        """Get a file as a bytestream.
164
 
        
165
 
        :deprecated: Use a Transport instead of LockableFiles.
166
 
        """
 
153
        """Get a file as a bytestream."""
167
154
        relpath = self._escape(relpath)
168
155
        return self._transport.get(relpath)
169
156
 
170
157
    @needs_read_lock
171
 
    @deprecated_method(deprecated_in((1, 5, 0)))
172
158
    def get_utf8(self, relpath):
173
 
        """Get a file as a unicode stream.
174
 
        
175
 
        :deprecated: Use a Transport instead of LockableFiles.
176
 
        """
 
159
        """Get a file as a unicode stream."""
177
160
        relpath = self._escape(relpath)
178
161
        # DO NOT introduce an errors=replace here.
179
162
        return codecs.getreader('utf-8')(self._transport.get(relpath))
180
163
 
181
164
    @needs_write_lock
182
 
    @deprecated_method(deprecated_in((1, 6, 0)))
183
165
    def put(self, path, file):
184
166
        """Write a file.
185
167
        
186
168
        :param path: The path to put the file, relative to the .bzr control
187
169
                     directory
188
 
        :param file: A file-like or string object whose contents should be copied.
189
 
 
190
 
        :deprecated: Use Transport methods instead.
 
170
        :param f: A file-like or string object whose contents should be copied.
191
171
        """
192
172
        self._transport.put_file(self._escape(path), file, mode=self._file_mode)
193
173
 
194
174
    @needs_write_lock
195
 
    @deprecated_method(deprecated_in((1, 6, 0)))
196
175
    def put_bytes(self, path, a_string):
197
176
        """Write a string of bytes.
198
177
 
199
178
        :param path: The path to put the bytes, relative to the transport root.
200
 
        :param a_string: A string object, whose exact bytes are to be copied.
201
 
 
202
 
        :deprecated: Use Transport methods instead.
 
179
        :param string: A string object, whose exact bytes are to be copied.
203
180
        """
204
181
        self._transport.put_bytes(self._escape(path), a_string,
205
182
                                  mode=self._file_mode)
206
183
 
207
184
    @needs_write_lock
208
 
    @deprecated_method(deprecated_in((1, 6, 0)))
209
185
    def put_utf8(self, path, a_string):
210
186
        """Write a string, encoding as utf-8.
211
187
 
212
188
        :param path: The path to put the string, relative to the transport root.
213
189
        :param string: A string or unicode object whose contents should be copied.
214
 
 
215
 
        :deprecated: Use Transport methods instead.
216
190
        """
217
191
        # IterableFile would not be needed if Transport.put took iterables
218
192
        # instead of files.  ADHB 2005-12-25
247
221
        some other way, and need to synchronise this object's state with that
248
222
        fact.
249
223
        """
 
224
        # mutter("lock write: %s (%s)", self, self._lock_count)
250
225
        # TODO: Upgrade locking to support using a Transport,
251
226
        # and potentially a remote locking protocol
252
227
        if self._lock_mode:
257
232
            return self._token_from_lock
258
233
        else:
259
234
            token_from_lock = self._lock.lock_write(token=token)
 
235
            #note('write locking %s', self)
260
236
            #traceback.print_stack()
261
237
            self._lock_mode = 'w'
262
238
            self._lock_count = 1
265
241
            return token_from_lock
266
242
 
267
243
    def lock_read(self):
 
244
        # mutter("lock read: %s (%s)", self, self._lock_count)
268
245
        if self._lock_mode:
269
 
            if self._lock_mode not in ('r', 'w'):
270
 
                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
271
248
            self._lock_count += 1
272
249
        else:
273
250
            self._lock.lock_read()
 
251
            #note('read locking %s', self)
274
252
            #traceback.print_stack()
275
253
            self._lock_mode = 'r'
276
254
            self._lock_count = 1
279
257
            self.get_transaction().set_cache_size(5000)
280
258
                        
281
259
    def unlock(self):
 
260
        # mutter("unlock: %s (%s)", self, self._lock_count)
282
261
        if not self._lock_mode:
283
262
            raise errors.LockNotHeld(self)
284
263
        if self._lock_count > 1:
285
264
            self._lock_count -= 1
286
265
        else:
 
266
            #note('unlocking %s', self)
287
267
            #traceback.print_stack()
288
268
            self._finish_transaction()
289
269
            try: