~ubuntu-branches/debian/experimental/bzr/experimental

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: Bazaar Package Importer
  • Author(s): Jelmer Vernooij, James Westby, Jelmer Vernooij
  • Date: 2009-09-08 14:14:23 UTC
  • mfrom: (1.1.59 upstream)
  • Revision ID: james.westby@ubuntu.com-20090908141423-ilpel5hy4vxhzxrl
Tags: 1.18-1
[ James Westby ]
* New upstream release.

[ Jelmer Vernooij ]
* Bump standards version to 3.8.3.
* Remove unused patch system.

Show diffs side-by-side

added added

removed removed

Lines of Context:
24
24
from bzrlib import (
25
25
    counted_lock,
26
26
    errors,
 
27
    lock,
27
28
    osutils,
28
29
    transactions,
29
30
    urlutils,
64
65
class LockableFiles(object):
65
66
    """Object representing a set of related files locked within the same scope.
66
67
 
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.
 
68
    This coordinates access to the lock along with providing a transaction.
72
69
 
73
70
    LockableFiles manage a lock count and can be locked repeatedly by
74
71
    a single caller.  (The underlying lock implementation generally does not
76
73
 
77
74
    Instances of this class are often called control_files.
78
75
 
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
76
    This class is now deprecated; code should move to using the Transport
87
77
    directly for file operations and using the lock or CountedLock for
88
78
    locking.
150
140
    def _find_modes(self):
151
141
        """Determine the appropriate modes for files and directories.
152
142
 
153
 
        :deprecated: Replaced by BzrDir._find_modes.
 
143
        :deprecated: Replaced by BzrDir._find_creation_modes.
154
144
        """
155
145
        # XXX: The properties created by this can be removed or deprecated
156
146
        # once all the _get_text_store methods etc no longer use them.
169
159
            # Remove the sticky and execute bits for files
170
160
            self._file_mode = self._dir_mode & ~07111
171
161
 
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
162
    def leave_in_place(self):
248
163
        """Set this LockableFiles to not clear the physical lock on unlock."""
249
164
        self._lock.leave_in_place()
308
223
 
309
224
    def unlock(self):
310
225
        if not self._lock_mode:
311
 
            raise errors.LockNotHeld(self)
 
226
            return lock.cant_unlock_not_held(self)
312
227
        if self._lock_warner.lock_count > 1:
313
228
            self._lock_warner.lock_count -= 1
314
229
        else: