/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

merge bzr.dev.

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,
32
38
    multiparent,
33
39
    osutils,
34
40
    revision as _mod_revision,
 
41
    trace,
35
42
    ui,
 
43
    urlutils,
36
44
    )
37
45
""")
38
46
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
45
53
    delete_any,
46
54
    file_kind,
47
55
    has_symlinks,
48
 
    lexists,
49
56
    pathjoin,
50
57
    sha_file,
51
58
    splitpath,
52
59
    supports_executable,
53
 
)
 
60
    )
54
61
from bzrlib.progress import ProgressPhase
55
62
from bzrlib.symbol_versioning import (
56
 
        deprecated_function,
57
 
        deprecated_in,
58
 
        )
59
 
from bzrlib.trace import mutter, warning
60
 
from bzrlib import tree
61
 
import bzrlib.ui
62
 
import bzrlib.urlutils as urlutils
 
63
    deprecated_function,
 
64
    deprecated_in,
 
65
    deprecated_method,
 
66
    )
 
67
from bzrlib.trace import warning
63
68
 
64
69
 
65
70
ROOT_PARENT = "root-parent"
66
71
 
67
 
 
68
72
def unique_add(map, key, value):
69
73
    if key in map:
70
74
        raise DuplicateKey(key=key)
71
75
    map[key] = value
72
76
 
73
77
 
 
78
 
74
79
class _TransformResults(object):
75
80
    def __init__(self, modified_paths, rename_count):
76
81
        object.__init__(self)
124
129
            self._new_root = self.trans_id_tree_file_id(root_id)
125
130
        else:
126
131
            self._new_root = None
127
 
        # Indictor of whether the transform has been applied
 
132
        # Indicator of whether the transform has been applied
128
133
        self._done = False
129
134
        # A progress bar
130
135
        self._pb = pb
315
320
 
316
321
    def delete_contents(self, trans_id):
317
322
        """Schedule the contents of a path entry for deletion"""
318
 
        # Ensure that the object exists in the WorkingTree, this will raise an
319
 
        # exception if there is a problem
320
 
        self.tree_kind(trans_id)
321
 
        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)
322
326
 
323
327
    def cancel_deletion(self, trans_id):
324
328
        """Cancel a scheduled deletion"""
389
393
        changed_kind = set(self._removed_contents)
390
394
        changed_kind.intersection_update(self._new_contents)
391
395
        changed_kind.difference_update(new_ids)
392
 
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
393
 
                        self.final_kind(t))
 
396
        changed_kind = (t for t in changed_kind
 
397
                        if self.tree_kind(t) != self.final_kind(t))
394
398
        new_ids.update(changed_kind)
395
399
        return sorted(FinalPaths(self).get_paths(new_ids))
396
400
 
397
401
    def final_kind(self, trans_id):
398
402
        """Determine the final file kind, after any changes applied.
399
403
 
400
 
        Raises NoSuchFile if the file does not exist/has no contents.
401
 
        (It is conceivable that a path would be created without the
402
 
        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)
403
407
        """
404
408
        if trans_id in self._new_contents:
405
409
            return self._new_contents[trans_id]
406
410
        elif trans_id in self._removed_contents:
407
 
            raise NoSuchFile(None)
 
411
            return None
408
412
        else:
409
413
            return self.tree_kind(trans_id)
410
414
 
523
527
        for trans_id in self._removed_id:
524
528
            file_id = self.tree_file_id(trans_id)
525
529
            if file_id is not None:
 
530
                # XXX: This seems like something that should go via a different
 
531
                #      indirection.
526
532
                if self._tree.inventory[file_id].kind == 'directory':
527
533
                    parents.append(trans_id)
528
534
            elif self.tree_kind(trans_id) == 'directory':
532
538
            # ensure that all children are registered with the transaction
533
539
            list(self.iter_tree_children(parent_id))
534
540
 
 
541
    @deprecated_method(deprecated_in((2, 3, 0)))
535
542
    def has_named_child(self, by_parent, parent_id, name):
536
 
        try:
537
 
            children = by_parent[parent_id]
538
 
        except KeyError:
539
 
            children = []
540
 
        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:
541
560
            if self.final_name(child) == name:
542
561
                return True
543
 
        try:
544
 
            path = self._tree_id_paths[parent_id]
545
 
        except KeyError:
 
562
        parent_path = self._tree_id_paths.get(parent_id, None)
 
563
        if parent_path is None:
 
564
            # No parent... no children
546
565
            return False
547
 
        childpath = joinpath(path, name)
548
 
        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)
549
568
        if child_id is None:
550
 
            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))
551
571
        else:
552
 
            if self.final_parent(child_id) != parent_id:
553
 
                return False
554
 
            if child_id in self._removed_contents:
555
 
                # XXX What about dangling file-ids?
556
 
                return False
557
 
            else:
558
 
                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))
559
588
 
560
589
    def _parent_loops(self):
561
590
        """No entry should be its own ancestor"""
596
625
        """
597
626
        conflicts = []
598
627
        for trans_id in self._new_id.iterkeys():
599
 
            try:
600
 
                kind = self.final_kind(trans_id)
601
 
            except NoSuchFile:
 
628
            kind = self.final_kind(trans_id)
 
629
            if kind is None:
602
630
                conflicts.append(('versioning no contents', trans_id))
603
631
                continue
604
632
            if not InventoryEntry.versionable_kind(kind):
618
646
            if self.final_file_id(trans_id) is None:
619
647
                conflicts.append(('unversioned executability', trans_id))
620
648
            else:
621
 
                try:
622
 
                    non_file = self.final_kind(trans_id) != "file"
623
 
                except NoSuchFile:
624
 
                    non_file = True
625
 
                if non_file is True:
 
649
                if self.final_kind(trans_id) != "file":
626
650
                    conflicts.append(('non-file executability', trans_id))
627
651
        return conflicts
628
652
 
630
654
        """Check for overwrites (not permitted on Win32)"""
631
655
        conflicts = []
632
656
        for trans_id in self._new_contents:
633
 
            try:
634
 
                self.tree_kind(trans_id)
635
 
            except NoSuchFile:
 
657
            if self.tree_kind(trans_id) is None:
636
658
                continue
637
659
            if trans_id not in self._removed_contents:
638
660
                conflicts.append(('overwrite', trans_id,
645
667
        if (self._new_name, self._new_parent) == ({}, {}):
646
668
            return conflicts
647
669
        for children in by_parent.itervalues():
648
 
            name_ids = [(self.final_name(t), t) for t in children]
649
 
            if not self._case_sensitive_target:
650
 
                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))
651
678
            name_ids.sort()
652
679
            last_name = None
653
680
            last_trans_id = None
654
681
            for name, trans_id in name_ids:
655
 
                try:
656
 
                    kind = self.final_kind(trans_id)
657
 
                except NoSuchFile:
658
 
                    kind = None
 
682
                kind = self.final_kind(trans_id)
659
683
                file_id = self.final_file_id(trans_id)
660
684
                if kind is None and file_id is None:
661
685
                    continue
680
704
        return conflicts
681
705
 
682
706
    def _parent_type_conflicts(self, by_parent):
683
 
        """parents must have directory 'contents'."""
 
707
        """Children must have a directory parent"""
684
708
        conflicts = []
685
709
        for parent_id, children in by_parent.iteritems():
686
710
            if parent_id is ROOT_PARENT:
687
711
                continue
688
 
            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:
689
718
                continue
690
 
            for child in children:
691
 
                try:
692
 
                    self.final_kind(child)
693
 
                except NoSuchFile:
694
 
                    continue
695
 
            try:
696
 
                kind = self.final_kind(parent_id)
697
 
            except NoSuchFile:
698
 
                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)
699
722
            if kind is None:
 
723
                # The directory will be deleted
700
724
                conflicts.append(('missing parent', parent_id))
701
725
            elif kind != "directory":
 
726
                # Meh, we need a *directory* to put something in it
702
727
                conflicts.append(('non-directory parent', parent_id))
703
728
        return conflicts
704
729
 
705
 
    def _any_contents(self, trans_ids):
706
 
        """Return true if any of the trans_ids, will have contents."""
707
 
        for trans_id in trans_ids:
708
 
            try:
709
 
                kind = self.final_kind(trans_id)
710
 
            except NoSuchFile:
711
 
                continue
712
 
            return True
713
 
        return False
714
 
 
715
730
    def _set_executability(self, path, trans_id):
716
731
        """Set the executability of versioned files """
717
732
        if supports_executable():
781
796
        self.create_symlink(target, trans_id)
782
797
        return trans_id
783
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
 
784
841
    def _affected_ids(self):
785
842
        """Return the set of transform ids affected by the transform"""
786
843
        trans_ids = set(self._removed_id)
845
902
        Return a (name, parent, kind, executable) tuple
846
903
        """
847
904
        to_name = self.final_name(to_trans_id)
848
 
        try:
849
 
            to_kind = self.final_kind(to_trans_id)
850
 
        except NoSuchFile:
851
 
            to_kind = None
 
905
        to_kind = self.final_kind(to_trans_id)
852
906
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
853
907
        if to_trans_id in self._new_executability:
854
908
            to_executable = self._new_executability[to_trans_id]
1182
1236
            if trans_id not in self._new_contents:
1183
1237
                continue
1184
1238
            new_path = self._limbo_name(trans_id)
1185
 
            osutils.rename(old_path, new_path)
 
1239
            os.rename(old_path, new_path)
1186
1240
            for descendant in self._limbo_descendants(trans_id):
1187
1241
                desc_path = self._limbo_files[descendant]
1188
1242
                desc_path = new_path + desc_path[len(old_path):]
1296
1350
            del self._limbo_children_names[trans_id]
1297
1351
        delete_any(self._limbo_name(trans_id))
1298
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
 
1299
1436
 
1300
1437
class TreeTransform(DiskTreeTransform):
1301
1438
    """Represent a tree transformation.
1419
1556
    def tree_kind(self, trans_id):
1420
1557
        """Determine the file kind in the working tree.
1421
1558
 
1422
 
        Raises NoSuchFile if the file does not exist
 
1559
        :returns: The file kind or None if the file does not exist
1423
1560
        """
1424
1561
        path = self._tree_id_paths.get(trans_id)
1425
1562
        if path is None:
1426
 
            raise NoSuchFile(None)
 
1563
            return None
1427
1564
        try:
1428
1565
            return file_kind(self._tree.abspath(path))
1429
 
        except OSError, e:
1430
 
            if e.errno != errno.ENOENT:
1431
 
                raise
1432
 
            else:
1433
 
                raise NoSuchFile(path)
 
1566
        except errors.NoSuchFile:
 
1567
            return None
1434
1568
 
1435
1569
    def _set_mode(self, trans_id, mode_id, typefunc):
1436
1570
        """Set the mode of new file contents.
1542
1676
        """
1543
1677
        if not no_conflicts:
1544
1678
            self._check_malformed()
1545
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1679
        child_pb = ui.ui_factory.nested_progress_bar()
1546
1680
        try:
1547
1681
            if precomputed_delta is None:
1548
1682
                child_pb.update('Apply phase', 0, 2)
1575
1709
    def _generate_inventory_delta(self):
1576
1710
        """Generate an inventory delta for the current transform."""
1577
1711
        inventory_delta = []
1578
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1712
        child_pb = ui.ui_factory.nested_progress_bar()
1579
1713
        new_paths = self._inventory_altered()
1580
1714
        total_entries = len(new_paths) + len(self._removed_id)
1581
1715
        try:
1605
1739
                if file_id is None:
1606
1740
                    continue
1607
1741
                needs_entry = False
1608
 
                try:
1609
 
                    kind = self.final_kind(trans_id)
1610
 
                except NoSuchFile:
 
1742
                kind = self.final_kind(trans_id)
 
1743
                if kind is None:
1611
1744
                    kind = self._tree.stored_kind(file_id)
1612
1745
                parent_trans_id = self.final_parent(trans_id)
1613
1746
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1644
1777
        """
1645
1778
        tree_paths = list(self._tree_path_ids.iteritems())
1646
1779
        tree_paths.sort(reverse=True)
1647
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1780
        child_pb = ui.ui_factory.nested_progress_bar()
1648
1781
        try:
1649
1782
            for num, data in enumerate(tree_paths):
1650
1783
                path, trans_id = data
1679
1812
        modified_paths = []
1680
1813
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1681
1814
                                 new_paths)
1682
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1815
        child_pb = ui.ui_factory.nested_progress_bar()
1683
1816
        try:
1684
1817
            for num, (path, trans_id) in enumerate(new_paths):
1685
1818
                if (num % 10) == 0:
1725
1858
    def tree_kind(self, trans_id):
1726
1859
        path = self._tree_id_paths.get(trans_id)
1727
1860
        if path is None:
1728
 
            raise NoSuchFile(None)
 
1861
            return None
1729
1862
        file_id = self._tree.path2id(path)
1730
 
        return self._tree.kind(file_id)
 
1863
        try:
 
1864
            return self._tree.kind(file_id)
 
1865
        except errors.NoSuchFile:
 
1866
            return None
1731
1867
 
1732
1868
    def _set_mode(self, trans_id, mode_id, typefunc):
1733
1869
        """Set the mode of new file contents.
1753
1889
            childpath = joinpath(path, child)
1754
1890
            yield self.trans_id_tree_path(childpath)
1755
1891
 
 
1892
    def new_orphan(self, trans_id, parent_id):
 
1893
        raise NotImplementedError(self.new_orphan)
 
1894
 
1756
1895
 
1757
1896
class _PreviewTree(tree.Tree):
1758
1897
    """Partial implementation of Tree to support show_diff_trees"""
1929
2068
            if (specific_file_ids is not None
1930
2069
                and file_id not in specific_file_ids):
1931
2070
                continue
1932
 
            try:
1933
 
                kind = self._transform.final_kind(trans_id)
1934
 
            except NoSuchFile:
 
2071
            kind = self._transform.final_kind(trans_id)
 
2072
            if kind is None:
1935
2073
                kind = self._transform._tree.stored_kind(file_id)
1936
2074
            new_entry = inventory.make_entry(
1937
2075
                kind,
2169
2307
                path_from_root = self._final_paths.get_path(child_id)
2170
2308
                basename = self._transform.final_name(child_id)
2171
2309
                file_id = self._transform.final_file_id(child_id)
2172
 
                try:
2173
 
                    kind = self._transform.final_kind(child_id)
 
2310
                kind  = self._transform.final_kind(child_id)
 
2311
                if kind is not None:
2174
2312
                    versioned_kind = kind
2175
 
                except NoSuchFile:
 
2313
                else:
2176
2314
                    kind = 'unknown'
2177
2315
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2178
2316
                if versioned_kind == 'directory':
2291
2429
    for num, _unused in enumerate(wt.all_file_ids()):
2292
2430
        if num > 0:  # more than just a root
2293
2431
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
2294
 
    existing_files = set()
2295
 
    for dir, files in wt.walkdirs():
2296
 
        existing_files.update(f[0] for f in files)
2297
2432
    file_trans_id = {}
2298
 
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2433
    top_pb = ui.ui_factory.nested_progress_bar()
2299
2434
    pp = ProgressPhase("Build phase", 2, top_pb)
2300
2435
    if tree.inventory.root is not None:
2301
2436
        # This is kind of a hack: we should be altering the root
2314
2449
        pp.next_phase()
2315
2450
        file_trans_id[wt.get_root_id()] = \
2316
2451
            tt.trans_id_tree_file_id(wt.get_root_id())
2317
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2452
        pb = ui.ui_factory.nested_progress_bar()
2318
2453
        try:
2319
2454
            deferred_contents = []
2320
2455
            num = 0
2323
2458
                precomputed_delta = []
2324
2459
            else:
2325
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)
2326
2470
            for num, (tree_path, entry) in \
2327
2471
                enumerate(tree.inventory.iter_entries_by_dir()):
2328
2472
                pb.update("Building tree", num - len(deferred_contents), total)
2448
2592
    for child in tt.iter_tree_children(old_parent):
2449
2593
        tt.adjust_path(tt.final_name(child), new_parent, child)
2450
2594
 
 
2595
 
2451
2596
def _reparent_transform_children(tt, old_parent, new_parent):
2452
2597
    by_parent = tt.by_parent()
2453
2598
    for child in by_parent[old_parent]:
2454
2599
        tt.adjust_path(tt.final_name(child), new_parent, child)
2455
2600
    return by_parent[old_parent]
2456
2601
 
 
2602
 
2457
2603
def _content_match(tree, entry, file_id, kind, target_path):
2458
2604
    if entry.kind != kind:
2459
2605
        return False
2523
2669
        raise errors.BadFileKindError(name, kind)
2524
2670
 
2525
2671
 
2526
 
@deprecated_function(deprecated_in((1, 9, 0)))
2527
 
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
2528
 
    """Create new file contents according to an inventory entry.
2529
 
 
2530
 
    DEPRECATED.  Use create_from_tree instead.
2531
 
    """
2532
 
    if entry.kind == "file":
2533
 
        if lines is None:
2534
 
            lines = tree.get_file(entry.file_id).readlines()
2535
 
        tt.create_file(lines, trans_id, mode_id=mode_id)
2536
 
    elif entry.kind == "symlink":
2537
 
        tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
2538
 
    elif entry.kind == "directory":
2539
 
        tt.create_directory(trans_id)
2540
 
 
2541
 
 
2542
2672
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2543
2673
    filter_tree_path=None):
2544
2674
    """Create new file contents according to tree contents.
2575
2705
        tt.set_executability(entry.executable, trans_id)
2576
2706
 
2577
2707
 
 
2708
@deprecated_function(deprecated_in((2, 3, 0)))
2578
2709
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2579
2710
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2580
2711
 
2581
2712
 
 
2713
@deprecated_function(deprecated_in((2, 3, 0)))
2582
2714
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2583
2715
    """Produce a backup-style name that appears to be available"""
2584
2716
    def name_gen():
2647
2779
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2648
2780
                              backups, pp, basis_tree=None,
2649
2781
                              merge_modified=None):
2650
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2782
    child_pb = ui.ui_factory.nested_progress_bar()
2651
2783
    try:
2652
2784
        if merge_modified is None:
2653
2785
            merge_modified = working_tree.merge_modified()
2656
2788
                                      merge_modified, basis_tree)
2657
2789
    finally:
2658
2790
        child_pb.finished()
2659
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2791
    child_pb = ui.ui_factory.nested_progress_bar()
2660
2792
    try:
2661
2793
        raw_conflicts = resolve_conflicts(tt, child_pb,
2662
2794
            lambda t, c: conflict_pass(t, c, target_tree))
2705
2837
                        tt.delete_contents(trans_id)
2706
2838
                    elif kind[1] is not None:
2707
2839
                        parent_trans_id = tt.trans_id_file_id(parent[0])
2708
 
                        by_parent = tt.by_parent()
2709
 
                        backup_name = _get_backup_name(name[0], by_parent,
2710
 
                                                       parent_trans_id, tt)
 
2840
                        backup_name = tt._available_backup_name(
 
2841
                            name[0], parent_trans_id)
2711
2842
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2712
2843
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2713
2844
                        if versioned == (True, True):
2836
2967
 
2837
2968
        elif c_type == 'missing parent':
2838
2969
            trans_id = conflict[1]
2839
 
            try:
2840
 
                tt.cancel_deletion(trans_id)
2841
 
                new_conflicts.add(('deleting parent', 'Not deleting',
2842
 
                                   trans_id))
2843
 
            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:
2844
2994
                create = True
2845
2995
                try:
2846
2996
                    tt.final_name(trans_id)
2871
3021
            file_id = tt.inactive_file_id(conflict[1])
2872
3022
            # special-case the other tree root (move its children instead)
2873
3023
            if path_tree and file_id in path_tree:
2874
 
                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
2875
3026
                    continue
2876
3027
            tt.version_file(file_id, conflict[1])
2877
3028
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2929
3080
    def rename(self, from_, to):
2930
3081
        """Rename a file from one path to another."""
2931
3082
        try:
2932
 
            osutils.rename(from_, to)
2933
 
        except (IOError, OSError), e:
 
3083
            os.rename(from_, to)
 
3084
        except OSError, e:
2934
3085
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2935
3086
                raise errors.FileExists(to, str(e))
2936
3087
            # normal OSError doesn't include filenames so it's hard to see where
2952
3103
        """Reverse all renames that have been performed"""
2953
3104
        for from_, to in reversed(self.past_renames):
2954
3105
            try:
2955
 
                osutils.rename(to, from_)
2956
 
            except (OSError, IOError), e:
2957
 
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)                
 
3106
                os.rename(to, from_)
 
3107
            except OSError, e:
 
3108
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2958
3109
        # after rollback, don't reuse _FileMover
2959
3110
        past_renames = None
2960
3111
        pending_deletions = None