/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: Jelmer Vernooij
  • Date: 2011-04-05 17:52:20 UTC
  • mto: This revision was merged to the branch mainline in revision 5801.
  • Revision ID: jelmer@samba.org-20110405175220-07pi4se33fhvore7
Avoid bzrlib.knit imports when using groupcompress repositories.

Add bzrlib.knit to the blacklist in test_import_tariff.

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
from bzrlib import (
 
23
    errors,
 
24
    lazy_import,
 
25
    registry,
 
26
    trace,
 
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,
32
39
    osutils,
33
40
    revision as _mod_revision,
34
41
    ui,
 
42
    urlutils,
35
43
    )
36
44
""")
37
45
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
39
47
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
40
48
                           UnableCreateSymlink)
41
49
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
42
 
from bzrlib.inventory import InventoryEntry
43
50
from bzrlib.osutils import (
44
51
    delete_any,
45
52
    file_kind,
46
53
    has_symlinks,
47
 
    lexists,
48
54
    pathjoin,
49
55
    sha_file,
50
56
    splitpath,
51
57
    supports_executable,
52
 
)
 
58
    )
53
59
from bzrlib.progress import ProgressPhase
54
60
from bzrlib.symbol_versioning import (
55
 
        deprecated_function,
56
 
        deprecated_in,
57
 
        )
58
 
from bzrlib.trace import mutter, warning
59
 
from bzrlib import tree
60
 
import bzrlib.ui
61
 
import bzrlib.urlutils as urlutils
 
61
    deprecated_function,
 
62
    deprecated_in,
 
63
    deprecated_method,
 
64
    )
62
65
 
63
66
 
64
67
ROOT_PARENT = "root-parent"
65
68
 
66
 
 
67
69
def unique_add(map, key, value):
68
70
    if key in map:
69
71
        raise DuplicateKey(key=key)
70
72
    map[key] = value
71
73
 
72
74
 
 
75
 
73
76
class _TransformResults(object):
74
77
    def __init__(self, modified_paths, rename_count):
75
78
        object.__init__(self)
123
126
            self._new_root = self.trans_id_tree_file_id(root_id)
124
127
        else:
125
128
            self._new_root = None
126
 
        # Indictor of whether the transform has been applied
 
129
        # Indicator of whether the transform has been applied
127
130
        self._done = False
128
131
        # A progress bar
129
132
        self._pb = pb
314
317
 
315
318
    def delete_contents(self, trans_id):
316
319
        """Schedule the contents of a path entry for deletion"""
317
 
        # Ensure that the object exists in the WorkingTree, this will raise an
318
 
        # exception if there is a problem
319
 
        self.tree_kind(trans_id)
320
 
        self._removed_contents.add(trans_id)
 
320
        kind = self.tree_kind(trans_id)
 
321
        if kind is not None:
 
322
            self._removed_contents.add(trans_id)
321
323
 
322
324
    def cancel_deletion(self, trans_id):
323
325
        """Cancel a scheduled deletion"""
388
390
        changed_kind = set(self._removed_contents)
389
391
        changed_kind.intersection_update(self._new_contents)
390
392
        changed_kind.difference_update(new_ids)
391
 
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
392
 
                        self.final_kind(t))
 
393
        changed_kind = (t for t in changed_kind
 
394
                        if self.tree_kind(t) != self.final_kind(t))
393
395
        new_ids.update(changed_kind)
394
396
        return sorted(FinalPaths(self).get_paths(new_ids))
395
397
 
396
398
    def final_kind(self, trans_id):
397
399
        """Determine the final file kind, after any changes applied.
398
400
 
399
 
        Raises NoSuchFile if the file does not exist/has no contents.
400
 
        (It is conceivable that a path would be created without the
401
 
        corresponding contents insertion command)
 
401
        :return: None if the file does not exist/has no contents.  (It is
 
402
            conceivable that a path would be created without the corresponding
 
403
            contents insertion command)
402
404
        """
403
405
        if trans_id in self._new_contents:
404
406
            return self._new_contents[trans_id]
405
407
        elif trans_id in self._removed_contents:
406
 
            raise NoSuchFile(None)
 
408
            return None
407
409
        else:
408
410
            return self.tree_kind(trans_id)
409
411
 
522
524
        for trans_id in self._removed_id:
523
525
            file_id = self.tree_file_id(trans_id)
524
526
            if file_id is not None:
 
527
                # XXX: This seems like something that should go via a different
 
528
                #      indirection.
525
529
                if self._tree.inventory[file_id].kind == 'directory':
526
530
                    parents.append(trans_id)
527
531
            elif self.tree_kind(trans_id) == 'directory':
531
535
            # ensure that all children are registered with the transaction
532
536
            list(self.iter_tree_children(parent_id))
533
537
 
 
538
    @deprecated_method(deprecated_in((2, 3, 0)))
534
539
    def has_named_child(self, by_parent, parent_id, name):
535
 
        try:
536
 
            children = by_parent[parent_id]
537
 
        except KeyError:
538
 
            children = []
539
 
        for child in children:
 
540
        return self._has_named_child(
 
541
            name, parent_id, known_children=by_parent.get(parent_id, []))
 
542
 
 
543
    def _has_named_child(self, name, parent_id, known_children):
 
544
        """Does a parent already have a name child.
 
545
 
 
546
        :param name: The searched for name.
 
547
 
 
548
        :param parent_id: The parent for which the check is made.
 
549
 
 
550
        :param known_children: The already known children. This should have
 
551
            been recently obtained from `self.by_parent.get(parent_id)`
 
552
            (or will be if None is passed).
 
553
        """
 
554
        if known_children is None:
 
555
            known_children = self.by_parent().get(parent_id, [])
 
556
        for child in known_children:
540
557
            if self.final_name(child) == name:
541
558
                return True
542
 
        try:
543
 
            path = self._tree_id_paths[parent_id]
544
 
        except KeyError:
 
559
        parent_path = self._tree_id_paths.get(parent_id, None)
 
560
        if parent_path is None:
 
561
            # No parent... no children
545
562
            return False
546
 
        childpath = joinpath(path, name)
547
 
        child_id = self._tree_path_ids.get(childpath)
 
563
        child_path = joinpath(parent_path, name)
 
564
        child_id = self._tree_path_ids.get(child_path, None)
548
565
        if child_id is None:
549
 
            return lexists(self._tree.abspath(childpath))
 
566
            # Not known by the tree transform yet, check the filesystem
 
567
            return osutils.lexists(self._tree.abspath(child_path))
550
568
        else:
551
 
            if self.final_parent(child_id) != parent_id:
552
 
                return False
553
 
            if child_id in self._removed_contents:
554
 
                # XXX What about dangling file-ids?
555
 
                return False
556
 
            else:
557
 
                return True
 
569
            raise AssertionError('child_id is missing: %s, %s, %s'
 
570
                                 % (name, parent_id, child_id))
 
571
 
 
572
    def _available_backup_name(self, name, target_id):
 
573
        """Find an available backup name.
 
574
 
 
575
        :param name: The basename of the file.
 
576
 
 
577
        :param target_id: The directory trans_id where the backup should 
 
578
            be placed.
 
579
        """
 
580
        known_children = self.by_parent().get(target_id, [])
 
581
        return osutils.available_backup_name(
 
582
            name,
 
583
            lambda base: self._has_named_child(
 
584
                base, target_id, known_children))
558
585
 
559
586
    def _parent_loops(self):
560
587
        """No entry should be its own ancestor"""
595
622
        """
596
623
        conflicts = []
597
624
        for trans_id in self._new_id.iterkeys():
598
 
            try:
599
 
                kind = self.final_kind(trans_id)
600
 
            except NoSuchFile:
 
625
            kind = self.final_kind(trans_id)
 
626
            if kind is None:
601
627
                conflicts.append(('versioning no contents', trans_id))
602
628
                continue
603
 
            if not InventoryEntry.versionable_kind(kind):
 
629
            if not inventory.InventoryEntry.versionable_kind(kind):
604
630
                conflicts.append(('versioning bad kind', trans_id, kind))
605
631
        return conflicts
606
632
 
617
643
            if self.final_file_id(trans_id) is None:
618
644
                conflicts.append(('unversioned executability', trans_id))
619
645
            else:
620
 
                try:
621
 
                    non_file = self.final_kind(trans_id) != "file"
622
 
                except NoSuchFile:
623
 
                    non_file = True
624
 
                if non_file is True:
 
646
                if self.final_kind(trans_id) != "file":
625
647
                    conflicts.append(('non-file executability', trans_id))
626
648
        return conflicts
627
649
 
629
651
        """Check for overwrites (not permitted on Win32)"""
630
652
        conflicts = []
631
653
        for trans_id in self._new_contents:
632
 
            try:
633
 
                self.tree_kind(trans_id)
634
 
            except NoSuchFile:
 
654
            if self.tree_kind(trans_id) is None:
635
655
                continue
636
656
            if trans_id not in self._removed_contents:
637
657
                conflicts.append(('overwrite', trans_id,
644
664
        if (self._new_name, self._new_parent) == ({}, {}):
645
665
            return conflicts
646
666
        for children in by_parent.itervalues():
647
 
            name_ids = [(self.final_name(t), t) for t in children]
648
 
            if not self._case_sensitive_target:
649
 
                name_ids = [(n.lower(), t) for n, t in name_ids]
 
667
            name_ids = []
 
668
            for child_tid in children:
 
669
                name = self.final_name(child_tid)
 
670
                if name is not None:
 
671
                    # Keep children only if they still exist in the end
 
672
                    if not self._case_sensitive_target:
 
673
                        name = name.lower()
 
674
                    name_ids.append((name, child_tid))
650
675
            name_ids.sort()
651
676
            last_name = None
652
677
            last_trans_id = None
653
678
            for name, trans_id in name_ids:
654
 
                try:
655
 
                    kind = self.final_kind(trans_id)
656
 
                except NoSuchFile:
657
 
                    kind = None
 
679
                kind = self.final_kind(trans_id)
658
680
                file_id = self.final_file_id(trans_id)
659
681
                if kind is None and file_id is None:
660
682
                    continue
679
701
        return conflicts
680
702
 
681
703
    def _parent_type_conflicts(self, by_parent):
682
 
        """parents must have directory 'contents'."""
 
704
        """Children must have a directory parent"""
683
705
        conflicts = []
684
706
        for parent_id, children in by_parent.iteritems():
685
707
            if parent_id is ROOT_PARENT:
686
708
                continue
687
 
            if not self._any_contents(children):
 
709
            no_children = True
 
710
            for child_id in children:
 
711
                if self.final_kind(child_id) is not None:
 
712
                    no_children = False
 
713
                    break
 
714
            if no_children:
688
715
                continue
689
 
            for child in children:
690
 
                try:
691
 
                    self.final_kind(child)
692
 
                except NoSuchFile:
693
 
                    continue
694
 
            try:
695
 
                kind = self.final_kind(parent_id)
696
 
            except NoSuchFile:
697
 
                kind = None
 
716
            # There is at least a child, so we need an existing directory to
 
717
            # contain it.
 
718
            kind = self.final_kind(parent_id)
698
719
            if kind is None:
 
720
                # The directory will be deleted
699
721
                conflicts.append(('missing parent', parent_id))
700
722
            elif kind != "directory":
 
723
                # Meh, we need a *directory* to put something in it
701
724
                conflicts.append(('non-directory parent', parent_id))
702
725
        return conflicts
703
726
 
704
 
    def _any_contents(self, trans_ids):
705
 
        """Return true if any of the trans_ids, will have contents."""
706
 
        for trans_id in trans_ids:
707
 
            try:
708
 
                kind = self.final_kind(trans_id)
709
 
            except NoSuchFile:
710
 
                continue
711
 
            return True
712
 
        return False
713
 
 
714
727
    def _set_executability(self, path, trans_id):
715
728
        """Set the executability of versioned files """
716
729
        if supports_executable():
780
793
        self.create_symlink(target, trans_id)
781
794
        return trans_id
782
795
 
 
796
    def new_orphan(self, trans_id, parent_id):
 
797
        """Schedule an item to be orphaned.
 
798
 
 
799
        When a directory is about to be removed, its children, if they are not
 
800
        versioned are moved out of the way: they don't have a parent anymore.
 
801
 
 
802
        :param trans_id: The trans_id of the existing item.
 
803
        :param parent_id: The parent trans_id of the item.
 
804
        """
 
805
        raise NotImplementedError(self.new_orphan)
 
806
 
 
807
    def _get_potential_orphans(self, dir_id):
 
808
        """Find the potential orphans in a directory.
 
809
 
 
810
        A directory can't be safely deleted if there are versioned files in it.
 
811
        If all the contained files are unversioned then they can be orphaned.
 
812
 
 
813
        The 'None' return value means that the directory contains at least one
 
814
        versioned file and should not be deleted.
 
815
 
 
816
        :param dir_id: The directory trans id.
 
817
 
 
818
        :return: A list of the orphan trans ids or None if at least one
 
819
             versioned file is present.
 
820
        """
 
821
        orphans = []
 
822
        # Find the potential orphans, stop if one item should be kept
 
823
        for child_tid in self.by_parent()[dir_id]:
 
824
            if child_tid in self._removed_contents:
 
825
                # The child is removed as part of the transform. Since it was
 
826
                # versioned before, it's not an orphan
 
827
                continue
 
828
            elif self.final_file_id(child_tid) is None:
 
829
                # The child is not versioned
 
830
                orphans.append(child_tid)
 
831
            else:
 
832
                # We have a versioned file here, searching for orphans is
 
833
                # meaningless.
 
834
                orphans = None
 
835
                break
 
836
        return orphans
 
837
 
783
838
    def _affected_ids(self):
784
839
        """Return the set of transform ids affected by the transform"""
785
840
        trans_ids = set(self._removed_id)
844
899
        Return a (name, parent, kind, executable) tuple
845
900
        """
846
901
        to_name = self.final_name(to_trans_id)
847
 
        try:
848
 
            to_kind = self.final_kind(to_trans_id)
849
 
        except NoSuchFile:
850
 
            to_kind = None
 
902
        to_kind = self.final_kind(to_trans_id)
851
903
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
852
904
        if to_trans_id in self._new_executability:
853
905
            to_executable = self._new_executability[to_trans_id]
927
979
        """
928
980
        return _PreviewTree(self)
929
981
 
930
 
    def commit(self, branch, message, merge_parents=None, strict=False):
 
982
    def commit(self, branch, message, merge_parents=None, strict=False,
 
983
               timestamp=None, timezone=None, committer=None, authors=None,
 
984
               revprops=None, revision_id=None):
931
985
        """Commit the result of this TreeTransform to a branch.
932
986
 
933
987
        :param branch: The branch to commit to.
934
988
        :param message: The message to attach to the commit.
935
 
        :param merge_parents: Additional parents specified by pending merges.
 
989
        :param merge_parents: Additional parent revision-ids specified by
 
990
            pending merges.
 
991
        :param strict: If True, abort the commit if there are unversioned
 
992
            files.
 
993
        :param timestamp: if not None, seconds-since-epoch for the time and
 
994
            date.  (May be a float.)
 
995
        :param timezone: Optional timezone for timestamp, as an offset in
 
996
            seconds.
 
997
        :param committer: Optional committer in email-id format.
 
998
            (e.g. "J Random Hacker <jrandom@example.com>")
 
999
        :param authors: Optional list of authors in email-id format.
 
1000
        :param revprops: Optional dictionary of revision properties.
 
1001
        :param revision_id: Optional revision id.  (Specifying a revision-id
 
1002
            may reduce performance for some non-native formats.)
936
1003
        :return: The revision_id of the revision committed.
937
1004
        """
938
1005
        self._check_malformed()
955
1022
        if self._tree.get_revision_id() != last_rev_id:
956
1023
            raise ValueError('TreeTransform not based on branch basis: %s' %
957
1024
                             self._tree.get_revision_id())
958
 
        builder = branch.get_commit_builder(parent_ids)
 
1025
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1026
        builder = branch.get_commit_builder(parent_ids,
 
1027
                                            timestamp=timestamp,
 
1028
                                            timezone=timezone,
 
1029
                                            committer=committer,
 
1030
                                            revprops=revprops,
 
1031
                                            revision_id=revision_id)
959
1032
        preview = self.get_preview_tree()
960
1033
        list(builder.record_iter_changes(preview, last_rev_id,
961
1034
                                         self.iter_changes()))
1160
1233
            if trans_id not in self._new_contents:
1161
1234
                continue
1162
1235
            new_path = self._limbo_name(trans_id)
1163
 
            osutils.rename(old_path, new_path)
 
1236
            os.rename(old_path, new_path)
1164
1237
            for descendant in self._limbo_descendants(trans_id):
1165
1238
                desc_path = self._limbo_files[descendant]
1166
1239
                desc_path = new_path + desc_path[len(old_path):]
1274
1347
            del self._limbo_children_names[trans_id]
1275
1348
        delete_any(self._limbo_name(trans_id))
1276
1349
 
 
1350
    def new_orphan(self, trans_id, parent_id):
 
1351
        # FIXME: There is no tree config, so we use the branch one (it's weird
 
1352
        # to define it this way as orphaning can only occur in a working tree,
 
1353
        # but that's all we have (for now). It will find the option in
 
1354
        # locations.conf or bazaar.conf though) -- vila 20100916
 
1355
        conf = self._tree.branch.get_config()
 
1356
        conf_var_name = 'bzr.transform.orphan_policy'
 
1357
        orphan_policy = conf.get_user_option(conf_var_name)
 
1358
        default_policy = orphaning_registry.default_key
 
1359
        if orphan_policy is None:
 
1360
            orphan_policy = default_policy
 
1361
        if orphan_policy not in orphaning_registry:
 
1362
            trace.warning('%s (from %s) is not a known policy, defaulting '
 
1363
                'to %s' % (orphan_policy, conf_var_name, default_policy))
 
1364
            orphan_policy = default_policy
 
1365
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1366
        handle_orphan(self, trans_id, parent_id)
 
1367
 
 
1368
 
 
1369
class OrphaningError(errors.BzrError):
 
1370
 
 
1371
    # Only bugs could lead to such exception being seen by the user
 
1372
    internal_error = True
 
1373
    _fmt = "Error while orphaning %s in %s directory"
 
1374
 
 
1375
    def __init__(self, orphan, parent):
 
1376
        errors.BzrError.__init__(self)
 
1377
        self.orphan = orphan
 
1378
        self.parent = parent
 
1379
 
 
1380
 
 
1381
class OrphaningForbidden(OrphaningError):
 
1382
 
 
1383
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1384
 
 
1385
    def __init__(self, policy):
 
1386
        errors.BzrError.__init__(self)
 
1387
        self.policy = policy
 
1388
 
 
1389
 
 
1390
def move_orphan(tt, orphan_id, parent_id):
 
1391
    """See TreeTransformBase.new_orphan.
 
1392
 
 
1393
    This creates a new orphan in the `bzr-orphans` dir at the root of the
 
1394
    `TreeTransform`.
 
1395
 
 
1396
    :param tt: The TreeTransform orphaning `trans_id`.
 
1397
 
 
1398
    :param orphan_id: The trans id that should be orphaned.
 
1399
 
 
1400
    :param parent_id: The orphan parent trans id.
 
1401
    """
 
1402
    # Add the orphan dir if it doesn't exist
 
1403
    orphan_dir_basename = 'bzr-orphans'
 
1404
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1405
    if tt.final_kind(od_id) is None:
 
1406
        tt.create_directory(od_id)
 
1407
    parent_path = tt._tree_id_paths[parent_id]
 
1408
    # Find a name that doesn't exist yet in the orphan dir
 
1409
    actual_name = tt.final_name(orphan_id)
 
1410
    new_name = tt._available_backup_name(actual_name, od_id)
 
1411
    tt.adjust_path(new_name, od_id, orphan_id)
 
1412
    trace.warning('%s has been orphaned in %s'
 
1413
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1414
 
 
1415
 
 
1416
def refuse_orphan(tt, orphan_id, parent_id):
 
1417
    """See TreeTransformBase.new_orphan.
 
1418
 
 
1419
    This refuses to create orphan, letting the caller handle the conflict.
 
1420
    """
 
1421
    raise OrphaningForbidden('never')
 
1422
 
 
1423
 
 
1424
orphaning_registry = registry.Registry()
 
1425
orphaning_registry.register(
 
1426
    'conflict', refuse_orphan,
 
1427
    'Leave orphans in place and create a conflict on the directory.')
 
1428
orphaning_registry.register(
 
1429
    'move', move_orphan,
 
1430
    'Move orphans into the bzr-orphans directory.')
 
1431
orphaning_registry._set_default_key('conflict')
 
1432
 
1277
1433
 
1278
1434
class TreeTransform(DiskTreeTransform):
1279
1435
    """Represent a tree transformation.
1397
1553
    def tree_kind(self, trans_id):
1398
1554
        """Determine the file kind in the working tree.
1399
1555
 
1400
 
        Raises NoSuchFile if the file does not exist
 
1556
        :returns: The file kind or None if the file does not exist
1401
1557
        """
1402
1558
        path = self._tree_id_paths.get(trans_id)
1403
1559
        if path is None:
1404
 
            raise NoSuchFile(None)
 
1560
            return None
1405
1561
        try:
1406
1562
            return file_kind(self._tree.abspath(path))
1407
 
        except OSError, e:
1408
 
            if e.errno != errno.ENOENT:
1409
 
                raise
1410
 
            else:
1411
 
                raise NoSuchFile(path)
 
1563
        except errors.NoSuchFile:
 
1564
            return None
1412
1565
 
1413
1566
    def _set_mode(self, trans_id, mode_id, typefunc):
1414
1567
        """Set the mode of new file contents.
1520
1673
        """
1521
1674
        if not no_conflicts:
1522
1675
            self._check_malformed()
1523
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1676
        child_pb = ui.ui_factory.nested_progress_bar()
1524
1677
        try:
1525
1678
            if precomputed_delta is None:
1526
1679
                child_pb.update('Apply phase', 0, 2)
1553
1706
    def _generate_inventory_delta(self):
1554
1707
        """Generate an inventory delta for the current transform."""
1555
1708
        inventory_delta = []
1556
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1709
        child_pb = ui.ui_factory.nested_progress_bar()
1557
1710
        new_paths = self._inventory_altered()
1558
1711
        total_entries = len(new_paths) + len(self._removed_id)
1559
1712
        try:
1583
1736
                if file_id is None:
1584
1737
                    continue
1585
1738
                needs_entry = False
1586
 
                try:
1587
 
                    kind = self.final_kind(trans_id)
1588
 
                except NoSuchFile:
 
1739
                kind = self.final_kind(trans_id)
 
1740
                if kind is None:
1589
1741
                    kind = self._tree.stored_kind(file_id)
1590
1742
                parent_trans_id = self.final_parent(trans_id)
1591
1743
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1622
1774
        """
1623
1775
        tree_paths = list(self._tree_path_ids.iteritems())
1624
1776
        tree_paths.sort(reverse=True)
1625
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1777
        child_pb = ui.ui_factory.nested_progress_bar()
1626
1778
        try:
1627
1779
            for num, data in enumerate(tree_paths):
1628
1780
                path, trans_id = data
1635
1787
                      or trans_id in self._new_parent):
1636
1788
                    try:
1637
1789
                        mover.rename(full_path, self._limbo_name(trans_id))
1638
 
                    except OSError, e:
 
1790
                    except errors.TransformRenameFailed, e:
1639
1791
                        if e.errno != errno.ENOENT:
1640
1792
                            raise
1641
1793
                    else:
1657
1809
        modified_paths = []
1658
1810
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1659
1811
                                 new_paths)
1660
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1812
        child_pb = ui.ui_factory.nested_progress_bar()
1661
1813
        try:
1662
1814
            for num, (path, trans_id) in enumerate(new_paths):
1663
1815
                if (num % 10) == 0:
1666
1818
                if trans_id in self._needs_rename:
1667
1819
                    try:
1668
1820
                        mover.rename(self._limbo_name(trans_id), full_path)
1669
 
                    except OSError, e:
 
1821
                    except errors.TransformRenameFailed, e:
1670
1822
                        # We may be renaming a dangling inventory id
1671
1823
                        if e.errno != errno.ENOENT:
1672
1824
                            raise
1703
1855
    def tree_kind(self, trans_id):
1704
1856
        path = self._tree_id_paths.get(trans_id)
1705
1857
        if path is None:
1706
 
            raise NoSuchFile(None)
 
1858
            return None
1707
1859
        file_id = self._tree.path2id(path)
1708
 
        return self._tree.kind(file_id)
 
1860
        try:
 
1861
            return self._tree.kind(file_id)
 
1862
        except errors.NoSuchFile:
 
1863
            return None
1709
1864
 
1710
1865
    def _set_mode(self, trans_id, mode_id, typefunc):
1711
1866
        """Set the mode of new file contents.
1731
1886
            childpath = joinpath(path, child)
1732
1887
            yield self.trans_id_tree_path(childpath)
1733
1888
 
 
1889
    def new_orphan(self, trans_id, parent_id):
 
1890
        raise NotImplementedError(self.new_orphan)
 
1891
 
1734
1892
 
1735
1893
class _PreviewTree(tree.Tree):
1736
1894
    """Partial implementation of Tree to support show_diff_trees"""
1770
1928
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1771
1929
                       self._iter_parent_trees()]
1772
1930
        vf.add_lines((file_id, tree_revision), parent_keys,
1773
 
                     self.get_file(file_id).readlines())
 
1931
                     self.get_file_lines(file_id))
1774
1932
        repo = self._get_repository()
1775
1933
        base_vf = repo.texts
1776
1934
        if base_vf not in vf.fallback_versionedfiles:
1798
1956
            executable = self.is_executable(file_id, path)
1799
1957
        return kind, executable, None
1800
1958
 
 
1959
    def is_locked(self):
 
1960
        return False
 
1961
 
1801
1962
    def lock_read(self):
1802
1963
        # Perhaps in theory, this should lock the TreeTransform?
1803
 
        pass
 
1964
        return self
1804
1965
 
1805
1966
    def unlock(self):
1806
1967
        pass
1904
2065
            if (specific_file_ids is not None
1905
2066
                and file_id not in specific_file_ids):
1906
2067
                continue
1907
 
            try:
1908
 
                kind = self._transform.final_kind(trans_id)
1909
 
            except NoSuchFile:
 
2068
            kind = self._transform.final_kind(trans_id)
 
2069
            if kind is None:
1910
2070
                kind = self._transform._tree.stored_kind(file_id)
1911
2071
            new_entry = inventory.make_entry(
1912
2072
                kind,
2144
2304
                path_from_root = self._final_paths.get_path(child_id)
2145
2305
                basename = self._transform.final_name(child_id)
2146
2306
                file_id = self._transform.final_file_id(child_id)
2147
 
                try:
2148
 
                    kind = self._transform.final_kind(child_id)
 
2307
                kind  = self._transform.final_kind(child_id)
 
2308
                if kind is not None:
2149
2309
                    versioned_kind = kind
2150
 
                except NoSuchFile:
 
2310
                else:
2151
2311
                    kind = 'unknown'
2152
2312
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2153
2313
                if versioned_kind == 'directory':
2266
2426
    for num, _unused in enumerate(wt.all_file_ids()):
2267
2427
        if num > 0:  # more than just a root
2268
2428
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
2269
 
    existing_files = set()
2270
 
    for dir, files in wt.walkdirs():
2271
 
        existing_files.update(f[0] for f in files)
2272
2429
    file_trans_id = {}
2273
 
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2430
    top_pb = ui.ui_factory.nested_progress_bar()
2274
2431
    pp = ProgressPhase("Build phase", 2, top_pb)
2275
2432
    if tree.inventory.root is not None:
2276
2433
        # This is kind of a hack: we should be altering the root
2289
2446
        pp.next_phase()
2290
2447
        file_trans_id[wt.get_root_id()] = \
2291
2448
            tt.trans_id_tree_file_id(wt.get_root_id())
2292
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2449
        pb = ui.ui_factory.nested_progress_bar()
2293
2450
        try:
2294
2451
            deferred_contents = []
2295
2452
            num = 0
2298
2455
                precomputed_delta = []
2299
2456
            else:
2300
2457
                precomputed_delta = None
 
2458
            # Check if tree inventory has content. If so, we populate
 
2459
            # existing_files with the directory content. If there are no
 
2460
            # entries we skip populating existing_files as its not used.
 
2461
            # This improves performance and unncessary work on large
 
2462
            # directory trees. (#501307)
 
2463
            if total > 0:
 
2464
                existing_files = set()
 
2465
                for dir, files in wt.walkdirs():
 
2466
                    existing_files.update(f[0] for f in files)
2301
2467
            for num, (tree_path, entry) in \
2302
2468
                enumerate(tree.inventory.iter_entries_by_dir()):
2303
2469
                pb.update("Building tree", num - len(deferred_contents), total)
2355
2521
            precomputed_delta = None
2356
2522
        conflicts = cook_conflicts(raw_conflicts, tt)
2357
2523
        for conflict in conflicts:
2358
 
            warning(conflict)
 
2524
            trace.warning(conflict)
2359
2525
        try:
2360
2526
            wt.add_conflicts(conflicts)
2361
2527
        except errors.UnsupportedOperation:
2423
2589
    for child in tt.iter_tree_children(old_parent):
2424
2590
        tt.adjust_path(tt.final_name(child), new_parent, child)
2425
2591
 
 
2592
 
2426
2593
def _reparent_transform_children(tt, old_parent, new_parent):
2427
2594
    by_parent = tt.by_parent()
2428
2595
    for child in by_parent[old_parent]:
2429
2596
        tt.adjust_path(tt.final_name(child), new_parent, child)
2430
2597
    return by_parent[old_parent]
2431
2598
 
 
2599
 
2432
2600
def _content_match(tree, entry, file_id, kind, target_path):
2433
2601
    if entry.kind != kind:
2434
2602
        return False
2435
2603
    if entry.kind == "directory":
2436
2604
        return True
2437
2605
    if entry.kind == "file":
2438
 
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
2439
 
            return True
 
2606
        f = file(target_path, 'rb')
 
2607
        try:
 
2608
            if tree.get_file_text(file_id) == f.read():
 
2609
                return True
 
2610
        finally:
 
2611
            f.close()
2440
2612
    elif entry.kind == "symlink":
2441
2613
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2442
2614
            return True
2494
2666
        raise errors.BadFileKindError(name, kind)
2495
2667
 
2496
2668
 
2497
 
@deprecated_function(deprecated_in((1, 9, 0)))
2498
 
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
2499
 
    """Create new file contents according to an inventory entry.
2500
 
 
2501
 
    DEPRECATED.  Use create_from_tree instead.
2502
 
    """
2503
 
    if entry.kind == "file":
2504
 
        if lines is None:
2505
 
            lines = tree.get_file(entry.file_id).readlines()
2506
 
        tt.create_file(lines, trans_id, mode_id=mode_id)
2507
 
    elif entry.kind == "symlink":
2508
 
        tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
2509
 
    elif entry.kind == "directory":
2510
 
        tt.create_directory(trans_id)
2511
 
 
2512
 
 
2513
2669
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2514
2670
    filter_tree_path=None):
2515
2671
    """Create new file contents according to tree contents.
2546
2702
        tt.set_executability(entry.executable, trans_id)
2547
2703
 
2548
2704
 
 
2705
@deprecated_function(deprecated_in((2, 3, 0)))
2549
2706
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2550
2707
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2551
2708
 
2552
2709
 
 
2710
@deprecated_function(deprecated_in((2, 3, 0)))
2553
2711
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2554
2712
    """Produce a backup-style name that appears to be available"""
2555
2713
    def name_gen():
2604
2762
                unversioned_filter=working_tree.is_ignored)
2605
2763
            delta.report_changes(tt.iter_changes(), change_reporter)
2606
2764
        for conflict in conflicts:
2607
 
            warning(conflict)
 
2765
            trace.warning(conflict)
2608
2766
        pp.next_phase()
2609
2767
        tt.apply()
2610
2768
        working_tree.set_merge_modified(merge_modified)
2618
2776
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2619
2777
                              backups, pp, basis_tree=None,
2620
2778
                              merge_modified=None):
2621
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2779
    child_pb = ui.ui_factory.nested_progress_bar()
2622
2780
    try:
2623
2781
        if merge_modified is None:
2624
2782
            merge_modified = working_tree.merge_modified()
2627
2785
                                      merge_modified, basis_tree)
2628
2786
    finally:
2629
2787
        child_pb.finished()
2630
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2788
    child_pb = ui.ui_factory.nested_progress_bar()
2631
2789
    try:
2632
2790
        raw_conflicts = resolve_conflicts(tt, child_pb,
2633
2791
            lambda t, c: conflict_pass(t, c, target_tree))
2676
2834
                        tt.delete_contents(trans_id)
2677
2835
                    elif kind[1] is not None:
2678
2836
                        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)
 
2837
                        backup_name = tt._available_backup_name(
 
2838
                            name[0], parent_trans_id)
2682
2839
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2683
2840
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2684
2841
                        if versioned == (True, True):
2807
2964
 
2808
2965
        elif c_type == 'missing parent':
2809
2966
            trans_id = conflict[1]
2810
 
            try:
2811
 
                tt.cancel_deletion(trans_id)
2812
 
                new_conflicts.add(('deleting parent', 'Not deleting',
2813
 
                                   trans_id))
2814
 
            except KeyError:
 
2967
            if trans_id in tt._removed_contents:
 
2968
                cancel_deletion = True
 
2969
                orphans = tt._get_potential_orphans(trans_id)
 
2970
                if orphans:
 
2971
                    cancel_deletion = False
 
2972
                    # All children are orphans
 
2973
                    for o in orphans:
 
2974
                        try:
 
2975
                            tt.new_orphan(o, trans_id)
 
2976
                        except OrphaningError:
 
2977
                            # Something bad happened so we cancel the directory
 
2978
                            # deletion which will leave it in place with a
 
2979
                            # conflict. The user can deal with it from there.
 
2980
                            # Note that this also catch the case where we don't
 
2981
                            # want to create orphans and leave the directory in
 
2982
                            # place.
 
2983
                            cancel_deletion = True
 
2984
                            break
 
2985
                if cancel_deletion:
 
2986
                    # Cancel the directory deletion
 
2987
                    tt.cancel_deletion(trans_id)
 
2988
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
2989
                                       trans_id))
 
2990
            else:
2815
2991
                create = True
2816
2992
                try:
2817
2993
                    tt.final_name(trans_id)
2842
3018
            file_id = tt.inactive_file_id(conflict[1])
2843
3019
            # special-case the other tree root (move its children instead)
2844
3020
            if path_tree and file_id in path_tree:
2845
 
                if path_tree.inventory[file_id].parent_id is None:
 
3021
                if path_tree.path2id('') == file_id:
 
3022
                    # This is the root entry, skip it
2846
3023
                    continue
2847
3024
            tt.version_file(file_id, conflict[1])
2848
3025
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2900
3077
    def rename(self, from_, to):
2901
3078
        """Rename a file from one path to another."""
2902
3079
        try:
2903
 
            osutils.rename(from_, to)
 
3080
            os.rename(from_, to)
2904
3081
        except OSError, e:
2905
3082
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2906
3083
                raise errors.FileExists(to, str(e))
2907
 
            raise
 
3084
            # normal OSError doesn't include filenames so it's hard to see where
 
3085
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
 
3086
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
2908
3087
        self.past_renames.append((from_, to))
2909
3088
 
2910
3089
    def pre_delete(self, from_, to):
2920
3099
    def rollback(self):
2921
3100
        """Reverse all renames that have been performed"""
2922
3101
        for from_, to in reversed(self.past_renames):
2923
 
            osutils.rename(to, from_)
 
3102
            try:
 
3103
                os.rename(to, from_)
 
3104
            except OSError, e:
 
3105
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2924
3106
        # after rollback, don't reuse _FileMover
2925
3107
        past_renames = None
2926
3108
        pending_deletions = None