← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-04-09 20:23:07 UTC
  • mfrom: (4265.1.4 bbc-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20090409202307-n0depb16qepoe21o
(jam) Change _fetch_uses_deltas = False for CHK repos until we can
        write a better fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
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
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
25
25
import os
26
 
import re
27
26
 
28
27
from bzrlib import (
29
28
    add,
30
29
    bzrdir,
 
30
    hooks,
 
31
    symbol_versioning,
 
32
    )
 
33
from bzrlib.osutils import dirname
 
34
from bzrlib.revisiontree import RevisionTree
 
35
from bzrlib.trace import mutter, warning
 
36
""")
 
37
 
 
38
from bzrlib import (
31
39
    errors,
32
 
    hooks,
33
40
    osutils,
34
 
    revisiontree,
35
 
    symbol_versioning,
36
 
    trace,
37
41
    tree,
38
42
    )
39
 
""")
40
 
 
41
43
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
44
from bzrlib.osutils import splitpath
42
45
 
43
46
 
44
47
def needs_tree_write_lock(unbound):
126
129
            # generic constraint checks:
127
130
            if self.is_control_filename(f):
128
131
                raise errors.ForbiddenControlFileError(filename=f)
129
 
            fp = osutils.splitpath(f)
 
132
            fp = splitpath(f)
130
133
        # fill out file kinds for all files [not needed when we stop
131
134
        # caring about the instantaneous file kind within a uncommmitted tree
132
135
        #
223
226
            revprops=revprops,
224
227
            possible_master_transports=possible_master_transports,
225
228
            *args, **kwargs)
226
 
        post_hook_params = PostCommitHookParams(self)
227
 
        for hook in MutableTree.hooks['post_commit']:
228
 
            hook(post_hook_params)
229
229
        return committed_id
230
230
 
231
231
    def _gather_kinds(self, files, kinds):
232
232
        """Helper function for add - sets the entries of kinds."""
233
233
        raise NotImplementedError(self._gather_kinds)
234
234
 
235
 
    @needs_read_lock
236
 
    def has_changes(self, _from_tree=None):
237
 
        """Quickly check that the tree contains at least one commitable change.
238
 
 
239
 
        :param _from_tree: tree to compare against to find changes (default to
240
 
            the basis tree and is intended to be used by tests).
241
 
 
242
 
        :return: True if a change is found. False otherwise
243
 
        """
244
 
        # Check pending merges
245
 
        if len(self.get_parent_ids()) > 1:
246
 
            return True
247
 
        if _from_tree is None:
248
 
            _from_tree = self.basis_tree()
249
 
        changes = self.iter_changes(_from_tree)
250
 
        try:
251
 
            change = changes.next()
252
 
            # Exclude root (talk about black magic... --vila 20090629)
253
 
            if change[4] == (None, None):
254
 
                change = changes.next()
255
 
            return True
256
 
        except StopIteration:
257
 
            # No changes
258
 
            return False
259
 
 
260
 
    @needs_read_lock
261
 
    def check_changed_or_out_of_date(self, strict, opt_name,
262
 
                                     more_error, more_warning):
263
 
        """Check the tree for uncommitted changes and branch synchronization.
264
 
 
265
 
        If strict is None and not set in the config files, a warning is issued.
266
 
        If strict is True, an error is raised.
267
 
        If strict is False, no checks are done and no warning is issued.
268
 
 
269
 
        :param strict: True, False or None, searched in branch config if None.
270
 
 
271
 
        :param opt_name: strict option name to search in config file.
272
 
 
273
 
        :param more_error: Details about how to avoid the check.
274
 
 
275
 
        :param more_warning: Details about what is happening.
276
 
        """
277
 
        if strict is None:
278
 
            strict = self.branch.get_config().get_user_option_as_bool(opt_name)
279
 
        if strict is not False:
280
 
            err_class = None
281
 
            if (self.has_changes()):
282
 
                err_class = errors.UncommittedChanges
283
 
            elif self.last_revision() != self.branch.last_revision():
284
 
                # The tree has lost sync with its branch, there is little
285
 
                # chance that the user is aware of it but he can still force
286
 
                # the action with --no-strict
287
 
                err_class = errors.OutOfDateTree
288
 
            if err_class is not None:
289
 
                if strict is None:
290
 
                    err = err_class(self, more=more_warning)
291
 
                    # We don't want to interrupt the user if he expressed no
292
 
                    # preference about strict.
293
 
                    trace.warning('%s', err._format())
294
 
                else:
295
 
                    err = err_class(self, more=more_error)
296
 
                    raise err
 
235
    def get_file_with_stat(self, file_id, path=None):
 
236
        """Get a file handle and stat object for file_id.
 
237
 
 
238
        The default implementation returns (self.get_file, None) for backwards
 
239
        compatibility.
 
240
 
 
241
        :param file_id: The file id to read.
 
242
        :param path: The path of the file, if it is known.
 
243
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
 
244
            no stat facility, or need for a stat cache feedback during commit,
 
245
            it may return None for the second element of the tuple.
 
246
        """
 
247
        return (self.get_file(file_id, path), None)
297
248
 
298
249
    @needs_read_lock
299
250
    def last_revision(self):
418
369
 
419
370
        if not file_list:
420
371
            # no paths supplied: add the entire tree.
421
 
            # FIXME: this assumes we are running in a working tree subdir :-/
422
 
            # -- vila 20100208
423
372
            file_list = [u'.']
424
373
        # mutter("smart add of %r")
425
374
        inv = self.inventory
427
376
        ignored = {}
428
377
        dirs_to_add = []
429
378
        user_dirs = set()
430
 
        conflicts_related = set()
431
 
        # Not all mutable trees can have conflicts
432
 
        if getattr(self, 'conflicts', None) is not None:
433
 
            # Collect all related files without checking whether they exist or
434
 
            # are versioned. It's cheaper to do that once for all conflicts
435
 
            # than trying to find the relevant conflict for each added file.
436
 
            for c in self.conflicts():
437
 
                conflicts_related.update(c.associated_filenames())
438
379
 
439
380
        # validate user file paths and convert all paths to tree
440
381
        # relative : it's cheaper to make a tree relative path an abspath
442
383
        # perform the canonicalization in bulk.
443
384
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
444
385
            rf = _FastPath(filepath)
445
 
            # validate user parameters. Our recursive code avoids adding new
446
 
            # files that need such validation
 
386
            # validate user parameters. Our recursive code avoids adding new files
 
387
            # that need such validation
447
388
            if self.is_control_filename(rf.raw_path):
448
389
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
449
390
 
455
396
            else:
456
397
                if not InventoryEntry.versionable_kind(kind):
457
398
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
458
 
            # ensure the named path is added, so that ignore rules in the later
459
 
            # directory walk dont skip it.
460
 
            # we dont have a parent ie known yet.: use the relatively slower
461
 
            # inventory probing method
 
399
            # ensure the named path is added, so that ignore rules in the later directory
 
400
            # walk dont skip it.
 
401
            # we dont have a parent ie known yet.: use the relatively slower inventory
 
402
            # probing method
462
403
            versioned = inv.has_filename(rf.raw_path)
463
404
            if versioned:
464
405
                continue
480
421
                dirs_to_add.append((path, None))
481
422
            prev_dir = path.raw_path
482
423
 
483
 
        illegalpath_re = re.compile(r'[\r\n]')
484
424
        # dirs_to_add is initialised to a list of directories, but as we scan
485
425
        # directories we append files to it.
486
426
        # XXX: We should determine kind of files when we scan them rather than
495
435
            kind = osutils.file_kind(abspath)
496
436
 
497
437
            if not InventoryEntry.versionable_kind(kind):
498
 
                trace.warning("skipping %s (can't add file of kind '%s')",
499
 
                              abspath, kind)
500
 
                continue
501
 
            if illegalpath_re.search(directory.raw_path):
502
 
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
503
 
                continue
504
 
            if directory.raw_path in conflicts_related:
505
 
                # If the file looks like one generated for a conflict, don't
506
 
                # add it.
507
 
                trace.warning(
508
 
                    'skipping %s (generated to help resolve conflicts)',
509
 
                    abspath)
 
438
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
510
439
                continue
511
440
 
512
441
            if parent_ie is not None:
535
464
                pass
536
465
                # mutter("%r is already versioned", abspath)
537
466
            elif sub_tree:
538
 
                # XXX: This is wrong; people *might* reasonably be trying to
539
 
                # add subtrees as subtrees.  This should probably only be done
540
 
                # in formats which can represent subtrees, and even then
541
 
                # perhaps only when the user asked to add subtrees.  At the
542
 
                # moment you can add them specially through 'join --reference',
543
 
                # which is perhaps reasonable: adding a new reference is a
544
 
                # special operation and can have a special behaviour.  mbp
545
 
                # 20070306
546
 
                trace.mutter("%r is a nested bzr tree", abspath)
 
467
                # XXX: This is wrong; people *might* reasonably be trying to add
 
468
                # subtrees as subtrees.  This should probably only be done in formats
 
469
                # which can represent subtrees, and even then perhaps only when
 
470
                # the user asked to add subtrees.  At the moment you can add them
 
471
                # specially through 'join --reference', which is perhaps
 
472
                # reasonable: adding a new reference is a special operation and
 
473
                # can have a special behaviour.  mbp 20070306
 
474
                mutter("%r is a nested bzr tree", abspath)
547
475
            else:
548
476
                _add_one(self, inv, parent_ie, directory, kind, action)
549
477
                added.append(directory.raw_path)
556
484
                    # without the parent ie, use the relatively slower inventory
557
485
                    # probing method
558
486
                    this_id = inv.path2id(
559
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
487
                            self._fix_case_of_inventory_path(directory.raw_path))
560
488
                    if this_id is None:
561
489
                        this_ie = None
562
490
                    else:
571
499
                    # faster - its impossible for a non root dir to have a
572
500
                    # control file.
573
501
                    if self.is_control_filename(subp):
574
 
                        trace.mutter("skip control directory %r", subp)
 
502
                        mutter("skip control directory %r", subp)
575
503
                    elif subf in this_ie.children:
576
504
                        # recurse into this already versioned subdir.
577
505
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
609
537
        for commit which is not required to handle situations that do not arise
610
538
        outside of commit.
611
539
 
612
 
        See the inventory developers documentation for the theory behind
613
 
        inventory deltas.
614
 
 
615
540
        :param new_revid: The new revision id for the trees parent.
616
541
        :param delta: An inventory delta (see apply_inventory_delta) describing
617
542
            the changes from the current left most parent revision to new_revid.
633
558
        inventory = basis.inventory._get_mutable_inventory()
634
559
        basis.unlock()
635
560
        inventory.apply_delta(delta)
636
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
637
 
                                             inventory, new_revid)
 
561
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
638
562
        self.set_parent_trees([(new_revid, rev_tree)])
639
563
 
640
564
 
651
575
        self.create_hook(hooks.HookPoint('start_commit',
652
576
            "Called before a commit is performed on a tree. The start commit "
653
577
            "hook is able to change the tree before the commit takes place. "
654
 
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
655
 
            "that the commit is being performed on.", (1, 4), None))
656
 
        self.create_hook(hooks.HookPoint('post_commit',
657
 
            "Called after a commit is performed on a tree. The hook is "
658
 
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
659
 
            "The mutable tree the commit was performed on is available via "
660
 
            "the mutable_tree attribute of that object.", (2, 0), None))
 
578
            "start_commit is called with the bzrlib.tree.MutableTree that the "
 
579
            "commit is being performed on.", (1, 4), None))
661
580
 
662
581
 
663
582
# install the default hooks into the MutableTree class.
664
583
MutableTree.hooks = MutableTreeHooks()
665
584
 
666
585
 
667
 
class PostCommitHookParams(object):
668
 
    """Parameters for the post_commit hook.
669
 
 
670
 
    To access the parameters, use the following attributes:
671
 
 
672
 
    * mutable_tree - the MutableTree object
673
 
    """
674
 
 
675
 
    def __init__(self, mutable_tree):
676
 
        """Create the parameters for the post_commit hook."""
677
 
        self.mutable_tree = mutable_tree
678
 
 
679
 
 
680
586
class _FastPath(object):
681
587
    """A path object with fast accessors for things like basename."""
682
588
 
723
629
        # there are a limited number of dirs we can be nested under, it should
724
630
        # generally find it very fast and not recurse after that.
725
631
        added = _add_one_and_parent(tree, inv, None,
726
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
727
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
632
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
633
        parent_id = inv.path2id(dirname(path.raw_path))
728
634
        parent_ie = inv[parent_id]
729
635
    _add_one(tree, inv, parent_ie, path, kind, action)
730
636
    return added + [path.raw_path]