← 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: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockable_files.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from cStringIO import StringIO
18
 
 
19
17
from bzrlib.lazy_import import lazy_import
20
18
lazy_import(globals(), """
21
19
import codecs
24
22
from bzrlib import (
25
23
    counted_lock,
26
24
    errors,
 
25
    lock,
27
26
    osutils,
28
27
    transactions,
29
28
    urlutils,
31
30
""")
32
31
 
33
32
from bzrlib.decorators import (
34
 
    needs_read_lock,
35
 
    needs_write_lock,
36
 
    )
37
 
from bzrlib.symbol_versioning import (
38
 
    deprecated_in,
39
 
    deprecated_method,
 
33
    only_raises,
40
34
    )
41
35
 
42
36
 
64
58
class LockableFiles(object):
65
59
    """Object representing a set of related files locked within the same scope.
66
60
 
67
 
    These files are used by a WorkingTree, Repository or Branch, and should
68
 
    generally only be touched by that object.
69
 
 
70
 
    LockableFiles also provides some policy on top of Transport for encoding
71
 
    control files as utf-8.
 
61
    This coordinates access to the lock along with providing a transaction.
72
62
 
73
63
    LockableFiles manage a lock count and can be locked repeatedly by
74
64
    a single caller.  (The underlying lock implementation generally does not
76
66
 
77
67
    Instances of this class are often called control_files.
78
68
 
79
 
    This object builds on top of a Transport, which is used to actually write
80
 
    the files to disk, and an OSLock or LockDir, which controls how access to
81
 
    the files is controlled.  The particular type of locking used is set when
82
 
    the object is constructed.  In older formats OSLocks are used everywhere.
83
 
    in newer formats a LockDir is used for Repositories and Branches, and
84
 
    OSLocks for the local filesystem.
85
 
 
86
69
    This class is now deprecated; code should move to using the Transport
87
70
    directly for file operations and using the lock or CountedLock for
88
71
    locking.
150
133
    def _find_modes(self):
151
134
        """Determine the appropriate modes for files and directories.
152
135
 
153
 
        :deprecated: Replaced by BzrDir._find_modes.
 
136
        :deprecated: Replaced by BzrDir._find_creation_modes.
154
137
        """
155
138
        # XXX: The properties created by this can be removed or deprecated
156
139
        # once all the _get_text_store methods etc no longer use them.
169
152
            # Remove the sticky and execute bits for files
170
153
            self._file_mode = self._dir_mode & ~07111
171
154
 
172
 
    @deprecated_method(deprecated_in((1, 6, 0)))
173
 
    def controlfilename(self, file_or_path):
174
 
        """Return location relative to branch.
175
 
 
176
 
        :deprecated: Use Transport methods instead.
177
 
        """
178
 
        return self._transport.abspath(self._escape(file_or_path))
179
 
 
180
 
    @needs_read_lock
181
 
    @deprecated_method(deprecated_in((1, 5, 0)))
182
 
    def get(self, relpath):
183
 
        """Get a file as a bytestream.
184
 
 
185
 
        :deprecated: Use a Transport instead of LockableFiles.
186
 
        """
187
 
        relpath = self._escape(relpath)
188
 
        return self._transport.get(relpath)
189
 
 
190
 
    @needs_read_lock
191
 
    @deprecated_method(deprecated_in((1, 5, 0)))
192
 
    def get_utf8(self, relpath):
193
 
        """Get a file as a unicode stream.
194
 
 
195
 
        :deprecated: Use a Transport instead of LockableFiles.
196
 
        """
197
 
        relpath = self._escape(relpath)
198
 
        # DO NOT introduce an errors=replace here.
199
 
        return codecs.getreader('utf-8')(self._transport.get(relpath))
200
 
 
201
 
    @needs_write_lock
202
 
    @deprecated_method(deprecated_in((1, 6, 0)))
203
 
    def put(self, path, file):
204
 
        """Write a file.
205
 
 
206
 
        :param path: The path to put the file, relative to the .bzr control
207
 
                     directory
208
 
        :param file: A file-like or string object whose contents should be copied.
209
 
 
210
 
        :deprecated: Use Transport methods instead.
211
 
        """
212
 
        self._transport.put_file(self._escape(path), file, mode=self._file_mode)
213
 
 
214
 
    @needs_write_lock
215
 
    @deprecated_method(deprecated_in((1, 6, 0)))
216
 
    def put_bytes(self, path, a_string):
217
 
        """Write a string of bytes.
218
 
 
219
 
        :param path: The path to put the bytes, relative to the transport root.
220
 
        :param a_string: A string object, whose exact bytes are to be copied.
221
 
 
222
 
        :deprecated: Use Transport methods instead.
223
 
        """
224
 
        self._transport.put_bytes(self._escape(path), a_string,
225
 
                                  mode=self._file_mode)
226
 
 
227
 
    @needs_write_lock
228
 
    @deprecated_method(deprecated_in((1, 6, 0)))
229
 
    def put_utf8(self, path, a_string):
230
 
        """Write a string, encoding as utf-8.
231
 
 
232
 
        :param path: The path to put the string, relative to the transport root.
233
 
        :param string: A string or unicode object whose contents should be copied.
234
 
 
235
 
        :deprecated: Use Transport methods instead.
236
 
        """
237
 
        # IterableFile would not be needed if Transport.put took iterables
238
 
        # instead of files.  ADHB 2005-12-25
239
 
        # RBC 20060103 surely its not needed anyway, with codecs transcode
240
 
        # file support ?
241
 
        # JAM 20060103 We definitely don't want encode(..., 'replace')
242
 
        # these are valuable files which should have exact contents.
243
 
        if not isinstance(a_string, basestring):
244
 
            raise errors.BzrBadParameterNotString(a_string)
245
 
        self.put_bytes(path, a_string.encode('utf-8'))
246
 
 
247
155
    def leave_in_place(self):
248
156
        """Set this LockableFiles to not clear the physical lock on unlock."""
249
157
        self._lock.leave_in_place()
306
214
        """Setup a write transaction."""
307
215
        self._set_transaction(transactions.WriteTransaction())
308
216
 
 
217
    @only_raises(errors.LockNotHeld, errors.LockBroken)
309
218
    def unlock(self):
310
219
        if not self._lock_mode:
311
 
            raise errors.LockNotHeld(self)
 
220
            return lock.cant_unlock_not_held(self)
312
221
        if self._lock_warner.lock_count > 1:
313
222
            self._lock_warner.lock_count -= 1
314
223
        else: