/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

  • Committer: Martin Pool
  • Date: 2006-03-03 07:31:24 UTC
  • mto: This revision was merged to the branch mainline in revision 1593.
  • Revision ID: mbp@sourcefrog.net-20060303073124-c0741f11f36d7236
doc

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockable_files.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
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.symbol_versioning import deprecated_method, zero_eight
 
27
from bzrlib.trace import mutter
 
28
import bzrlib.transactions as transactions
 
29
 
 
30
# XXX: The tracking here of lock counts and whether the lock is held is
 
31
# somewhat redundant with what's done in LockDir; the main difference is that
 
32
# LockableFiles permits reentrancy.
 
33
 
 
34
class LockableFiles(object):
 
35
    """Object representing a set of related files locked within the same scope.
 
36
 
 
37
    These files are used by a WorkingTree, Repository or Branch, and should
 
38
    generally only be touched by that object.
 
39
 
 
40
    LockableFiles also provides some policy on top of Transport for encoding
 
41
    control files as utf-8.
 
42
 
 
43
    LockableFiles manage a lock count and can be locked repeatedly by
 
44
    a single caller.  (The underlying lock implementation generally does not
 
45
    support this.)
 
46
 
 
47
    Instances of this class are often called control_files.
 
48
    
 
49
    This object builds on top of a Transport, which is used to actually write
 
50
    the files to disk, and an OSLock or LockDir, which controls how access to
 
51
    the files is controlled.  The particular type of locking used is set when
 
52
    the object is constructed.  In older formats OSLocks are used everywhere.
 
53
    in newer formats a LockDir is used for Repositories and Branches, and 
 
54
    OSLocks for the local filesystem.
 
55
    """
 
56
 
 
57
    _lock_mode = None               # None, or 'r' or 'w'
 
58
 
 
59
    # If _lock_mode is true, a positive count of the number of times the
 
60
    # lock has been taken *by this process*.  Others may have compatible 
 
61
    # read locks.
 
62
    _lock_count = None
 
63
 
 
64
    # If set to False (by a plugin, etc) BzrBranch will not set the
 
65
    # mode on created files or directories
 
66
    _set_file_mode = True
 
67
    _set_dir_mode = True
 
68
 
 
69
    def __init__(self, transport, lock_name, lock_strategy_class=None):
 
70
        """Create a LockableFiles group
 
71
 
 
72
        :param transport: Transport pointing to the directory holding the 
 
73
            control files and lock.
 
74
        :param lock_name: Name of the lock guarding these files.
 
75
        :param lock_strategy_class: Class of lock strategy to use.
 
76
        """
 
77
        object.__init__(self)
 
78
        self._transport = transport
 
79
        self.lock_name = lock_name
 
80
        self._transaction = None
 
81
        self._find_modes()
 
82
        # TODO: remove this and make the parameter mandatory
 
83
        if lock_strategy_class is None:
 
84
            lock_strategy_class = TransportLock
 
85
        esc_name = self._escape(lock_name)
 
86
        self._lock_strategy = lock_strategy_class(transport, esc_name)
 
87
 
 
88
    def _escape(self, file_or_path):
 
89
        if not isinstance(file_or_path, basestring):
 
90
            file_or_path = '/'.join(file_or_path)
 
91
        if file_or_path == '':
 
92
            return u''
 
93
        return bzrlib.transport.urlescape(safe_unicode(file_or_path))
 
94
 
 
95
    def _find_modes(self):
 
96
        """Determine the appropriate modes for files and directories."""
 
97
        try:
 
98
            st = self._transport.stat('.')
 
99
        except errors.TransportNotPossible:
 
100
            self._dir_mode = 0755
 
101
            self._file_mode = 0644
 
102
        else:
 
103
            self._dir_mode = st.st_mode & 07777
 
104
            # Remove the sticky and execute bits for files
 
105
            self._file_mode = self._dir_mode & ~07111
 
106
        if not self._set_dir_mode:
 
107
            self._dir_mode = None
 
108
        if not self._set_file_mode:
 
109
            self._file_mode = None
 
110
 
 
111
    def controlfilename(self, file_or_path):
 
112
        """Return location relative to branch."""
 
113
        return self._transport.abspath(self._escape(file_or_path))
 
114
 
 
115
    @deprecated_method(zero_eight)
 
116
    def controlfile(self, file_or_path, mode='r'):
 
117
        """Open a control file for this branch.
 
118
 
 
119
        There are two classes of file in a lockable directory: text
 
120
        and binary.  binary files are untranslated byte streams.  Text
 
121
        control files are stored with Unix newlines and in UTF-8, even
 
122
        if the platform or locale defaults are different.
 
123
 
 
124
        Such files are not openable in write mode : they are managed via
 
125
        put and put_utf8 which atomically replace old versions using
 
126
        atomicfile.
 
127
        """
 
128
 
 
129
        relpath = self._escape(file_or_path)
 
130
        # TODO: codecs.open() buffers linewise, so it was overloaded with
 
131
        # a much larger buffer, do we need to do the same for getreader/getwriter?
 
132
        if mode == 'rb': 
 
133
            return self.get(relpath)
 
134
        elif mode == 'wb':
 
135
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put[_utf8]")
 
136
        elif mode == 'r':
 
137
            return self.get_utf8(relpath)
 
138
        elif mode == 'w':
 
139
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put[_utf8]")
 
140
        else:
 
141
            raise BzrError("invalid controlfile mode %r" % mode)
 
142
 
 
143
    @needs_read_lock
 
144
    def get(self, relpath):
 
145
        """Get a file as a bytestream."""
 
146
        relpath = self._escape(relpath)
 
