/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 breezy/lockable_files.py

  • Committer: Jelmer Vernooij
  • Date: 2020-09-02 16:35:18 UTC
  • mto: (7490.40.109 work)
  • mto: This revision was merged to the branch mainline in revision 7526.
  • Revision ID: jelmer@jelmer.uk-20200902163518-sy9f4unbboljphgu
Handle duplicate directories entries for git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/lockable_files.py
 
1
# Copyright (C) 2005-2011 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
 
18
 
 
19
from .lazy_import import lazy_import
 
20
lazy_import(globals(), """
 
21
from breezy import (
 
22
    counted_lock,
 
23
    lock,
 
24
    transactions,
 
25
    urlutils,
 
26
    )
 
27
""")
 
28
 
 
29
from . import (
 
30
    errors,
 
31
    )
 
32
from .decorators import (
 
33
    only_raises,
 
34
    )
 
35
 
 
36
 
 
37
class LockableFiles(object):
 
38
    """Object representing a set of related files locked within the same scope.
 
39
 
 
40
    This coordinates access to the lock along with providing a transaction.
 
41
 
 
42
    LockableFiles manage a lock count and can be locked repeatedly by
 
43
    a single caller.  (The underlying lock implementation generally does not
 
44
    support this.)
 
45
 
 
46
    Instances of this class are often called control_files.
 
47
 
 
48
    This class is now deprecated; code should move to using the Transport
 
49
    directly for file operations and using the lock or CountedLock for
 
50
    locking.
 
51
 
 
52
    :ivar _lock: The real underlying lock (e.g. a LockDir)
 
53
    :ivar _lock_count: If _lock_mode is true, a positive count of the number
 
54
        of times the lock has been taken (and not yet released) *by this
 
55
        process*, through this particular object instance.
 
56
    :ivar _lock_mode: None, or 'r' or 'w'
 
57
    """
 
58
 
 
59
    def __init__(self, transport, lock_name, lock_class):
 
60
        """Create a LockableFiles group
 
61
 
 
62
        :param transport: Transport pointing to the directory holding the
 
63
            control files and lock.
 
64
        :param lock_name: Name of the lock guarding these files.
 
65
        :param lock_class: Class of lock strategy to use: typically
 
66
            either LockDir or TransportLock.
 
67
        """
 
68
        self._transport = transport
 
69
        self.lock_name = lock_name
 
70
        self._transaction = None
 
71
        self._lock_mode = None
 
72
        self._lock_count = 0
 
73
        self._find_modes()
 
74
        esc_name = self._escape(lock_name)
 
75
        self._lock = lock_class(transport, esc_name,
 
76
                                file_modebits=self._file_mode,
 
77
                                dir_modebits=self._dir_mode)
 
78
        self._counted_lock = counted_lock.CountedLock(self._lock)
 
79
 
 
80
    def create_lock(self):
 
81
        """Create the lock.
 
82
 
 
83
        This should normally be called only when the LockableFiles directory
 
84
        is first created on disk.
 
85
        """
 
86
        self._lock.create(mode=self._dir_mode)
 
87
 
 
88
    def __repr__(self):
 
89
        return '%s(%r)' % (self.__class__.__name__,
 
90
                           self._transport)
 
91
 
 
92
    def __str__(self):
 
93
        return 'LockableFiles(%s, %s)' % (self.lock_name, self._transport.base)
 
94
 
 
95
    def break_lock(self):
 
96
        """Break the lock of this lockable files group if it is held.
 
97
 
 
98
        The current ui factory will be used to prompt for user conformation.
 
99
        """
 
100
        self._lock.break_lock()
 
101
 
 
102
    def _escape(self, file_or_path):
 
103
        """DEPRECATED: Do not use outside this class"""
 
104
        if file_or_path == '':
 
105
            return u''
 
106
        return urlutils.escape(file_or_path)
 
107
 
 
108
    def _find_modes(self):
 
109
        """Determine the appropriate modes for files and directories.
 
110
 
 
111
        :deprecated: Replaced by BzrDir._find_creation_modes.
 
112
        """
 
113
        # XXX: The properties created by this can be removed or deprecated
 
114
        # once all the _get_text_store methods etc no longer use them.
 
115
        # -- mbp 20080512
 
116
        try:
 
117
            st = self._transport.stat('.')
 
118
        except errors.TransportNotPossible:
 
119
            self._dir_mode = 0o755
 
120
            self._file_mode = 0o644
 
121
        else:
 
122
            # Check the directory mode, but also make sure the created
 
123
            # directories and files are read-write for this user. This is
 
124
            # mostly a workaround for filesystems which lie about being able to
 
125
            # write to a directory (cygwin & win32)
 
126
            self._dir_mode = (st.st_mode & 0o7777) | 0o0700
 
127
            # Remove the sticky and execute bits for files
 
128
            self._file_mode = self._dir_mode & ~0o7111
 
129
 
 
130
    def leave_in_place(self):
 
131
        """Set this LockableFiles to not clear the physical lock on unlock."""
 
132
        self._lock.leave_in_place()
 
133
 
 
134
    def dont_leave_in_place(self):
 
135
        """Set this LockableFiles to clear the physical lock on unlock."""
 
136
        self._lock.dont_leave_in_place()
 
137
 
 
138
    def lock_write(self, token=None):
 
