~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

[merge] robert's knit-performance work

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2011 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from bzrlib.lazy_import import lazy_import
18
 
lazy_import(globals(), """
19
 
import warnings
20
 
 
21
 
from bzrlib import (
22
 
    counted_lock,
23
 
    errors,
24
 
    lock,
25
 
    osutils,
26
 
    transactions,
27
 
    urlutils,
28
 
    )
29
 
""")
30
 
 
31
 
from bzrlib.decorators import (
32
 
    only_raises,
33
 
    )
34
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from cStringIO import StringIO
 
18
import codecs
 
19
 
 
20
import bzrlib
 
21
from bzrlib.decorators import *
 
22
import bzrlib.errors as errors
 
23
from bzrlib.errors import LockError, ReadOnlyError
 
24
from bzrlib.osutils import file_iterator, safe_unicode
 
25
from bzrlib.symbol_versioning import *
 
26
from bzrlib.trace import mutter
 
27
import bzrlib.transactions as transactions
 
28
 
 
29
# XXX: The tracking here of lock counts and whether the lock is held is
 
30
# somewhat redundant with what's done in LockDir; the main difference is that
 
31
# LockableFiles permits reentrancy.
35
32
 
36
33
class LockableFiles(object):
37
34
    """Object representing a set of related files locked within the same scope.
38
35
 
39
 
    This coordinates access to the lock along with providing a transaction.
 
36
    These files are used by a WorkingTree, Repository or Branch, and should
 
37
    generally only be touched by that object.
 
38
 
 
39
    LockableFiles also provides some policy on top of Transport for encoding
 
40
    control files as utf-8.
40
41
 
41
42
    LockableFiles manage a lock count and can be locked repeatedly by
42
43
    a single caller.  (The underlying lock implementation generally does not
43
44
    support this.)
44
45
 
45
46
    Instances of this class are often called control_files.
46
 
 
47
 
    This class is now deprecated; code should move to using the Transport
48
 
    directly for file operations and using the lock or CountedLock for
49
 
    locking.
50
 
 
51
 
    :ivar _lock: The real underlying lock (e.g. a LockDir)
52
 
    :ivar _lock_count: If _lock_mode is true, a positive count of the number
53
 
        of times the lock has been taken (and not yet released) *by this
54
 
        process*, through this particular object instance.
55
 
    :ivar _lock_mode: None, or 'r' or 'w'
 
47
    
 
48
    This object builds on top of a Transport, which is used to actually write
 
49
    the files to disk, and an OSLock or LockDir, which controls how access to
 
50
    the files is controlled.  The particular type of locking used is set when
 
51
    the object is constructed.  In older formats OSLocks are used everywhere.
 
52
    in newer formats a LockDir is used for Repositories and Branches, and 
 
53
    OSLocks for the local filesystem.
56
54
    """
57
55
 
 
56
    # _lock_mode: None, or 'r' or 'w'
 
57
 
 
58
    # _lock_count: If _lock_mode is true, a positive count of the number of
 
59
    # times the lock has been taken *by this process*.   
 
60
    
 
61
    # If set to False (by a plugin, etc) BzrBranch will not set the
 
62
    # mode on created files or directories
 
63
    _set_file_mode = True
 
64
    _set_dir_mode = True
 
65
 
58
66
    def __init__(self, transport, lock_name, lock_class):
59
67
        """Create a LockableFiles group
60
68
 
61
 
        :param transport: Transport pointing to the directory holding the
 
69
        :param transport: Transport pointing to the directory holding the 
62
70
            control files and lock.
63
71
        :param lock_name: Name of the lock guarding these files.
64
72
        :param lock_class: Class of lock strategy to use: typically
65
73
            either LockDir or TransportLock.
66
74
        """
 
75
        object.__init__(self)
67
76
        self._transport = transport
68
77
        self.lock_name = lock_name
69
78
        self._transaction = None
 
79
        self._find_modes()
70
80
        self._lock_mode = None
71
81
        self._lock_count = 0
72
 
        self._find_modes()
73
82
        esc_name = self._escape(lock_name)
74
 
        self._lock = lock_class(transport, esc_name,
 
83
        self._lock = lock_class(transport, esc_name, 
75
84
                                file_modebits=self._file_mode,
76
85
                                dir_modebits=self._dir_mode)
77
 
        self._counted_lock = counted_lock.CountedLock(self._lock)
78
86
 
79
87
    def create_lock(self):
80
88
        """Create the lock.
82
90
        This should normally be called only when the LockableFiles directory
83
91
        is first created on disk.
84
92
        """
85
 
        self._lock.create(mode=self._dir_mode)
 
93
        self._lock.create()
86
94
 
87
95
    def __repr__(self):
88
96
        return '%s(%r)' % (self.__class__.__name__,
89
97
                           self._transport)
90
98
 
91
 
    def __str__(self):
92
 
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
93
 
 
94
 
    def break_lock(self):
95
 
        """Break the lock of this lockable files group if it is held.
96
 
 
97
 
        The current ui factory will be used to prompt for user conformation.
98
 
        """
99
 
        self._lock.break_lock()
100
 
 
101
99
    def _escape(self, file_or_path):
102
 
        """DEPRECATED: Do not use outside this class"""
103
100
        if not isinstance(file_or_path, basestring):
104
101
            file_or_path = '/'.join(file_or_path)
105
102
        if file_or_path == '':
106
103
            return u''
107
 
        return urlutils.escape(osutils.safe_unicode(file_or_path))
 
104
        return bzrlib.transport.urlescape(safe_unicode(file_or_path))
108
105
 
109
106
    def _find_modes(self):
110
 
        """Determine the appropriate modes for files and directories.
111
 
 
112
 
        :deprecated: Replaced by BzrDir._find_creation_modes.
113
 
        """
114
 
        # XXX: The properties created by this can be removed or deprecated
115
 
        # once all the _get_text_store methods etc no longer use them.
116
 
        # -- mbp 20080512
 
107
        """Determine the appropriate modes for files and directories."""
117
108
        try:
118
109
            st = self._transport.stat('.')
119
110
        except errors.TransportNotPossible:
120
111
            self._dir_mode = 0755
121
112
            self._file_mode = 0644
122
113
        else:
123
 
            # Check the directory mode, but also make sure the created
124
 
            # directories and files are read-write for this user. This is
125
 
            # mostly a workaround for filesystems which lie about being able to
126
 
            # write to a directory (cygwin & win32)
127
 
            self._dir_mode = (st.st_mode & 07777) | 00700
 
114
            self._dir_mode = st.st_mode & 07777
128
115
            # Remove the sticky and execute bits for files
129
116
            self._file_mode = self._dir_mode & ~07111
130
 
 
131
 
    def leave_in_place(self):
132
 
        """Set this LockableFiles to not clear the physical lock on unlock."""
133
 
        self._lock.leave_in_place()
134
 
 
135
 
    def dont_leave_in_place(self):
136
 
        """Set this LockableFiles to clear the physical lock on unlock."""
137
 
        self._lock.dont_leave_in_place()
138
 
 
139
 
    def lock_write(self, token=None):
140
 
        """Lock this group of files for writing.
141
 
 
142
 
        :param token: if this is already locked, then lock_write will fail
143
 
            unless the token matches the existing lock.
144
 
        :returns: a token if this instance supports tokens, otherwise None.
145
 
        :raises TokenLockingNotSupported: when a token is given but this
146
 
            instance doesn't support using token locks.
147
 
        :raises MismatchedToken: if the specified token doesn't match the token
148
 
            of the existing lock.
149
 
 
150
 
        A token should be passed in if you know that you have locked the object
151
 
        some other way, and need to synchronise this object's state with that
152
 
        fact.
153
 
        """
 
117
        if not self._set_dir_mode:
 
118
            self._dir_mode = None
 
119
        if not self._set_file_mode:
 
120
            self._file_mode = None
 
121
 
 
122
    def controlfilename(self, file_or_path):
 
123
        """Return location relative to branch."""
 
124
        return self._transport.abspath(self._escape(file_or_path))
 
125
 
 
126
    @deprecated_method(zero_eight)
 
127
    def controlfile(self, file_or_path, mode='r'):
 
128
        """Open a control file for this branch.
 
129
 
 
130
        There are two classes of file in a lockable directory: text
 
131
        and binary.  binary files are untranslated byte streams.  Text
 
132
        control files are stored with Unix newlines and in UTF-8, even
 
133
        if the platform or locale defaults are different.
 
134
 
 
135
        Such files are not openable in write mode : they are managed via
 
136
        put and put_utf8 which atomically replace old versions using
 
137
        atomicfile.
 
138
        """
 
139
 
 
140
        relpath = self._escape(file_or_path)
 
141
        # TODO: codecs.open() buffers linewise, so it was overloaded with
 
142
        # a much larger buffer, do we need to do the same for getreader/getwriter?
 
143
        if mode == 'rb': 
 
144
            return self.get(relpath)
 
145
        elif mode == 'wb':
 
146
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put[_utf8]")
 
147
        elif mode == 'r':
 
148
            return self.get_utf8(relpath)
 
149
        elif mode == 'w':
 
150
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put[_utf8]")
 
151
        else:
 
152
            raise BzrError("invalid controlfile mode %r" % mode)
 
153
 
 
154
    @needs_read_lock
 
155
    def get(self, relpath):
 
156
        """Get a file as a bytestream."""
 
157
        relpath = self._escape(relpath)
 
158
        return self._transport.get(relpath)
 
159
 
 
160
    @needs_read_lock
 
161
    def get_utf8(self, relpath):
 
162
        """Get a file as a unicode stream."""
 
163
        relpath = self._escape(relpath)
 
164
        # DO NOT introduce an errors=replace here.
 
165
        return codecs.getreader('utf-8')(self._transport.get(relpath))
 
166
 
 
167
    @needs_write_lock
 
168
    def put(self, path, file):
 
169
        """Write a file.
 
170
        
 
171
        :param path: The path to put the file, relative to the .bzr control
 
172
                     directory
 
173
        :param f: A file-like or string object whose contents should be copied.
 
174
        """
 
175
        self._transport.put(self._escape(path), file, mode=self._file_mode)
 
176
 
 
177
    @needs_write_lock
 
178
    def put_utf8(self, path, a_string):
 
179
        """Write a string, encoding as utf-8.
 
180
 
 
181
        :param path: The path to put the string, relative to the transport root.
 
182
        :param string: A file-like or string object whose contents should be copied.
 
183
        """
 
184
        # IterableFile would not be needed if Transport.put took iterables
 
185
        # instead of files.  ADHB 2005-12-25
 
186
        # RBC 20060103 surely its not needed anyway, with codecs transcode
 
187
        # file support ?
 
188
        # JAM 20060103 We definitely don't want encode(..., 'replace')
 
189
        # these are valuable files which should have exact contents.
 
190
        if not isinstance(a_string, basestring):
 
191
            raise errors.BzrBadParameterNotString(a_string)
 
192
        self.put(path, StringIO(a_string.encode('utf-8')))
 
193
 
 
194
    def lock_write(self):
 
195
        # mutter("lock write: %s (%s)", self, self._lock_count)
 
196
        # TODO: Upgrade locking to support using a Transport,
 
197
        # and potentially a remote locking protocol
154
198
        if self._lock_mode:
155
 
            if (self._lock_mode != 'w'
156
 
                or not self.get_transaction().writeable()):
157
 
                raise errors.ReadOnlyError(self)
158
 
            self._lock.validate_token(token)
 
199
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
 
200
                raise ReadOnlyError(self)
159
201
            self._lock_count += 1
160
 
            return self._token_from_lock
161
202
        else:
162
 
            token_from_lock = self._lock.lock_write(token=token)
163
 
            #traceback.print_stack()
 
203
            self._lock.lock_write()
164
204
            self._lock_mode = 'w'
165
205
            self._lock_count = 1
166
 
            self._set_write_transaction()
167
 
            self._token_from_lock = token_from_lock
168
 
            return token_from_lock
 
206
            self._set_transaction(transactions.WriteTransaction())
169
207
 
170
208
    def lock_read(self):
 
209
        # mutter("lock read: %s (%s)", self, self._lock_count)
171
210
        if self._lock_mode:
172
 
            if self._lock_mode not in ('r', 'w'):
173
 
                raise ValueError("invalid lock mode %r" % (self._lock_mode,))
 
211
            assert self._lock_mode in ('r', 'w'), \
 
212
                   "invalid lock mode %r" % self._lock_mode
174
213
            self._lock_count += 1
175
214
        else:
176
215
            self._lock.lock_read()
177
 
            #traceback.print_stack()
178
216
            self._lock_mode = 'r'
179
217
            self._lock_count = 1
180
 
            self._set_read_transaction()
181
 
 
182
 
    def _set_read_transaction(self):
183
 
        """Setup a read transaction."""
184
 
        self._set_transaction(transactions.ReadOnlyTransaction())
185
 
        # 5K may be excessive, but hey, its a knob.
186
 
        self.get_transaction().set_cache_size(5000)
187
 
 
188
 
    def _set_write_transaction(self):
189
 
        """Setup a write transaction."""
190
 
        self._set_transaction(transactions.WriteTransaction())
191
 
 
192
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
218
            self._set_transaction(transactions.ReadOnlyTransaction())
 
219
            # 5K may be excessive, but hey, its a knob.
 
220
            self.get_transaction().set_cache_size(5000)
 
221
                        
193
222
    def unlock(self):
 
223
        # mutter("unlock: %s (%s)", self, self._lock_count)
194
224
        if not self._lock_mode:
195
 
            return lock.cant_unlock_not_held(self)
 
225
            raise errors.LockNotHeld(self)
196
226
        if self._lock_count > 1:
197
227
            self._lock_count -= 1
198
228
        else:
199
 
            #traceback.print_stack()
200
229
            self._finish_transaction()
201
 
            try:
202
 
                self._lock.unlock()
203
 
            finally:
204
 
                self._lock_mode = self._lock_count = None
 
230
            self._lock.unlock()
 
231
            self._lock_mode = self._lock_count = None
205
232
 
206
233
    def is_locked(self):
207
234
        """Return true if this LockableFiles group is locked"""
208
235
        return self._lock_count >= 1
209
236
 
210
 
    def get_physical_lock_status(self):
211
 
        """Return physical lock status.
212
 
 
213
 
        Returns true if a lock is held on the transport. If no lock is held, or
214
 
        the underlying locking mechanism does not support querying lock
215
 
        status, false is returned.
216
 
        """
217
 
        try:
218
 
            return self._lock.peek() is not None
219
 
        except NotImplementedError:
220
 
            return False
221
 
 
222
237
    def get_transaction(self):
223
238
        """Return the current active transaction.
224
239
 
264
279
        self._file_modebits = file_modebits
265
280
        self._dir_modebits = dir_modebits
266
281
 
267
 
    def break_lock(self):
268
 
        raise NotImplementedError(self.break_lock)
269
 
 
270
 
    def leave_in_place(self):
271
 
        raise NotImplementedError(self.leave_in_place)
272
 
 
273
 
    def dont_leave_in_place(self):
274
 
        raise NotImplementedError(self.dont_leave_in_place)
275
 
 
276
 
    def lock_write(self, token=None):
277
 
        if token is not None:
278
 
            raise errors.TokenLockingNotSupported(self)
 
282
    def lock_write(self):
279
283
        self._lock = self._transport.lock_write(self._escaped_name)
280
284
 
281
285
    def lock_read(self):
285
289
        self._lock.unlock()
286
290
        self._lock = None
287
291
 
288
 
    def peek(self):
289
 
        raise NotImplementedError()
290
 
 
291
 
    def create(self, mode=None):
 
292
    def create(self):
292
293
        """Create lock mechanism"""
293
294
        # for old-style locks, create the file now
294
 
        self._transport.put_bytes(self._escaped_name, '',
 
295
        self._transport.put(self._escaped_name, StringIO(), 
295
296
                            mode=self._file_modebits)
296
 
 
297
 
    def validate_token(self, token):
298
 
        if token is not None:
299
 
            raise errors.TokenLockingNotSupported(self)