147
        return self._transport.get(relpath)
 
148
 
 
149
    @needs_read_lock
 
150
    def get_utf8(self, relpath):
 
151
        """Get a file as a unicode stream."""
 
152
        relpath = self._escape(relpath)
 
153
        # DO NOT introduce an errors=replace here.
 
154
        return codecs.getreader('utf-8')(self._transport.get(relpath))
 
155
 
 
156
    @needs_write_lock
 
157
    def put(self, path, file):
 
158
        """Write a file.
 
159
        
 
160
        :param path: The path to put the file, relative to the .bzr control
 
161
                     directory
 
162
        :param f: A file-like or string object whose contents should be copied.
 
163
        """
 
164
        self._transport.put(self._escape(path), file, mode=self._file_mode)
 
165
 
 
166
    @needs_write_lock
 
167
    def put_utf8(self, path, a_string):
 
168
        """Write a string, encoding as utf-8.
 
169
 
 
170
        :param path: The path to put the string, relative to the transport root.
 
171
        :param string: A file-like or string object whose contents should be copied.
 
172
        """
 
173
        # IterableFile would not be needed if Transport.put took iterables
 
174
        # instead of files.  ADHB 2005-12-25
 
175
        # RBC 20060103 surely its not needed anyway, with codecs transcode
 
176
        # file support ?
 
177
        # JAM 20060103 We definitely don't want encode(..., 'replace')
 
178
        # these are valuable files which should have exact contents.
 
179
        if not isinstance(a_string, basestring):
 
180
            raise errors.BzrBadParameterNotString(a_string)
 
181
        self.put(path, StringIO(a_string.encode('utf-8')))
 
182
 
 
183
    def lock_write(self):
 
184
        # mutter("lock write: %s (%s)", self, self._lock_count)
 
185
        # TODO: Upgrade locking to support using a Transport,
 
186
        # and potentially a remote locking protocol
 
187
        if self._lock_mode:
 
188
            if self._lock_mode != 'w':
 
189
                raise ReadOnlyError(self)
 
190
            self._lock_count += 1
 
191
        else:
 
192
            self._lock_strategy.lock_write()
 
193
            self._lock_mode = 'w'
 
194
            self._lock_count = 1
 
195
            self._set_transaction(transactions.PassThroughTransaction())
 
196
 
 
197
    def lock_read(self):
 
198
        # mutter("lock read: %s (%s)", self, self._lock_count)
 
199
        if self._lock_mode:
 
200
            assert self._lock_mode in ('r', 'w'), \
 
201
                   "invalid lock mode %r" % self._lock_mode
 
202
            self._lock_count += 1
 
203
        else:
 
204
            self._lock_strategy.lock_read()
 
205
            self._lock_mode = 'r'
 
206
            self._lock_count = 1
 
207
            self._set_transaction(transactions.ReadOnlyTransaction())
 
208
            # 5K may be excessive, but hey, its a knob.
 
209
            self.get_transaction().set_cache_size(5000)
 
210
                        
 
211
    def unlock(self):
 
212
        # mutter("unlock: %s (%s)", self, self._lock_count)
 
213
        if not self._lock_mode:
 
214
            raise errors.LockNotHeld(self)
 
215
        if self._lock_count > 1:
 
216
            self._lock_count -= 1
 
217
        else:
 
218
            self._finish_transaction()
 
219
            self._lock_strategy.unlock()
 
220
            self._lock_mode = self._lock_count = None
 
221
 
 
222
    def is_locked(self):
 
223
        """Return true if this LockableFiles group is locked"""
 
224
        return self._lock_count >= 1
 
225
 
 
226
    def get_transaction(self):
 
227
        """Return the current active transaction.
 
228
 
 
229
        If no transaction is active, this returns a passthrough object
 
230
        for which all data is immediately flushed and no caching happens.
 
231
        """
 
232
        if self._transaction is None:
 
233
            return transactions.PassThroughTransaction()
 
234
        else:
 
235
            return self._transaction
 
236
 
 
237
    def _set_transaction(self, new_transaction):
 
238
        """Set a new active transaction."""
 
239
        if self._transaction is not None:
 
240
            raise errors.LockError('Branch %s is in a transaction already.' %
 
241
                                   self)
 
242
        self._transaction = new_transaction
 
243
 
 
244
    def _finish_transaction(self):
 
245
        """Exit the current transaction."""
 
246
        if self._transaction is None:
 
247
            raise errors.LockError('Branch %s is not in a transaction' %
 
248
                                   self)
 
249
        transaction = self._transaction
 
250
        self._transaction = None
 
251
        transaction.finish()
 
252
 
 
253
 
 
254
class TransportLock(object):
 
255
    """Locking method which uses transport-dependent locks.
 
256
 
 
257
    On the local filesystem these transform into OS-managed locks.
 
258
 
 
259
    These do not guard against concurrent access via different
 
260
    transports.
 
261
 
 
262
    This is suitable for use only in WorkingTrees (which are at present
 
263
    always local).
 
264
    """
 
265
    def __init__(self, transport, escaped_name):
 
266
        self._transport = transport
 
267
        self._escaped_name = escaped_name
 
268
 
 
269
    def lock_write(self):
 
270
        self._lock = self._transport.lock_write(self._escaped_name)
 
271
 
 
272
    def lock_read(self):
 
273
        self._lock = self._transport.lock_read(self._escaped_name)
 
274
 
 
275
    def unlock(self):
 
276
        self._lock.unlock()
 
277
        self._lock = None
 
278
 
 
279
    # TODO: for old locks we have to manually create the file the first time
 
280
    # it's used; this should be here too.