/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/mutabletree.py

  • Committer: Jelmer Vernooij
  • Date: 2020-01-12 13:56:10 UTC
  • mto: This revision was merged to the branch mainline in revision 7443.
  • Revision ID: jelmer@jelmer.uk-20200112135610-0a9bct6x4cw7he6y
Add strip_segment_parameters function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/mutabletree.py
 
1
# Copyright (C) 2006-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
"""MutableTree object.
 
18
 
 
19
See MutableTree for more details.
 
20
"""
 
21
 
 
22
from __future__ import absolute_import
 
23
 
 
24
from . import (
 
25
    errors,
 
26
    hooks,
 
27
    osutils,
 
28
    trace,
 
29
    tree,
 
30
    )
 
31
 
 
32
from .sixish import (
 
33
    text_type,
 
34
    )
 
35
 
 
36
 
 
37
class BadReferenceTarget(errors.InternalBzrError):
 
38
 
 
39
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
40
           "%(reason)s"
 
41
 
 
42
    def __init__(self, tree, other_tree, reason):
 
43
        self.tree = tree
 
44
        self.other_tree = other_tree
 
45
        self.reason = reason
 
46
 
 
47
 
 
48
class MutableTree(tree.Tree):
 
49
    """A MutableTree is a specialisation of Tree which is able to be mutated.
 
50
 
 
51
    Generally speaking these mutations are only possible within a lock_write
 
52
    context, and will revert if the lock is broken abnormally - but this cannot
 
53
    be guaranteed - depending on the exact implementation of the mutable state.
 
54
 
 
55
    The most common form of Mutable Tree is WorkingTree, see breezy.workingtree.
 
56
    For tests we also have MemoryTree which is a MutableTree whose contents are
 
57
    entirely in memory.
 
58
 
 
59
    For now, we are not treating MutableTree as an interface to provide
 
60
    conformance tests for - rather we are testing MemoryTree specifically, and
 
61
    interface testing implementations of WorkingTree.
 
62
 
 
63
    A mutable tree always has an associated Branch and ControlDir object - the
 
64
    branch and bzrdir attributes.
 
65
    """
 
66
 
 
67
    def __init__(self, *args, **kw):
 
68
        super(MutableTree, self).__init__(*args, **kw)
 
69
        # Is this tree on a case-insensitive or case-preserving file-system?
 
70
        # Sub-classes may initialize to False if they detect they are being
 
71
        # used on media which doesn't differentiate the case of names.
 
72
        self.case_sensitive = True
 
73
 
 
74
    def is_control_filename(self, filename):
 
75
        """True if filename is the name of a control file in this tree.
 
76
 
 
77
        :param filename: A filename within the tree. This is a relative path
 
78
            from the root of this tree.
 
79
 
 
80
        This is true IF and ONLY IF the filename is part of the meta data
 
81
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
82
        on disk will not be a control file for this tree.
 
83
        """
 
84
        raise NotImplementedError(self.is_control_filename)
 
85
 
 
86
    def add(self, files, ids=None, kinds=None):
 
87
        """Add paths to the set of versioned paths.
 
88
 
 
89
        Note that the command line normally calls smart_add instead,
 
90
        which can automatically recurse.
 
91
 
 
92
        This adds the files to the tree, so that they will be
 
93
        recorded by the next commit.
 
94
 
 
95
        :param files: List of paths to add, relative to the base of the tree.
 
96
        :param ids: If set, use these instead of automatically generated ids.
 
97
            Must be the same length as the list of files, but may
 
98
            contain None for ids that are to be autogenerated.
 
99
        :param kinds: Optional parameter to specify the kinds to be used for
 
100
            each file.
 
101
 
 
102
        TODO: Perhaps callback with the ids and paths as they're added.
 
103
        """
 
104
        if isinstance(files, (str, text_type)):
 
105
            # XXX: Passing a single string is inconsistent and should be
 
106
            # deprecated.
 
107
            if not (ids is None or isinstance(ids, bytes)):
 
108
                raise AssertionError()
 
109
            if not (kinds is None or isinstance(kinds, (str, text_type))):
 
110
                raise AssertionError()
 
111
            files = [files]
 
112
            if ids is not None:
 
113
                ids = [ids]
 
114
            if kinds is not None:
 
115
                kinds = [kinds]
 
116
 
 
117
        files = [path.strip('/') for path in files]
 
118
 
 
119
        if ids is None:
 
120
            ids = [None] * len(files)
 
121
        else:
 
122
            if not (len(ids) == len(files)):
 
123
                raise AssertionError()
 
124
        if kinds is None:
 
125
            kinds = [None] * len(files)
 
126
        elif not len(kinds) == len(files):
 
127
            raise AssertionError()
 
128
        with self.lock_tree_write():
 
129
            for f in files:
 
130
                # generic constraint checks:
 
131
                if self.is_control_filename(f):
 
132
                    raise errors.ForbiddenControlFileError(filename=f)
 
133
                fp = osutils.splitpath(f)
 
134
            # fill out file kinds for all files [not needed when we stop
 
135
            # caring about the instantaneous file kind within a uncommmitted tree
 
136
            #
 
137
            self._gather_kinds(files, kinds)
 
138
            self._add(files, ids, kinds)
 
139
 
 
140
    def add_reference(self, sub_tree):
 
141
        """Add a TreeReference to the tree, pointing at sub_tree.
 
142
 
 
143
        :param sub_tree: subtree to add.
 
144
        """
 
145
        raise errors.UnsupportedOperation(self.add_reference, self)
 
146
 
 
147
    def _add(self, files, ids, kinds):
 
148
        """Helper function for add - updates the inventory.
 
149
 
 
150
        :param files: sequence of pathnames, relative to the tree root
 
151
        :param ids: sequence of suggested ids for the files (may be None)
 
152
        :param kinds: sequence of  inventory kinds of the files (i.e. may
 
153
            contain "tree-reference")
 
154
        """
 
155
        raise NotImplementedError(self._add)
 
156
 
 
157
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
158
        # avoid circular imports
 
159
        from breezy import commit
 
160
        possible_master_transports = []
 
161
        with self.lock_write():
 
162
            revprops = commit.Commit.update_revprops(
 
163
                revprops,
 
164
                self.branch,
 
165
                kwargs.pop('authors', None),
 
166
                kwargs.get('local', False),
 
167
                possible_master_transports)
 
168
            # args for wt.commit start at message from the Commit.commit method,
 
169
            args = (message, ) + args
 
170
            for hook in MutableTree.hooks['start_commit']:
 
171
                hook(self)
 
172
            committed_id = commit.Commit().commit(working_tree=self,
 
173
                                                  revprops=revprops,
 
174
                                                  possible_master_transports=possible_master_transports,
 
175
                                                  *args, **kwargs)
 
176
            post_hook_params = PostCommitHookParams(self)
 
177
            for hook in MutableTree.hooks['post_commit']:
 
178
                hook(post_hook_params)
 
179
            return committed_id
 
180
 
 
181
    def _gather_kinds(self, files, kinds):
 
182
        """Helper function for add - sets the entries of kinds."""
 
183
        raise NotImplementedError(self._gather_kinds)
 
184
 
 
185
    def has_changes(self, _from_tree=None):
 
186
        """Quickly check that the tree contains at least one commitable change.
 
187
 
 
188
        :param _from_tree: tree to compare against to find changes (default to
 
189
            the basis tree and is intended to be used by tests).
 
190
 
 
191
        :return: True if a change is found. False otherwise
 
192
        """
 
193
        with self.lock_read():
 
194
            # Check pending merges
 
195
            if len(self.get_parent_ids()) > 1:
 
196
                return True
 
197
            if _from_tree is None:
 
198
                _from_tree = self.basis_tree()
 
199
            changes = self.iter_changes(_from_tree)
 
200
            if self.supports_symlinks():
 
201
                # Fast path for has_changes.
 
202
                try:
 
203
                    change = next(changes)
 
204
                    # Exclude root (talk about black magic... --vila 20090629)
 
205
                    if change.parent_id == (None, None):
 
206
                        change = next(changes)
 
207
                    return True
 
208
                except StopIteration:
 
209
                    # No changes
 
210
                    return False
 
211
            else:
 
212
                # Slow path for has_changes.
 
213
                # Handle platforms that do not support symlinks in the
 
214
                # conditional below. This is slower than the try/except
 
215
                # approach below that but we don't have a choice as we
 
216
                # need to be sure that all symlinks are removed from the
 
217
                # entire changeset. This is because in platforms that
 
218
                # do not support symlinks, they show up as None in the
 
219
                # working copy as compared to the repository.
 
220
                # Also, exclude root as mention in the above fast path.
 
221
                changes = filter(
 
222
                    lambda c: c[6][0] != 'symlink' and c[4] != (None, None),
 
223
                    changes)
 
224
                try:
 
225
                    next(iter(changes))
 
226
                except StopIteration:
 
227
                    return False
 
228
                return True
 
229
 
 
230
    def check_changed_or_out_of_date(self, strict, opt_name,
 
231
                                     more_error, more_warning):
 
232
        """Check the tree for uncommitted changes and branch synchronization.
 
233
 
 
234
        If strict is None and not set in the config files, a warning is issued.
 
235
        If strict is True, an error is raised.
 
236
        If strict is False, no checks are done and no warning is issued.
 
237
 
 
238
        :param strict: True, False or None, searched in branch config if None.
 
239
 
 
240
        :param opt_name: strict option name to search in config file.
 
241
 
 
242
        :param more_error: Details about how to avoid the check.
 
243
 
 
244
        :param more_warning: Details about what is happening.
 
245
        """
 
246
        with self.lock_read():
 
247
            if strict is None:
 
248
                strict = self.branch.get_config_stack().get(opt_name)
 
249
            if strict is not False:
 
250
                err_class = None
 
251
                if (self.has_changes()):
 
252
                    err_class = errors.UncommittedChanges
 
253
                elif self.last_revision() != self.branch.last_revision():
 
254
                    # The tree has lost sync with its branch, there is little
 
255
                    # chance that the user is aware of it but he can still
 
256
                    # force the action with --no-strict
 
257
                    err_class = errors.OutOfDateTree
 
258
                if err_class is not None:
 
259
                    if strict is None:
 
260
                        err = err_class(self, more=more_warning)
 
261
                        # We don't want to interrupt the user if he expressed
 
262
                        # no preference about strict.
 
263
                        trace.warning('%s', err._format())
 
264
                    else:
 
265
                        err = err_class(self, more=more_error)
 
266
                        raise err
 
267
 
 
268
    def last_revision(self):
 
269
        """Return the revision id of the last commit performed in this tree.
 
270
 
 
271
        In early tree formats the result of last_revision is the same as the
 
272
        branch last_revision, but that is no longer the case for modern tree
 
273
        formats.
 
274
 
 
275
        last_revision returns the left most parent id, or None if there are no
 
276
        parents.
 
277
 
 
278
        last_revision was deprecated as of 0.11. Please use get_parent_ids
 
279
        instead.
 
280
        """
 
281
        raise NotImplementedError(self.last_revision)
 
282
 
 
283
    def lock_tree_write(self):
 
284
        """Lock the working tree for write, and the branch for read.
 
285
 
 
286
        This is useful for operations which only need to mutate the working
 
287
        tree. Taking out branch write locks is a relatively expensive process
 
288
        and may fail if the branch is on read only media. So branch write locks
 
289
        should only be taken out when we are modifying branch data - such as in
 
290
        operations like commit, pull, uncommit and update.
 
291
        """
 
292
        raise NotImplementedError(self.lock_tree_write)
 
293
 
 
294
    def lock_write(self):
 
295
        """Lock the tree and its branch. This allows mutating calls to be made.
 
296
 
 
297
        Some mutating methods will take out implicit write locks, but in
 
298
        general you should always obtain a write lock before calling mutating
 
299
        methods on a tree.
 
300
        """
 
301
        raise NotImplementedError(self.lock_write)
 
302
 
 
303
    def mkdir(self, path, file_id=None):
 
304
        """Create a directory in the tree. if file_id is None, one is assigned.
 
305
 
 
306
        :param path: A unicode file path.
 
307
        :param file_id: An optional file-id.
 
308
        :return: the file id of the new directory.
 
309
        """
 
310
        raise NotImplementedError(self.mkdir)
 
311
 
 
312
    def _observed_sha1(self, path, sha_and_stat):
 
313
        """Tell the tree we have observed a paths sha1.
 
314
 
 
315
        The intent of this function is to allow trees that have a hashcache to
 
316
        update the hashcache during commit. If the observed file is too new
 
317
        (based on the stat_value) to be safely hash-cached the tree will ignore
 
318
        it.
 
319
 
 
320
        The default implementation does nothing.
 
321
 
 
322
        :param path: The file path
 
323
        :param sha_and_stat: The sha 1 and stat result observed.
 
324
        :return: None
 
325
        """
 
326
 
 
327
    def put_file_bytes_non_atomic(self, path, bytes):
 
328
        """Update the content of a file in the tree.
 
329
 
 
330
        Note that the file is written in-place rather than being
 
331
        written to a temporary location and renamed. As a consequence,
 
332
        readers can potentially see the file half-written.
 
333
 
 
334
        :param file_id: file-id of the file
 
335
        :param bytes: the new file contents
 
336
        """
 
337
        raise NotImplementedError(self.put_file_bytes_non_atomic)
 
338
 
 
339
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
340
        """Set the parents ids of the working tree.
 
341
 
 
342
        :param revision_ids: A list of revision_ids.
 
343
        """
 
344
        raise NotImplementedError(self.set_parent_ids)
 
345
 
 
346
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
347
        """Set the parents of the working tree.
 
348
 
 
349
        :param parents_list: A list of (revision_id, tree) tuples.
 
350
            If tree is None, then that element is treated as an unreachable
 
351
            parent tree - i.e. a ghost.
 
352
        """
 
353
        raise NotImplementedError(self.set_parent_trees)
 
354
 
 
355
    def smart_add(self, file_list, recurse=True, action=None, save=True):
 
356
        """Version file_list, optionally recursing into directories.
 
357
 
 
358
        This is designed more towards DWIM for humans than API clarity.
 
359
        For the specific behaviour see the help for cmd_add().
 
360
 
 
361
        :param file_list: List of zero or more paths.  *NB: these are
 
362
            interpreted relative to the process cwd, not relative to the
 
363
            tree.*  (Add and most other tree methods use tree-relative
 
364
            paths.)
 
365
        :param action: A reporter to be called with the working tree, parent_ie,
 
366
            path and kind of the path being added. It may return a file_id if
 
367
            a specific one should be used.
 
368
        :param save: Save the changes after completing the adds. If False
 
369
            this provides dry-run functionality by doing the add and not saving
 
370
            the changes.
 
371
        :return: A tuple - files_added, ignored_files. files_added is the count
 
372
            of added files, and ignored_files is a dict mapping files that were
 
373
            ignored to the rule that caused them to be ignored.
 
374
        """
 
375
        raise NotImplementedError(self.smart_add)
 
376
 
 
377
    def rename_one(self, from_rel, to_rel, after=False):
 
378
        """Rename one file.
 
379
 
 
380
        This can change the directory or the filename or both.
 
381
 
 
382
        rename_one has several 'modes' to work. First, it can rename a physical
 
383
        file and change the file_id. That is the normal mode. Second, it can
 
384
        only change the file_id without touching any physical file.
 
385
 
 
386
        rename_one uses the second mode if 'after == True' and 'to_rel' is
 
387
        either not versioned or newly added, and present in the working tree.
 
388
 
 
389
        rename_one uses the second mode if 'after == False' and 'from_rel' is
 
390
        versioned but no longer in the working tree, and 'to_rel' is not
 
391
        versioned but present in the working tree.
 
392
 
 
393
        rename_one uses the first mode if 'after == False' and 'from_rel' is
 
394
        versioned and present in the working tree, and 'to_rel' is not
 
395
        versioned and not present in the working tree.
 
396
 
 
397
        Everything else results in an error.
 
398
        """
 
399
        raise NotImplementedError(self.rename_one)
 
400
 
 
401
    def copy_one(self, from_rel, to_rel):
 
402
        """Copy one file or directory.
 
403
 
 
404
        This can change the directory or the filename or both.
 
405
 
 
406
        """
 
407
        raise NotImplementedError(self.copy_one)
 
408
 
 
409
    def get_transform(self, pb=None):
 
410
        """Return a transform object for use with this tree."""
 
411
        raise NotImplementedError(self.get_transform)
 
412
 
 
413
 
 
414
class MutableTreeHooks(hooks.Hooks):
 
415
    """A dictionary mapping a hook name to a list of callables for mutabletree
 
416
    hooks.
 
417
    """
 
418
 
 
419
    def __init__(self):
 
420
        """Create the default hooks.
 
421
 
 
422
        """
 
423
        hooks.Hooks.__init__(self, "breezy.mutabletree", "MutableTree.hooks")
 
424
        self.add_hook('start_commit',
 
425
                      "Called before a commit is performed on a tree. The start commit "
 
426
                      "hook is able to change the tree before the commit takes place. "
 
427
                      "start_commit is called with the breezy.mutabletree.MutableTree "
 
428
                      "that the commit is being performed on.", (1, 4))
 
429
        self.add_hook('post_commit',
 
430
                      "Called after a commit is performed on a tree. The hook is "
 
431
                      "called with a breezy.mutabletree.PostCommitHookParams object. "
 
432
                      "The mutable tree the commit was performed on is available via "
 
433
                      "the mutable_tree attribute of that object.", (2, 0))
 
434
        self.add_hook('pre_transform',
 
435
                      "Called before a tree transform on this tree. The hook is called "
 
436
                      "with the tree that is being transformed and the transform.",
 
437
                      (2, 5))
 
438
        self.add_hook('post_build_tree',
 
439
                      "Called after a completely new tree is built. The hook is "
 
440
                      "called with the tree as its only argument.", (2, 5))
 
441
        self.add_hook('post_transform',
 
442
                      "Called after a tree transform has been performed on a tree. "
 
443
                      "The hook is called with the tree that is being transformed and "
 
444
                      "the transform.",
 
445
                      (2, 5))
 
446
 
 
447
 
 
448
# install the default hooks into the MutableTree class.
 
449
MutableTree.hooks = MutableTreeHooks()
 
450
 
 
451
 
 
452
class PostCommitHookParams(object):
 
453
    """Parameters for the post_commit hook.
 
454
 
 
455
    To access the parameters, use the following attributes:
 
456
 
 
457
    * mutable_tree - the MutableTree object
 
458
    """
 
459
 
 
460
    def __init__(self, mutable_tree):
 
461
        """Create the parameters for the post_commit hook."""
 
462
        self.mutable_tree = mutable_tree