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

  • Committer: John Arbash Meinel
  • Date: 2011-04-20 09:46:28 UTC
  • mfrom: (5609.33.4 2.3)
  • mto: (5609.33.5 2.3)
  • mto: This revision was merged to the branch mainline in revision 5811.
  • Revision ID: john@arbash-meinel.com-20110420094628-l0bafq1lwb6ib1v2
Merge lp:bzr/2.3 @ 5640 so we can update the release notes (aka NEWS)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
19
19
from stat import S_ISREG, S_IEXEC
20
20
import time
21
21
 
22
 
from bzrlib.lazy_import import lazy_import
23
 
lazy_import(globals(), """
 
22
import bzrlib
 
23
from bzrlib import (
 
24
    errors,
 
25
    lazy_import,
 
26
    registry,
 
27
    tree,
 
28
    )
 
29
lazy_import.lazy_import(globals(), """
24
30
from bzrlib import (
25
31
    annotate,
26
32
    bencode,
27
33
    bzrdir,
 
34
    commit,
28
35
    delta,
29
36
    errors,
30
37
    inventory,
31
38
    multiparent,
32
39
    osutils,
33
40
    revision as _mod_revision,
 
41
    trace,
 
42
    ui,
 
43
    urlutils,
34
44
    )
35
45
""")
36
46
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
37
 
                           ReusingTransform, NotVersionedError, CantMoveRoot,
 
47
                           ReusingTransform, CantMoveRoot,
38
48
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
39
49
                           UnableCreateSymlink)
40
50
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
43
53
    delete_any,
44
54
    file_kind,
45
55
    has_symlinks,
46
 
    lexists,
47
56
    pathjoin,
48
57
    sha_file,
49
58
    splitpath,
50
59
    supports_executable,
51
 
)
52
 
from bzrlib.progress import DummyProgress, ProgressPhase
 
60
    )
 
61
from bzrlib.progress import ProgressPhase
53
62
from bzrlib.symbol_versioning import (
54
 
        deprecated_function,
55
 
        deprecated_in,
56
 
        )
57
 
from bzrlib.trace import mutter, warning
58
 
from bzrlib import tree
59
 
import bzrlib.ui
60
 
import bzrlib.urlutils as urlutils
 
63
    deprecated_function,
 
64
    deprecated_in,
 
65
    deprecated_method,
 
66
    )
 
67
from bzrlib.trace import warning
61
68
 
62
69
 
63
70
ROOT_PARENT = "root-parent"
64
71
 
65
 
 
66
72
def unique_add(map, key, value):
67
73
    if key in map:
68
74
        raise DuplicateKey(key=key)
69
75
    map[key] = value
70
76
 
71
77
 
 
78
 
72
79
class _TransformResults(object):
73
80
    def __init__(self, modified_paths, rename_count):
74
81
        object.__init__(self)
79
86
class TreeTransformBase(object):
80
87
    """The base class for TreeTransform and its kin."""
81
88
 
82
 
    def __init__(self, tree, pb=DummyProgress(),
 
89
    def __init__(self, tree, pb=None,
83
90
                 case_sensitive=True):
84
91
        """Constructor.
85
92
 
86
93
        :param tree: The tree that will be transformed, but not necessarily
87
94
            the output tree.
88
 
        :param pb: A ProgressTask indicating how much progress is being made
 
95
        :param pb: ignored
89
96
        :param case_sensitive: If True, the target of the transform is
90
97
            case sensitive, not just case preserving.
91
98
        """
122
129
            self._new_root = self.trans_id_tree_file_id(root_id)
123
130
        else:
124
131
            self._new_root = None
125
 
        # Indictor of whether the transform has been applied
 
132
        # Indicator of whether the transform has been applied
126
133
        self._done = False
127
134
        # A progress bar
128
135
        self._pb = pb
313
320
 
314
321
    def delete_contents(self, trans_id):
315
322
        """Schedule the contents of a path entry for deletion"""
316
 
        # Ensure that the object exists in the WorkingTree, this will raise an
317
 
        # exception if there is a problem
318
 
        self.tree_kind(trans_id)
319
 
        self._removed_contents.add(trans_id)
 
323
        kind = self.tree_kind(trans_id)
 
324
        if kind is not None:
 
325
            self._removed_contents.add(trans_id)
320
326
 
321
327
    def cancel_deletion(self, trans_id):
322
328
        """Cancel a scheduled deletion"""
387
393
        changed_kind = set(self._removed_contents)
388
394
        changed_kind.intersection_update(self._new_contents)
389
395
        changed_kind.difference_update(new_ids)
390
 
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
391
 
                        self.final_kind(t))
 
396
        changed_kind = (t for t in changed_kind
 
397
                        if self.tree_kind(t) != self.final_kind(t))
392
398
        new_ids.update(changed_kind)
393
399
        return sorted(FinalPaths(self).get_paths(new_ids))
394
400
 
395
401
    def final_kind(self, trans_id):
396
402
        """Determine the final file kind, after any changes applied.
397
403
 
398
 
        Raises NoSuchFile if the file does not exist/has no contents.
399
 
        (It is conceivable that a path would be created without the
400
 
        corresponding contents insertion command)
 
404
        :return: None if the file does not exist/has no contents.  (It is
 
405
            conceivable that a path would be created without the corresponding
 
406
            contents insertion command)
401
407
        """
402
408
        if trans_id in self._new_contents:
403
409
            return self._new_contents[trans_id]
404
410
        elif trans_id in self._removed_contents:
405
 
            raise NoSuchFile(None)
 
411
            return None
406
412
        else:
407
413
            return self.tree_kind(trans_id)
408
414
 
521
527
        for trans_id in self._removed_id:
522
528
            file_id = self.tree_file_id(trans_id)
523
529
            if file_id is not None:
 
530
                # XXX: This seems like something that should go via a different
 
531
                #      indirection.
524
532
                if self._tree.inventory[file_id].kind == 'directory':
525
533
                    parents.append(trans_id)
526
534
            elif self.tree_kind(trans_id) == 'directory':
530
538
            # ensure that all children are registered with the transaction
531
539
            list(self.iter_tree_children(parent_id))
532
540
 
 
541
    @deprecated_method(deprecated_in((2, 3, 0)))
533
542
    def has_named_child(self, by_parent, parent_id, name):
534
 
        try:
535
 
            children = by_parent[parent_id]
536
 
        except KeyError:
537
 
            children = []
538
 
        for child in children:
 
543
        return self._has_named_child(
 
544
            name, parent_id, known_children=by_parent.get(parent_id, []))
 
545
 
 
546
    def _has_named_child(self, name, parent_id, known_children):
 
547
        """Does a parent already have a name child.
 
548
 
 
549
        :param name: The searched for name.
 
550
 
 
551
        :param parent_id: The parent for which the check is made.
 
552
 
 
553
        :param known_children: The already known children. This should have
 
554
            been recently obtained from `self.by_parent.get(parent_id)`
 
555
            (or will be if None is passed).
 
556
        """
 
557
        if known_children is None:
 
558
            known_children = self.by_parent().get(parent_id, [])
 
559
        for child in known_children:
539
560
            if self.final_name(child) == name:
540
561
                return True
541
 
        try:
542
 
            path = self._tree_id_paths[parent_id]
543
 
        except KeyError:
 
562
        parent_path = self._tree_id_paths.get(parent_id, None)
 
563
        if parent_path is None:
 
564
            # No parent... no children
544
565
            return False
545
 
        childpath = joinpath(path, name)
546
 
        child_id = self._tree_path_ids.get(childpath)
 
566
        child_path = joinpath(parent_path, name)
 
567
        child_id = self._tree_path_ids.get(child_path, None)
547
568
        if child_id is None:
548
 
            return lexists(self._tree.abspath(childpath))
 
569
            # Not known by the tree transform yet, check the filesystem
 
570
            return osutils.lexists(self._tree.abspath(child_path))
549
571
        else:
550
 
            if self.final_parent(child_id) != parent_id:
551
 
                return False
552
 
            if child_id in self._removed_contents:
553
 
                # XXX What about dangling file-ids?
554
 
                return False
555
 
            else:
556
 
                return True
 
572
            raise AssertionError('child_id is missing: %s, %s, %s'
 
573
                                 % (name, parent_id, child_id))
 
574
 
 
575
    def _available_backup_name(self, name, target_id):
 
576
        """Find an available backup name.
 
577
 
 
578
        :param name: The basename of the file.
 
579
 
 
580
        :param target_id: The directory trans_id where the backup should 
 
581
            be placed.
 
582
        """
 
583
        known_children = self.by_parent().get(target_id, [])
 
584
        return osutils.available_backup_name(
 
585
            name,
 
586
            lambda base: self._has_named_child(
 
587
                base, target_id, known_children))
557
588
 
558
589
    def _parent_loops(self):
559
590
        """No entry should be its own ancestor"""
594
625
        """
595
626
        conflicts = []
596
627
        for trans_id in self._new_id.iterkeys():
597
 
            try:
598
 
                kind = self.final_kind(trans_id)
599
 
            except NoSuchFile:
 
628
            kind = self.final_kind(trans_id)
 
629
            if kind is None:
600
630
                conflicts.append(('versioning no contents', trans_id))
601
631
                continue
602
632
            if not InventoryEntry.versionable_kind(kind):
616
646
            if self.final_file_id(trans_id) is None:
617
647
                conflicts.append(('unversioned executability', trans_id))
618
648
            else:
619
 
                try:
620
 
                    non_file = self.final_kind(trans_id) != "file"
621
 
                except NoSuchFile:
622
 
                    non_file = True
623
 
                if non_file is True:
 
649
                if self.final_kind(trans_id) != "file":
624
650
                    conflicts.append(('non-file executability', trans_id))
625
651
        return conflicts
626
652
 
628
654
        """Check for overwrites (not permitted on Win32)"""
629
655
        conflicts = []
630
656
        for trans_id in self._new_contents:
631
 
            try:
632
 
                self.tree_kind(trans_id)
633
 
            except NoSuchFile:
 
657
            if self.tree_kind(trans_id) is None:
634
658
                continue
635
659
            if trans_id not in self._removed_contents:
636
660
                conflicts.append(('overwrite', trans_id,
643
667
        if (self._new_name, self._new_parent) == ({}, {}):
644
668
            return conflicts
645
669
        for children in by_parent.itervalues():
646
 
            name_ids = [(self.final_name(t), t) for t in children]
647
 
            if not self._case_sensitive_target:
648
 
                name_ids = [(n.lower(), t) for n, t in name_ids]
 
670
            name_ids = []
 
671
            for child_tid in children:
 
672
                name = self.final_name(child_tid)
 
673
                if name is not None:
 
674
                    # Keep children only if they still exist in the end
 
675
                    if not self._case_sensitive_target:
 
676
                        name = name.lower()
 
677
                    name_ids.append((name, child_tid))
649
678
            name_ids.sort()
650
679
            last_name = None
651
680
            last_trans_id = None
652
681
            for name, trans_id in name_ids:
653
 
                try:
654
 
                    kind = self.final_kind(trans_id)
655
 
                except NoSuchFile:
656
 
                    kind = None
 
682
                kind = self.final_kind(trans_id)
657
683
                file_id = self.final_file_id(trans_id)
658
684
                if kind is None and file_id is None:
659
685
                    continue
678
704
        return conflicts
679
705
 
680
706
    def _parent_type_conflicts(self, by_parent):
681
 
        """parents must have directory 'contents'."""
 
707
        """Children must have a directory parent"""
682
708
        conflicts = []
683
709
        for parent_id, children in by_parent.iteritems():
684
710
            if parent_id is ROOT_PARENT:
685
711
                continue
686
 
            if not self._any_contents(children):
 
712
            no_children = True
 
713
            for child_id in children:
 
714
                if self.final_kind(child_id) is not None:
 
715
                    no_children = False
 
716
                    break
 
717
            if no_children:
687
718
                continue
688
 
            for child in children:
689
 
                try:
690
 
                    self.final_kind(child)
691
 
                except NoSuchFile:
692
 
                    continue
693
 
            try:
694
 
                kind = self.final_kind(parent_id)
695
 
            except NoSuchFile:
696
 
                kind = None
 
719
            # There is at least a child, so we need an existing directory to
 
720
            # contain it.
 
721
            kind = self.final_kind(parent_id)
697
722
            if kind is None:
 
723
                # The directory will be deleted
698
724
                conflicts.append(('missing parent', parent_id))
699
725
            elif kind != "directory":
 
726
                # Meh, we need a *directory* to put something in it
700
727
                conflicts.append(('non-directory parent', parent_id))
701
728
        return conflicts
702
729
 
703
 
    def _any_contents(self, trans_ids):
704
 
        """Return true if any of the trans_ids, will have contents."""
705
 
        for trans_id in trans_ids:
706
 
            try:
707
 
                kind = self.final_kind(trans_id)
708
 
            except NoSuchFile:
709
 
                continue
710
 
            return True
711
 
        return False
712
 
 
713
730
    def _set_executability(self, path, trans_id):
714
731
        """Set the executability of versioned files """
715
732
        if supports_executable():
779
796
        self.create_symlink(target, trans_id)
780
797
        return trans_id
781
798
 
 
799
    def new_orphan(self, trans_id, parent_id):
 
800
        """Schedule an item to be orphaned.
 
801
 
 
802
        When a directory is about to be removed, its children, if they are not
 
803
        versioned are moved out of the way: they don't have a parent anymore.
 
804
 
 
805
        :param trans_id: The trans_id of the existing item.
 
806
        :param parent_id: The parent trans_id of the item.
 
807
        """
 
808
        raise NotImplementedError(self.new_orphan)
 
809
 
 
810
    def _get_potential_orphans(self, dir_id):
 
811
        """Find the potential orphans in a directory.
 
812
 
 
813
        A directory can't be safely deleted if there are versioned files in it.
 
814
        If all the contained files are unversioned then they can be orphaned.
 
815
 
 
816
        The 'None' return value means that the directory contains at least one
 
817
        versioned file and should not be deleted.
 
818
 
 
819
        :param dir_id: The directory trans id.
 
820
 
 
821
        :return: A list of the orphan trans ids or None if at least one
 
822
             versioned file is present.
 
823
        """
 
824
        orphans = []
 
825
        # Find the potential orphans, stop if one item should be kept
 
826
        for child_tid in self.by_parent()[dir_id]:
 
827
            if child_tid in self._removed_contents:
 
828
                # The child is removed as part of the transform. Since it was
 
829
                # versioned before, it's not an orphan
 
830
                continue
 
831
            elif self.final_file_id(child_tid) is None:
 
832
                # The child is not versioned
 
833
                orphans.append(child_tid)
 
834
            else:
 
835
                # We have a versioned file here, searching for orphans is
 
836
                # meaningless.
 
837
                orphans = None
 
838
                break
 
839
        return orphans
 
840
 
782
841
    def _affected_ids(self):
783
842
        """Return the set of transform ids affected by the transform"""
784
843
        trans_ids = set(self._removed_id)
843
902
        Return a (name, parent, kind, executable) tuple
844
903
        """
845
904
        to_name = self.final_name(to_trans_id)
846
 
        try:
847
 
            to_kind = self.final_kind(to_trans_id)
848
 
        except NoSuchFile:
849
 
            to_kind = None
 
905
        to_kind = self.final_kind(to_trans_id)
850
906
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
851
907
        if to_trans_id in self._new_executability:
852
908
            to_executable = self._new_executability[to_trans_id]
926
982
        """
927
983
        return _PreviewTree(self)
928
984
 
929
 
    def commit(self, branch, message, merge_parents=None, strict=False):
 
985
    def commit(self, branch, message, merge_parents=None, strict=False,
 
986
               timestamp=None, timezone=None, committer=None, authors=None,
 
987
               revprops=None, revision_id=None):
930
988
        """Commit the result of this TreeTransform to a branch.
931
989
 
932
990
        :param branch: The branch to commit to.
933
991
        :param message: The message to attach to the commit.
934
 
        :param merge_parents: Additional parents specified by pending merges.
 
992
        :param merge_parents: Additional parent revision-ids specified by
 
993
            pending merges.
 
994
        :param strict: If True, abort the commit if there are unversioned
 
995
            files.
 
996
        :param timestamp: if not None, seconds-since-epoch for the time and
 
997
            date.  (May be a float.)
 
998
        :param timezone: Optional timezone for timestamp, as an offset in
 
999
            seconds.
 
1000
        :param committer: Optional committer in email-id format.
 
1001
            (e.g. "J Random Hacker <jrandom@example.com>")
 
1002
        :param authors: Optional list of authors in email-id format.
 
1003
        :param revprops: Optional dictionary of revision properties.
 
1004
        :param revision_id: Optional revision id.  (Specifying a revision-id
 
1005
            may reduce performance for some non-native formats.)
935
1006
        :return: The revision_id of the revision committed.
936
1007
        """
937
1008
        self._check_malformed()
954
1025
        if self._tree.get_revision_id() != last_rev_id:
955
1026
            raise ValueError('TreeTransform not based on branch basis: %s' %
956
1027
                             self._tree.get_revision_id())
957
 
        builder = branch.get_commit_builder(parent_ids)
 
1028
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1029
        builder = branch.get_commit_builder(parent_ids,
 
1030
                                            timestamp=timestamp,
 
1031
                                            timezone=timezone,
 
1032
                                            committer=committer,
 
1033
                                            revprops=revprops,
 
1034
                                            revision_id=revision_id)
958
1035
        preview = self.get_preview_tree()
959
1036
        list(builder.record_iter_changes(preview, last_rev_id,
960
1037
                                         self.iter_changes()))
1062
1139
class DiskTreeTransform(TreeTransformBase):
1063
1140
    """Tree transform storing its contents on disk."""
1064
1141
 
1065
 
    def __init__(self, tree, limbodir, pb=DummyProgress(),
 
1142
    def __init__(self, tree, limbodir, pb=None,
1066
1143
                 case_sensitive=True):
1067
1144
        """Constructor.
1068
1145
        :param tree: The tree that will be transformed, but not necessarily
1069
1146
            the output tree.
1070
1147
        :param limbodir: A directory where new files can be stored until
1071
1148
            they are installed in their proper places
1072
 
        :param pb: A ProgressBar indicating how much progress is being made
 
1149
        :param pb: ignored
1073
1150
        :param case_sensitive: If True, the target of the transform is
1074
1151
            case sensitive, not just case preserving.
1075
1152
        """
1273
1350
            del self._limbo_children_names[trans_id]
1274
1351
        delete_any(self._limbo_name(trans_id))
1275
1352
 
 
1353
    def new_orphan(self, trans_id, parent_id):
 
1354
        # FIXME: There is no tree config, so we use the branch one (it's weird
 
1355
        # to define it this way as orphaning can only occur in a working tree,
 
1356
        # but that's all we have (for now). It will find the option in
 
1357
        # locations.conf or bazaar.conf though) -- vila 20100916
 
1358
        conf = self._tree.branch.get_config()
 
1359
        conf_var_name = 'bzr.transform.orphan_policy'
 
1360
        orphan_policy = conf.get_user_option(conf_var_name)
 
1361
        default_policy = orphaning_registry.default_key
 
1362
        if orphan_policy is None:
 
1363
            orphan_policy = default_policy
 
1364
        if orphan_policy not in orphaning_registry:
 
1365
            trace.warning('%s (from %s) is not a known policy, defaulting to %s'
 
1366
                          % (orphan_policy, conf_var_name, default_policy))
 
1367
            orphan_policy = default_policy
 
1368
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1369
        handle_orphan(self, trans_id, parent_id)
 
1370
 
 
1371
 
 
1372
class OrphaningError(errors.BzrError):
 
1373
 
 
1374
    # Only bugs could lead to such exception being seen by the user
 
1375
    internal_error = True
 
1376
    _fmt = "Error while orphaning %s in %s directory"
 
1377
 
 
1378
    def __init__(self, orphan, parent):
 
1379
        errors.BzrError.__init__(self)
 
1380
        self.orphan = orphan
 
1381
        self.parent = parent
 
1382
 
 
1383
 
 
1384
class OrphaningForbidden(OrphaningError):
 
1385
 
 
1386
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1387
 
 
1388
    def __init__(self, policy):
 
1389
        errors.BzrError.__init__(self)
 
1390
        self.policy = policy
 
1391
 
 
1392
 
 
1393
def move_orphan(tt, orphan_id, parent_id):
 
1394
    """See TreeTransformBase.new_orphan.
 
1395
 
 
1396
    This creates a new orphan in the `bzr-orphans` dir at the root of the
 
1397
    `TreeTransform`.
 
1398
 
 
1399
    :param tt: The TreeTransform orphaning `trans_id`.
 
1400
 
 
1401
    :param orphan_id: The trans id that should be orphaned.
 
1402
 
 
1403
    :param parent_id: The orphan parent trans id.
 
1404
    """
 
1405
    # Add the orphan dir if it doesn't exist
 
1406
    orphan_dir_basename = 'bzr-orphans'
 
1407
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1408
    if tt.final_kind(od_id) is None:
 
1409
        tt.create_directory(od_id)
 
1410
    parent_path = tt._tree_id_paths[parent_id]
 
1411
    # Find a name that doesn't exist yet in the orphan dir
 
1412
    actual_name = tt.final_name(orphan_id)
 
1413
    new_name = tt._available_backup_name(actual_name, od_id)
 
1414
    tt.adjust_path(new_name, od_id, orphan_id)
 
1415
    trace.warning('%s has been orphaned in %s'
 
1416
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1417
 
 
1418
 
 
1419
def refuse_orphan(tt, orphan_id, parent_id):
 
1420
    """See TreeTransformBase.new_orphan.
 
1421
 
 
1422
    This refuses to create orphan, letting the caller handle the conflict.
 
1423
    """
 
1424
    raise OrphaningForbidden('never')
 
1425
 
 
1426
 
 
1427
orphaning_registry = registry.Registry()
 
1428
orphaning_registry.register(
 
1429
    'conflict', refuse_orphan,
 
1430
    'Leave orphans in place and create a conflict on the directory.')
 
1431
orphaning_registry.register(
 
1432
    'move', move_orphan,
 
1433
    'Move orphans into the bzr-orphans directory.')
 
1434
orphaning_registry._set_default_key('conflict')
 
1435
 
1276
1436
 
1277
1437
class TreeTransform(DiskTreeTransform):
1278
1438
    """Represent a tree transformation.
1339
1499
    FileMover does not delete files until it is sure that a rollback will not
1340
1500
    happen.
1341
1501
    """
1342
 
    def __init__(self, tree, pb=DummyProgress()):
 
1502
    def __init__(self, tree, pb=None):
1343
1503
        """Note: a tree_write lock is taken on the tree.
1344
1504
 
1345
1505
        Use TreeTransform.finalize() to release the lock (can be omitted if
1396
1556
    def tree_kind(self, trans_id):
1397
1557
        """Determine the file kind in the working tree.
1398
1558
 
1399
 
        Raises NoSuchFile if the file does not exist
 
1559
        :returns: The file kind or None if the file does not exist
1400
1560
        """
1401
1561
        path = self._tree_id_paths.get(trans_id)
1402
1562
        if path is None:
1403
 
            raise NoSuchFile(None)
 
1563
            return None
1404
1564
        try:
1405
1565
            return file_kind(self._tree.abspath(path))
1406
 
        except OSError, e:
1407
 
            if e.errno != errno.ENOENT:
1408
 
                raise
1409
 
            else:
1410
 
                raise NoSuchFile(path)
 
1566
        except errors.NoSuchFile:
 
1567
            return None
1411
1568
 
1412
1569
    def _set_mode(self, trans_id, mode_id, typefunc):
1413
1570
        """Set the mode of new file contents.
1519
1676
        """
1520
1677
        if not no_conflicts:
1521
1678
            self._check_malformed()
1522
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1679
        child_pb = ui.ui_factory.nested_progress_bar()
1523
1680
        try:
1524
1681
            if precomputed_delta is None:
1525
1682
                child_pb.update('Apply phase', 0, 2)
1552
1709
    def _generate_inventory_delta(self):
1553
1710
        """Generate an inventory delta for the current transform."""
1554
1711
        inventory_delta = []
1555
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1712
        child_pb = ui.ui_factory.nested_progress_bar()
1556
1713
        new_paths = self._inventory_altered()
1557
1714
        total_entries = len(new_paths) + len(self._removed_id)
1558
1715
        try:
1582
1739
                if file_id is None:
1583
1740
                    continue
1584
1741
                needs_entry = False
1585
 
                try:
1586
 
                    kind = self.final_kind(trans_id)
1587
 
                except NoSuchFile:
 
1742
                kind = self.final_kind(trans_id)
 
1743
                if kind is None:
1588
1744
                    kind = self._tree.stored_kind(file_id)
1589
1745
                parent_trans_id = self.final_parent(trans_id)
1590
1746
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1621
1777
        """
1622
1778
        tree_paths = list(self._tree_path_ids.iteritems())
1623
1779
        tree_paths.sort(reverse=True)
1624
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1780
        child_pb = ui.ui_factory.nested_progress_bar()
1625
1781
        try:
1626
1782
            for num, data in enumerate(tree_paths):
1627
1783
                path, trans_id = data
1634
1790
                      or trans_id in self._new_parent):
1635
1791
                    try:
1636
1792
                        mover.rename(full_path, self._limbo_name(trans_id))
1637
 
                    except OSError, e:
 
1793
                    except errors.TransformRenameFailed, e:
1638
1794
                        if e.errno != errno.ENOENT:
1639
1795
                            raise
1640
1796
                    else:
1656
1812
        modified_paths = []
1657
1813
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1658
1814
                                 new_paths)
1659
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1815
        child_pb = ui.ui_factory.nested_progress_bar()
1660
1816
        try:
1661
1817
            for num, (path, trans_id) in enumerate(new_paths):
1662
1818
                if (num % 10) == 0:
1665
1821
                if trans_id in self._needs_rename:
1666
1822
                    try:
1667
1823
                        mover.rename(self._limbo_name(trans_id), full_path)
1668
 
                    except OSError, e:
 
1824
                    except errors.TransformRenameFailed, e:
1669
1825
                        # We may be renaming a dangling inventory id
1670
1826
                        if e.errno != errno.ENOENT:
1671
1827
                            raise
1691
1847
    unversioned files in the input tree.
1692
1848
    """
1693
1849
 
1694
 
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
 
1850
    def __init__(self, tree, pb=None, case_sensitive=True):
1695
1851
        tree.lock_read()
1696
1852
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
1697
1853
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
1702
1858
    def tree_kind(self, trans_id):
1703
1859
        path = self._tree_id_paths.get(trans_id)
1704
1860
        if path is None:
1705
 
            raise NoSuchFile(None)
 
1861
            return None
1706
1862
        file_id = self._tree.path2id(path)
1707
 
        return self._tree.kind(file_id)
 
1863
        try:
 
1864
            return self._tree.kind(file_id)
 
1865
        except errors.NoSuchFile:
 
1866
            return None
1708
1867
 
1709
1868
    def _set_mode(self, trans_id, mode_id, typefunc):
1710
1869
        """Set the mode of new file contents.
1730
1889
            childpath = joinpath(path, child)
1731
1890
            yield self.trans_id_tree_path(childpath)
1732
1891
 
 
1892
    def new_orphan(self, trans_id, parent_id):
 
1893
        raise NotImplementedError(self.new_orphan)
 
1894
 
1733
1895
 
1734
1896
class _PreviewTree(tree.Tree):
1735
1897
    """Partial implementation of Tree to support show_diff_trees"""
1769
1931
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1770
1932
                       self._iter_parent_trees()]
1771
1933
        vf.add_lines((file_id, tree_revision), parent_keys,
1772
 
                     self.get_file(file_id).readlines())
 
1934
                     self.get_file_lines(file_id))
1773
1935
        repo = self._get_repository()
1774
1936
        base_vf = repo.texts
1775
1937
        if base_vf not in vf.fallback_versionedfiles:
1797
1959
            executable = self.is_executable(file_id, path)
1798
1960
        return kind, executable, None
1799
1961
 
 
1962
    def is_locked(self):
 
1963
        return False
 
1964
 
1800
1965
    def lock_read(self):
1801
1966
        # Perhaps in theory, this should lock the TreeTransform?
1802
 
        pass
 
1967
        return self
1803
1968
 
1804
1969
    def unlock(self):
1805
1970
        pass
1903
2068
            if (specific_file_ids is not None
1904
2069
                and file_id not in specific_file_ids):
1905
2070
                continue
1906
 
            try:
1907
 
                kind = self._transform.final_kind(trans_id)
1908
 
            except NoSuchFile:
 
2071
            kind = self._transform.final_kind(trans_id)
 
2072
            if kind is None:
1909
2073
                kind = self._transform._tree.stored_kind(file_id)
1910
2074
            new_entry = inventory.make_entry(
1911
2075
                kind,
2143
2307
                path_from_root = self._final_paths.get_path(child_id)
2144
2308
                basename = self._transform.final_name(child_id)
2145
2309
                file_id = self._transform.final_file_id(child_id)
2146
 
                try:
2147
 
                    kind = self._transform.final_kind(child_id)
 
2310
                kind  = self._transform.final_kind(child_id)
 
2311
                if kind is not None:
2148
2312
                    versioned_kind = kind
2149
 
                except NoSuchFile:
 
2313
                else:
2150
2314
                    kind = 'unknown'
2151
2315
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2152
2316
                if versioned_kind == 'directory':
2265
2429
    for num, _unused in enumerate(wt.all_file_ids()):
2266
2430
        if num > 0:  # more than just a root
2267
2431
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
2268
 
    existing_files = set()
2269
 
    for dir, files in wt.walkdirs():
2270
 
        existing_files.update(f[0] for f in files)
2271
2432
    file_trans_id = {}
2272
 
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2433
    top_pb = ui.ui_factory.nested_progress_bar()
2273
2434
    pp = ProgressPhase("Build phase", 2, top_pb)
2274
2435
    if tree.inventory.root is not None:
2275
2436
        # This is kind of a hack: we should be altering the root
2288
2449
        pp.next_phase()
2289
2450
        file_trans_id[wt.get_root_id()] = \
2290
2451
            tt.trans_id_tree_file_id(wt.get_root_id())
2291
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2452
        pb = ui.ui_factory.nested_progress_bar()
2292
2453
        try:
2293
2454
            deferred_contents = []
2294
2455
            num = 0
2297
2458
                precomputed_delta = []
2298
2459
            else:
2299
2460
                precomputed_delta = None
 
2461
            # Check if tree inventory has content. If so, we populate
 
2462
            # existing_files with the directory content. If there are no
 
2463
            # entries we skip populating existing_files as its not used.
 
2464
            # This improves performance and unncessary work on large
 
2465
            # directory trees. (#501307)
 
2466
            if total > 0:
 
2467
                existing_files = set()
 
2468
                for dir, files in wt.walkdirs():
 
2469
                    existing_files.update(f[0] for f in files)
2300
2470
            for num, (tree_path, entry) in \
2301
2471
                enumerate(tree.inventory.iter_entries_by_dir()):
2302
2472
                pb.update("Building tree", num - len(deferred_contents), total)
2422
2592
    for child in tt.iter_tree_children(old_parent):
2423
2593
        tt.adjust_path(tt.final_name(child), new_parent, child)
2424
2594
 
 
2595
 
2425
2596
def _reparent_transform_children(tt, old_parent, new_parent):
2426
2597
    by_parent = tt.by_parent()
2427
2598
    for child in by_parent[old_parent]:
2428
2599
        tt.adjust_path(tt.final_name(child), new_parent, child)
2429
2600
    return by_parent[old_parent]
2430
2601
 
 
2602
 
2431
2603
def _content_match(tree, entry, file_id, kind, target_path):
2432
2604
    if entry.kind != kind:
2433
2605
        return False
2434
2606
    if entry.kind == "directory":
2435
2607
        return True
2436
2608
    if entry.kind == "file":
2437
 
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
2438
 
            return True
 
2609
        f = file(target_path, 'rb')
 
2610
        try:
 
2611
            if tree.get_file_text(file_id) == f.read():
 
2612
                return True
 
2613
        finally:
 
2614
            f.close()
2439
2615
    elif entry.kind == "symlink":
2440
2616
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2441
2617
            return True
2493
2669
        raise errors.BadFileKindError(name, kind)
2494
2670
 
2495
2671
 
2496
 
@deprecated_function(deprecated_in((1, 9, 0)))
2497
 
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
2498
 
    """Create new file contents according to an inventory entry.
2499
 
 
2500
 
    DEPRECATED.  Use create_from_tree instead.
2501
 
    """
2502
 
    if entry.kind == "file":
2503
 
        if lines is None:
2504
 
            lines = tree.get_file(entry.file_id).readlines()
2505
 
        tt.create_file(lines, trans_id, mode_id=mode_id)
2506
 
    elif entry.kind == "symlink":
2507
 
        tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
2508
 
    elif entry.kind == "directory":
2509
 
        tt.create_directory(trans_id)
2510
 
 
2511
 
 
2512
2672
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2513
2673
    filter_tree_path=None):
2514
2674
    """Create new file contents according to tree contents.
2545
2705
        tt.set_executability(entry.executable, trans_id)
2546
2706
 
2547
2707
 
 
2708
@deprecated_function(deprecated_in((2, 3, 0)))
2548
2709
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2549
2710
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2550
2711
 
2551
2712
 
 
2713
@deprecated_function(deprecated_in((2, 3, 0)))
2552
2714
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2553
2715
    """Produce a backup-style name that appears to be available"""
2554
2716
    def name_gen():
2589
2751
 
2590
2752
 
2591
2753
def revert(working_tree, target_tree, filenames, backups=False,
2592
 
           pb=DummyProgress(), change_reporter=None):
 
2754
           pb=None, change_reporter=None):
2593
2755
    """Revert a working tree's contents to those of a target tree."""
2594
2756
    target_tree.lock_read()
 
2757
    pb = ui.ui_factory.nested_progress_bar()
2595
2758
    tt = TreeTransform(working_tree, pb)
2596
2759
    try:
2597
2760
        pp = ProgressPhase("Revert phase", 3, pb)
2616
2779
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2617
2780
                              backups, pp, basis_tree=None,
2618
2781
                              merge_modified=None):