139
        """Lock this group of files for writing.
 
140
 
 
141
        :param token: if this is already locked, then lock_write will fail
 
142
            unless the token matches the existing lock.
 
143
        :returns: a token if this instance supports tokens, otherwise None.
 
144
        :raises TokenLockingNotSupported: when a token is given but this
 
145
            instance doesn't support using token locks.
 
146
        :raises MismatchedToken: if the specified token doesn't match the token
 
147
            of the existing lock.
 
148
 
 
149
        A token should be passed in if you know that you have locked the object
 
150
        some other way, and need to synchronise this object's state with that
 
151
        fact.
 
152
        """
 
153
        if self._lock_mode:
 
154
            if (self._lock_mode != 'w'
 
155
                    or not self.get_transaction().writeable()):
 
156
                raise errors.ReadOnlyError(self)
 
157
            self._lock.validate_token(token)
 
158
            self._lock_count += 1
 
159
            return self._token_from_lock
 
160
        else:
 
161
            token_from_lock = self._lock.lock_write(token=token)
 
162
            # traceback.print_stack()
 
163
            self._lock_mode = 'w'
 
164
            self._lock_count = 1
 
165
            self._set_write_transaction()
 
166
            self._token_from_lock = token_from_lock
 
167
            return token_from_lock
 
168
 
 
169
    def lock_read(self):
 
170
        if self._lock_mode:
 
171
            if self._lock_mode not in ('r', 'w'):
 
172
                raise ValueError("invalid lock mode %r" % (self._lock_mode,))
 
173
            self._lock_count += 1
 
174
        else:
 
175
            self._lock.lock_read()
 
176
            # traceback.print_stack()
 
177
            self._lock_mode = 'r'
 
178
            self._lock_count = 1
 
179
            self._set_read_transaction()
 
180
 
 
181
    def _set_read_transaction(self):
 
182
        """Setup a read transaction."""
 
183
        self._set_transaction(transactions.ReadOnlyTransaction())
 
184
        # 5K may be excessive, but hey, its a knob.
 
185
        self.get_transaction().set_cache_size(5000)
 
186
 
 
187
    def _set_write_transaction(self):
 
188
        """Setup a write transaction."""
 
189
        self._set_transaction(transactions.WriteTransaction())
 
190
 
 
191
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
192
    def unlock(self):
 
193
        if not self._lock_mode:
 
194
            return lock.cant_unlock_not_held(self)
 
195
        if self._lock_count > 1:
 
196
            self._lock_count -= 1
 
197
        else:
 
198
            # traceback.print_stack()
 
199
            self._finish_transaction()
 
200
            try:
 
201
                self._lock.unlock()
 
202
            finally:
 
203
                self._lock_count = 0
 
204
                self._lock_mode = None
 
205
 
 
206
    def is_locked(self):
 
207
        """Return true if this LockableFiles group is locked"""
 
208
        return self._lock_count >= 1
 
209
 
 
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
    def get_transaction(self):
 
223
        """Return the current active transaction.
 
224
 
 
225
        If no transaction is active, this returns a passthrough object
 
226
        for which all data is immediately flushed and no caching happens.
 
227
        """
 
228
        if self._transaction is None:
 
229
            return transactions.PassThroughTransaction()
 
230
        else:
 
231
            return self._transaction
 
232
 
 
233
    def _set_transaction(self, new_transaction):
 
234
        """Set a new active transaction."""
 
235
        if self._transaction is not None:
 
236
            raise errors.LockError('Branch %s is in a transaction already.' %
 
237
                                   self)
 
238
        self._transaction = new_transaction
 
239
 
 
240
    def _finish_transaction(self):
 
241
        """Exit the current transaction."""
 
242
        if self._transaction is None:
 
243
            raise errors.LockError('Branch %s is not in a transaction' %
 
244
                                   self)
 
245
        transaction = self._transaction
 
246
        self._transaction = None
 
247
        transaction.finish()
 
248
 
 
249
 
 
250
class TransportLock(object):
 
251
    """Locking method which uses transport-dependent locks.
 
252
 
 
253
    On the local filesystem these transform into OS-managed locks.
 
254
 
 
255
    These do not guard against concurrent access via different
 
256
    transports.
 
257
 
 
258
    This is suitable for use only in WorkingTrees (which are at present
 
259
    always local).
 
260
    """
 
261
 
 
262
    def __init__(self, transport, escaped_name, file_modebits, dir_modebits):
 
263
        self._transport = transport
 
264
        self._escaped_name = escaped_name
 
265
        self._file_modebits = file_modebits
 
266
        self._dir_modebits = dir_modebits
 
267
 
 
268
    def break_lock(self):
 
269
        raise NotImplementedError(self.break_lock)
 
270
 
 
271
    def leave_in_place(self):
 
272
        raise NotImplementedError(self.leave_in_place)
 
273
 
 
274
    def dont_leave_in_place(self):
 
275
        raise NotImplementedError(self.dont_leave_in_place)
 
276
 
 
277
    def lock_write(self, token=None):
 
278
        if token is not None:
 
279
            raise errors.TokenLockingNotSupported(self)
 
280
        self._lock = self._transport.lock_write(self._escaped_name)
 
281
 
 
282
    def lock_read(self):
 
283
        self._lock = self._transport.lock_read(self._escaped_name)
 
284
 
 
285
    def unlock(self):
 
286
        self._lock.unlock()
 
287
        self._lock = None
 
288
 
 
289
    def peek(self):
 
290
        raise NotImplementedError()
 
291
 
 
292
    def create(self, mode=None):
 
293
        """Create lock mechanism"""
 
294
        # for old-style locks, create the file now
 
295
        self._transport.put_bytes(self._escaped_name, b'',
 
296
                                  mode=self._file_modebits)
 
297
 
 
298
    def validate_token(self, token):
 
299
        if token is not None:
 
300
            raise errors.TokenLockingNotSupported(self)