2619
 
    pp.next_phase()
2620
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2782
    child_pb = ui.ui_factory.nested_progress_bar()
2621
2783
    try:
2622
2784
        if merge_modified is None:
2623
2785
            merge_modified = working_tree.merge_modified()
2626
2788
                                      merge_modified, basis_tree)
2627
2789
    finally:
2628
2790
        child_pb.finished()
2629
 
    pp.next_phase()
2630
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2791
    child_pb = ui.ui_factory.nested_progress_bar()
2631
2792
    try:
2632
2793
        raw_conflicts = resolve_conflicts(tt, child_pb,
2633
2794
            lambda t, c: conflict_pass(t, c, target_tree))
2676
2837
                        tt.delete_contents(trans_id)
2677
2838
                    elif kind[1] is not None:
2678
2839
                        parent_trans_id = tt.trans_id_file_id(parent[0])
2679
 
                        by_parent = tt.by_parent()
2680
 
                        backup_name = _get_backup_name(name[0], by_parent,
2681
 
                                                       parent_trans_id, tt)
 
2840
                        backup_name = tt._available_backup_name(
 
2841
                            name[0], parent_trans_id)
2682
2842
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2683
2843
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2684
2844
                        if versioned == (True, True):
2754
2914
    return merge_modified
2755
2915
 
2756
2916
 
2757
 
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
 
2917
def resolve_conflicts(tt, pb=None, pass_func=None):
2758
2918
    """Make many conflict-resolution attempts, but die if they fail"""
2759
2919
    if pass_func is None:
2760
2920
        pass_func = conflict_pass
2761
2921
    new_conflicts = set()
 
2922
    pb = ui.ui_factory.nested_progress_bar()
2762
2923
    try:
2763
2924
        for n in range(10):
2764
2925
            pb.update('Resolution pass', n+1, 10)
2768
2929
            new_conflicts.update(pass_func(tt, conflicts))
2769
2930
        raise MalformedTransform(conflicts=conflicts)
2770
2931
    finally:
2771
 
        pb.clear()
 
2932
        pb.finished()
2772
2933
 
2773
2934
 
2774
2935
def conflict_pass(tt, conflicts, path_tree=None):
2806
2967
 
2807
2968
        elif c_type == 'missing parent':
2808
2969
            trans_id = conflict[1]
2809
 
            try:
2810
 
                tt.cancel_deletion(trans_id)
2811
 
                new_conflicts.add(('deleting parent', 'Not deleting',
2812
 
                                   trans_id))
2813
 
            except KeyError:
 
2970
            if trans_id in tt._removed_contents:
 
2971
                cancel_deletion = True
 
2972
                orphans = tt._get_potential_orphans(trans_id)
 
2973
                if orphans:
 
2974
                    cancel_deletion = False
 
2975
                    # All children are orphans
 
2976
                    for o in orphans:
 
2977
                        try:
 
2978
                            tt.new_orphan(o, trans_id)
 
2979
                        except OrphaningError:
 
2980
                            # Something bad happened so we cancel the directory
 
2981
                            # deletion which will leave it in place with a
 
2982
                            # conflict. The user can deal with it from there.
 
2983
                            # Note that this also catch the case where we don't
 
2984
                            # want to create orphans and leave the directory in
 
2985
                            # place.
 
2986
                            cancel_deletion = True
 
2987
                            break
 
2988
                if cancel_deletion:
 
2989
                    # Cancel the directory deletion
 
2990
                    tt.cancel_deletion(trans_id)
 
2991
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
2992
                                       trans_id))
 
2993
            else:
2814
2994
                create = True
2815
2995
                try:
2816
2996
                    tt.final_name(trans_id)
2823
3003
                        # special-case the other tree root (move its
2824
3004
                        # children to current root)
2825
3005
                        if entry.parent_id is None:
2826
 
                            create=False
 
3006
                            create = False
2827
3007
                            moved = _reparent_transform_children(
2828
3008
                                tt, trans_id, tt.root)
2829
3009
                            for child in moved:
2841
3021
            file_id = tt.inactive_file_id(conflict[1])
2842
3022
            # special-case the other tree root (move its children instead)
2843
3023
            if path_tree and file_id in path_tree:
2844
 
                if path_tree.inventory[file_id].parent_id is None:
 
3024
                if path_tree.path2id('') == file_id:
 
3025
                    # This is the root entry, skip it
2845
3026
                    continue
2846
3027
            tt.version_file(file_id, conflict[1])
2847
3028
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2897
3078
        self.pending_deletions = []
2898
3079
 
2899
3080
    def rename(self, from_, to):
2900
 
        """Rename a file from one path to another.  Functions like os.rename"""
 
3081
        """Rename a file from one path to another."""
2901
3082
        try:
2902
3083
            os.rename(from_, to)
2903
3084
        except OSError, e:
2904
3085
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2905
3086
                raise errors.FileExists(to, str(e))
2906
 
            raise
 
3087
            # normal OSError doesn't include filenames so it's hard to see where
 
3088
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
 
3089
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
2907
3090
        self.past_renames.append((from_, to))
2908
3091
 
2909
3092
    def pre_delete(self, from_, to):
2919
3102
    def rollback(self):
2920
3103
        """Reverse all renames that have been performed"""
2921
3104
        for from_, to in reversed(self.past_renames):
2922
 
            os.rename(to, from_)
 
3105
            try:
 
3106
                os.rename(to, from_)
 
3107
            except OSError, e:
 
3108
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2923
3109
        # after rollback, don't reuse _FileMover
2924
3110
        past_renames = None
2925
3111
        pending_deletions = None