/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: Canonical.com Patch Queue Manager
  • Date: 2011-06-02 16:57:09 UTC
  • mfrom: (5927.2.8 598572-zlib-error)
  • Revision ID: pqm@pqm.ubuntu.com-20110602165709-ry228rc95pgnj3g9
(jr) Display error when zlib corruption occurs rather than a backtrace
 (Jonathan Riddell)

Show diffs side-by-side

added added

removed removed

Lines of Context:
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)
99
102
        self._new_parent = {}
100
103
        # mapping of trans_id with new contents -> new file_kind
101
104
        self._new_contents = {}
 
105
        # mapping of trans_id => (sha1 of content, stat_value)
 
106
        self._observed_sha1s = {}
102
107
        # Set of trans_ids whose contents will be removed
103
108
        self._removed_contents = set()
104
109
        # Mapping of trans_id -> new execute-bit value
123
128
            self._new_root = self.trans_id_tree_file_id(root_id)
124
129
        else:
125
130
            self._new_root = None
126
 
        # Indictor of whether the transform has been applied
 
131
        # Indicator of whether the transform has been applied
127
132
        self._done = False
128
133
        # A progress bar
129
134
        self._pb = pb
314
319
 
315
320
    def delete_contents(self, trans_id):
316
321
        """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)
 
322
        kind = self.tree_kind(trans_id)
 
323
        if kind is not None:
 
324
            self._removed_contents.add(trans_id)
321
325
 
322
326
    def cancel_deletion(self, trans_id):
323
327
        """Cancel a scheduled deletion"""
388
392
        changed_kind = set(self._removed_contents)
389
393
        changed_kind.intersection_update(self._new_contents)
390
394
        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))
 
395
        changed_kind = (t for t in changed_kind
 
396
                        if self.tree_kind(t) != self.final_kind(t))
393
397
        new_ids.update(changed_kind)
394
398
        return sorted(FinalPaths(self).get_paths(new_ids))
395
399
 
396
400
    def final_kind(self, trans_id):
397
401
        """Determine the final file kind, after any changes applied.
398
402
 
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)
 
403
        :return: None if the file does not exist/has no contents.  (It is
 
404
            conceivable that a path would be created without the corresponding
 
405
            contents insertion command)
402
406
        """
403
407
        if trans_id in self._new_contents:
404
408
            return self._new_contents[trans_id]
405
409
        elif trans_id in self._removed_contents:
406
 
            raise NoSuchFile(None)
 
410
            return None
407
411
        else:
408
412
            return self.tree_kind(trans_id)
409
413
 
522
526
        for trans_id in self._removed_id:
523
527
            file_id = self.tree_file_id(trans_id)
524
528
            if file_id is not None:
 
529
                # XXX: This seems like something that should go via a different
 
530
                #      indirection.
525
531
                if self._tree.inventory[file_id].kind == 'directory':
526
532
                    parents.append(trans_id)
527
533
            elif self.tree_kind(trans_id) == 'directory':
531
537
            # ensure that all children are registered with the transaction
532
538
            list(self.iter_tree_children(parent_id))
533
539
 
 
540
    @deprecated_method(deprecated_in((2, 3, 0)))
534
541
    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:
 
542
        return self._has_named_child(
 
543
            name, parent_id, known_children=by_parent.get(parent_id, []))
 
544
 
 
545
    def _has_named_child(self, name, parent_id, known_children):
 
546
        """Does a parent already have a name child.
 
547
 
 
548
        :param name: The searched for name.
 
549
 
 
550
        :param parent_id: The parent for which the check is made.
 
551
 
 
552
        :param known_children: The already known children. This should have
 
553
            been recently obtained from `self.by_parent.get(parent_id)`
 
554
            (or will be if None is passed).
 
555
        """
 
556
        if known_children is None:
 
557
            known_children = self.by_parent().get(parent_id, [])
 
558
        for child in known_children:
540
559
            if self.final_name(child) == name:
541
560
                return True
542
 
        try:
543
 
            path = self._tree_id_paths[parent_id]
544
 
        except KeyError:
 
561
        parent_path = self._tree_id_paths.get(parent_id, None)
 
562
        if parent_path is None:
 
563
            # No parent... no children
545
564
            return False
546
 
        childpath = joinpath(path, name)
547
 
        child_id = self._tree_path_ids.get(childpath)
 
565
        child_path = joinpath(parent_path, name)
 
566
        child_id = self._tree_path_ids.get(child_path, None)
548
567
        if child_id is None:
549
 
            return lexists(self._tree.abspath(childpath))
 
568
            # Not known by the tree transform yet, check the filesystem
 
569
            return osutils.lexists(self._tree.abspath(child_path))
550
570
        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
 
571
            raise AssertionError('child_id is missing: %s, %s, %s'
 
572
                                 % (name, parent_id, child_id))
 
573
 
 
574
    def _available_backup_name(self, name, target_id):
 
575
        """Find an available backup name.
 
576
 
 
577
        :param name: The basename of the file.
 
578
 
 
579
        :param target_id: The directory trans_id where the backup should 
 
580
            be placed.
 
581
        """
 
582
        known_children = self.by_parent().get(target_id, [])
 
583
        return osutils.available_backup_name(
 
584
            name,
 
585
            lambda base: self._has_named_child(
 
586
                base, target_id, known_children))
558
587
 
559
588
    def _parent_loops(self):
560
589
        """No entry should be its own ancestor"""
595
624
        """
596
625
        conflicts = []
597
626
        for trans_id in self._new_id.iterkeys():
598
 
            try:
599
 
                kind = self.final_kind(trans_id)
600
 
            except NoSuchFile:
 
627
            kind = self.final_kind(trans_id)
 
628
            if kind is None:
601
629
                conflicts.append(('versioning no contents', trans_id))
602
630
                continue
603
 
            if not InventoryEntry.versionable_kind(kind):
 
631
            if not inventory.InventoryEntry.versionable_kind(kind):
604
632
                conflicts.append(('versioning bad kind', trans_id, kind))
605
633
        return conflicts
606
634
 
617
645
            if self.final_file_id(trans_id) is None:
618
646
                conflicts.append(('unversioned executability', trans_id))
619
647
            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:
 
648
                if self.final_kind(trans_id) != "file":
625
649
                    conflicts.append(('non-file executability', trans_id))
626
650
        return conflicts
627
651
 
629
653
        """Check for overwrites (not permitted on Win32)"""
630
654
        conflicts = []
631
655
        for trans_id in self._new_contents:
632
 
            try:
633
 
                self.tree_kind(trans_id)
634
 
            except NoSuchFile:
 
656
            if self.tree_kind(trans_id) is None:
635
657
                continue
636
658
            if trans_id not in self._removed_contents:
637
659
                conflicts.append(('overwrite', trans_id,
644
666
        if (self._new_name, self._new_parent) == ({}, {}):
645
667
            return conflicts
646
668
        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]
 
669
            name_ids = []
 
670
            for child_tid in children:
 
671
                name = self.final_name(child_tid)
 
672
                if name is not None:
 
673
                    # Keep children only if they still exist in the end
 
674
                    if not self._case_sensitive_target:
 
675
                        name = name.lower()
 
676
                    name_ids.append((name, child_tid))
650
677
            name_ids.sort()
651
678
            last_name = None
652
679
            last_trans_id = None
653
680
            for name, trans_id in name_ids:
654
 
                try:
655
 
                    kind = self.final_kind(trans_id)
656
 
                except NoSuchFile:
657
 
                    kind = None
 
681
                kind = self.final_kind(trans_id)
658
682
                file_id = self.final_file_id(trans_id)
659
683
                if kind is None and file_id is None:
660
684
                    continue
679
703
        return conflicts
680
704
 
681
705
    def _parent_type_conflicts(self, by_parent):
682
 
        """parents must have directory 'contents'."""
 
706
        """Children must have a directory parent"""
683
707
        conflicts = []
684
708
        for parent_id, children in by_parent.iteritems():
685
709
            if parent_id is ROOT_PARENT:
686
710
                continue
687
 
            if not self._any_contents(children):
 
711
            no_children = True
 
712
            for child_id in children:
 
713
                if self.final_kind(child_id) is not None:
 
714
                    no_children = False
 
715
                    break
 
716
            if no_children:
688
717
                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
 
718
            # There is at least a child, so we need an existing directory to
 
719
            # contain it.
 
720
            kind = self.final_kind(parent_id)
698
721
            if kind is None:
 
722
                # The directory will be deleted
699
723
                conflicts.append(('missing parent', parent_id))
700
724
            elif kind != "directory":
 
725
                # Meh, we need a *directory* to put something in it
701
726
                conflicts.append(('non-directory parent', parent_id))
702
727
        return conflicts
703
728
 
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
729
    def _set_executability(self, path, trans_id):
715
730
        """Set the executability of versioned files """
716
731
        if supports_executable():
738
753
        return trans_id
739
754
 
740
755
    def new_file(self, name, parent_id, contents, file_id=None,
741
 
                 executable=None):
 
756
                 executable=None, sha1=None):
742
757
        """Convenience method to create files.
743
758
 
744
759
        name is the name of the file to create.
751
766
        trans_id = self._new_entry(name, parent_id, file_id)
752
767
        # TODO: rather than scheduling a set_executable call,
753
768
        # have create_file create the file with the right mode.
754
 
        self.create_file(contents, trans_id)
 
769
        self.create_file(contents, trans_id, sha1=sha1)
755
770
        if executable is not None:
756
771
            self.set_executability(executable, trans_id)
757
772
        return trans_id
780
795
        self.create_symlink(target, trans_id)
781
796
        return trans_id
782
797
 
 
798
    def new_orphan(self, trans_id, parent_id):
 
799
        """Schedule an item to be orphaned.
 
800
 
 
801
        When a directory is about to be removed, its children, if they are not
 
802
        versioned are moved out of the way: they don't have a parent anymore.
 
803
 
 
804
        :param trans_id: The trans_id of the existing item.
 
805
        :param parent_id: The parent trans_id of the item.
 
806
        """
 
807
        raise NotImplementedError(self.new_orphan)
 
808
 
 
809
    def _get_potential_orphans(self, dir_id):
 
810
        """Find the potential orphans in a directory.
 
811
 
 
812
        A directory can't be safely deleted if there are versioned files in it.
 
813
        If all the contained files are unversioned then they can be orphaned.
 
814
 
 
815
        The 'None' return value means that the directory contains at least one
 
816
        versioned file and should not be deleted.
 
817
 
 
818
        :param dir_id: The directory trans id.
 
819
 
 
820
        :return: A list of the orphan trans ids or None if at least one
 
821
             versioned file is present.
 
822
        """
 
823
        orphans = []
 
824
        # Find the potential orphans, stop if one item should be kept
 
825
        for child_tid in self.by_parent()[dir_id]:
 
826
            if child_tid in self._removed_contents:
 
827
                # The child is removed as part of the transform. Since it was
 
828
                # versioned before, it's not an orphan
 
829
                continue
 
830
            elif self.final_file_id(child_tid) is None:
 
831
                # The child is not versioned
 
832
                orphans.append(child_tid)
 
833
            else:
 
834
                # We have a versioned file here, searching for orphans is
 
835
                # meaningless.
 
836
                orphans = None
 
837
                break
 
838
        return orphans
 
839
 
783
840
    def _affected_ids(self):
784
841
        """Return the set of transform ids affected by the transform"""
785
842
        trans_ids = set(self._removed_id)
844
901
        Return a (name, parent, kind, executable) tuple
845
902
        """
846
903
        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
 
904
        to_kind = self.final_kind(to_trans_id)
851
905
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
852
906
        if to_trans_id in self._new_executability:
853
907
            to_executable = self._new_executability[to_trans_id]
927
981
        """
928
982
        return _PreviewTree(self)
929
983
 
930
 
    def commit(self, branch, message, merge_parents=None, strict=False):
 
984
    def commit(self, branch, message, merge_parents=None, strict=False,
 
985
               timestamp=None, timezone=None, committer=None, authors=None,
 
986
               revprops=None, revision_id=None):
931
987
        """Commit the result of this TreeTransform to a branch.
932
988
 
933
989
        :param branch: The branch to commit to.
934
990
        :param message: The message to attach to the commit.
935
 
        :param merge_parents: Additional parents specified by pending merges.
 
991
        :param merge_parents: Additional parent revision-ids specified by
 
992
            pending merges.
 
993
        :param strict: If True, abort the commit if there are unversioned
 
994
            files.
 
995
        :param timestamp: if not None, seconds-since-epoch for the time and
 
996
            date.  (May be a float.)
 
997
        :param timezone: Optional timezone for timestamp, as an offset in
 
998
            seconds.
 
999
        :param committer: Optional committer in email-id format.
 
1000
            (e.g. "J Random Hacker <jrandom@example.com>")
 
1001
        :param authors: Optional list of authors in email-id format.
 
1002
        :param revprops: Optional dictionary of revision properties.
 
1003
        :param revision_id: Optional revision id.  (Specifying a revision-id
 
1004
            may reduce performance for some non-native formats.)
936
1005
        :return: The revision_id of the revision committed.
937
1006
        """
938
1007
        self._check_malformed()
955
1024
        if self._tree.get_revision_id() != last_rev_id:
956
1025
            raise ValueError('TreeTransform not based on branch basis: %s' %
957
1026
                             self._tree.get_revision_id())
958
 
        builder = branch.get_commit_builder(parent_ids)
 
1027
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1028
        builder = branch.get_commit_builder(parent_ids,
 
1029
                                            timestamp=timestamp,
 
1030
                                            timezone=timezone,
 
1031
                                            committer=committer,
 
1032
                                            revprops=revprops,
 
1033
                                            revision_id=revision_id)
959
1034
        preview = self.get_preview_tree()
960
1035
        list(builder.record_iter_changes(preview, last_rev_id,
961
1036
                                         self.iter_changes()))
1097
1172
        if self._tree is None:
1098
1173
            return
1099
1174
        try:
1100
 
            entries = [(self._limbo_name(t), t, k) for t, k in
1101
 
                       self._new_contents.iteritems()]
1102
 
            entries.sort(reverse=True)
1103
 
            for path, trans_id, kind in entries:
1104
 
                delete_any(path)
 
1175
            limbo_paths = sorted(self._limbo_files.values(), reverse=True)
 
1176
            for path in limbo_paths:
 
1177
                try:
 
1178
                    delete_any(path)
 
1179
                except OSError, e:
 
1180
                    if e.errno != errno.ENOENT:
 
1181
                        raise
 
1182
                    # XXX: warn? perhaps we just got interrupted at an
 
1183
                    # inconvenient moment, but perhaps files are disappearing
 
1184
                    # from under us?
1105
1185
            try:
1106
1186
                delete_any(self._limbodir)
1107
1187
            except OSError:
1160
1240
            if trans_id not in self._new_contents:
1161
1241
                continue
1162
1242
            new_path = self._limbo_name(trans_id)
1163
 
            osutils.rename(old_path, new_path)
 
1243
            os.rename(old_path, new_path)
1164
1244
            for descendant in self._limbo_descendants(trans_id):
1165
1245
                desc_path = self._limbo_files[descendant]
1166
1246
                desc_path = new_path + desc_path[len(old_path):]
1173
1253
            descendants.update(self._limbo_descendants(descendant))
1174
1254
        return descendants
1175
1255
 
1176
 
    def create_file(self, contents, trans_id, mode_id=None):
 
1256
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
1177
1257
        """Schedule creation of a new file.
1178
1258
 
1179
 
        See also new_file.
1180
 
 
1181
 
        Contents is an iterator of strings, all of which will be written
1182
 
        to the target destination.
1183
 
 
1184
 
        New file takes the permissions of any existing file with that id,
1185
 
        unless mode_id is specified.
 
1259
        :seealso: new_file.
 
1260
 
 
1261
        :param contents: an iterator of strings, all of which will be written
 
1262
            to the target destination.
 
1263
        :param trans_id: TreeTransform handle
 
1264
        :param mode_id: If not None, force the mode of the target file to match
 
1265
            the mode of the object referenced by mode_id.
 
1266
            Otherwise, we will try to preserve mode bits of an existing file.
 
1267
        :param sha1: If the sha1 of this content is already known, pass it in.
 
1268
            We can use it to prevent future sha1 computations.
1186
1269
        """
1187
1270
        name = self._limbo_name(trans_id)
1188
1271
        f = open(name, 'wb')
1189
1272
        try:
1190
 
            try:
1191
 
                unique_add(self._new_contents, trans_id, 'file')
1192
 
            except:
1193
 
                # Clean up the file, it never got registered so
1194
 
                # TreeTransform.finalize() won't clean it up.
1195
 
                f.close()
1196
 
                os.unlink(name)
1197
 
                raise
1198
 
 
 
1273
            unique_add(self._new_contents, trans_id, 'file')
1199
1274
            f.writelines(contents)
1200
1275
        finally:
1201
1276
            f.close()
1202
1277
        self._set_mtime(name)
1203
1278
        self._set_mode(trans_id, mode_id, S_ISREG)
 
1279
        # It is unfortunate we have to use lstat instead of fstat, but we just
 
1280
        # used utime and chmod on the file, so we need the accurate final
 
1281
        # details.
 
1282
        if sha1 is not None:
 
1283
            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
1204
1284
 
1205
1285
    def _read_file_chunks(self, trans_id):
1206
1286
        cur_file = open(self._limbo_name(trans_id), 'rb')
1265
1345
    def cancel_creation(self, trans_id):
1266
1346
        """Cancel the creation of new file contents."""
1267
1347
        del self._new_contents[trans_id]
 
1348
        if trans_id in self._observed_sha1s:
 
1349
            del self._observed_sha1s[trans_id]
1268
1350
        children = self._limbo_children.get(trans_id)
1269
1351
        # if this is a limbo directory with children, move them before removing
1270
1352
        # the directory
1274
1356
            del self._limbo_children_names[trans_id]
1275
1357
        delete_any(self._limbo_name(trans_id))
1276
1358
 
 
1359
    def new_orphan(self, trans_id, parent_id):
 
1360
        # FIXME: There is no tree config, so we use the branch one (it's weird
 
1361
        # to define it this way as orphaning can only occur in a working tree,
 
1362
        # but that's all we have (for now). It will find the option in
 
1363
        # locations.conf or bazaar.conf though) -- vila 20100916
 
1364
        conf = self._tree.branch.get_config()
 
1365
        conf_var_name = 'bzr.transform.orphan_policy'
 
1366
        orphan_policy = conf.get_user_option(conf_var_name)
 
1367
        default_policy = orphaning_registry.default_key
 
1368
        if orphan_policy is None:
 
1369
            orphan_policy = default_policy
 
1370
        if orphan_policy not in orphaning_registry:
 
1371
            trace.warning('%s (from %s) is not a known policy, defaulting '
 
1372
                'to %s' % (orphan_policy, conf_var_name, default_policy))
 
1373
            orphan_policy = default_policy
 
1374
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1375
        handle_orphan(self, trans_id, parent_id)
 
1376
 
 
1377
 
 
1378
class OrphaningError(errors.BzrError):
 
1379
 
 
1380
    # Only bugs could lead to such exception being seen by the user
 
1381
    internal_error = True
 
1382
    _fmt = "Error while orphaning %s in %s directory"
 
1383
 
 
1384
    def __init__(self, orphan, parent):
 
1385
        errors.BzrError.__init__(self)
 
1386
        self.orphan = orphan
 
1387
        self.parent = parent
 
1388
 
 
1389
 
 
1390
class OrphaningForbidden(OrphaningError):
 
1391
 
 
1392
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1393
 
 
1394
    def __init__(self, policy):
 
1395
        errors.BzrError.__init__(self)
 
1396
        self.policy = policy
 
1397
 
 
1398
 
 
1399
def move_orphan(tt, orphan_id, parent_id):
 
1400
    """See TreeTransformBase.new_orphan.
 
1401
 
 
1402
    This creates a new orphan in the `bzr-orphans` dir at the root of the
 
1403
    `TreeTransform`.
 
1404
 
 
1405
    :param tt: The TreeTransform orphaning `trans_id`.
 
1406
 
 
1407
    :param orphan_id: The trans id that should be orphaned.
 
1408
 
 
1409
    :param parent_id: The orphan parent trans id.
 
1410
    """
 
1411
    # Add the orphan dir if it doesn't exist
 
1412
    orphan_dir_basename = 'bzr-orphans'
 
1413
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1414
    if tt.final_kind(od_id) is None:
 
1415
        tt.create_directory(od_id)
 
1416
    parent_path = tt._tree_id_paths[parent_id]
 
1417
    # Find a name that doesn't exist yet in the orphan dir
 
1418
    actual_name = tt.final_name(orphan_id)
 
1419
    new_name = tt._available_backup_name(actual_name, od_id)
 
1420
    tt.adjust_path(new_name, od_id, orphan_id)
 
1421
    trace.warning('%s has been orphaned in %s'
 
1422
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1423
 
 
1424
 
 
1425
def refuse_orphan(tt, orphan_id, parent_id):
 
1426
    """See TreeTransformBase.new_orphan.
 
1427
 
 
1428
    This refuses to create orphan, letting the caller handle the conflict.
 
1429
    """
 
1430
    raise OrphaningForbidden('never')
 
1431
 
 
1432
 
 
1433
orphaning_registry = registry.Registry()
 
1434
orphaning_registry.register(
 
1435
    'conflict', refuse_orphan,
 
1436
    'Leave orphans in place and create a conflict on the directory.')
 
1437
orphaning_registry.register(
 
1438
    'move', move_orphan,
 
1439
    'Move orphans into the bzr-orphans directory.')
 
1440
orphaning_registry._set_default_key('conflict')
 
1441
 
1277
1442
 
1278
1443
class TreeTransform(DiskTreeTransform):
1279
1444
    """Represent a tree transformation.
1397
1562
    def tree_kind(self, trans_id):
1398
1563
        """Determine the file kind in the working tree.
1399
1564
 
1400
 
        Raises NoSuchFile if the file does not exist
 
1565
        :returns: The file kind or None if the file does not exist
1401
1566
        """
1402
1567
        path = self._tree_id_paths.get(trans_id)
1403
1568
        if path is None:
1404
 
            raise NoSuchFile(None)
 
1569
            return None
1405
1570
        try:
1406
1571
            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)
 
1572
        except errors.NoSuchFile:
 
1573
            return None
1412
1574
 
1413
1575
    def _set_mode(self, trans_id, mode_id, typefunc):
1414
1576
        """Set the mode of new file contents.
1520
1682
        """
1521
1683
        if not no_conflicts:
1522
1684
            self._check_malformed()
1523
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1685
        child_pb = ui.ui_factory.nested_progress_bar()
1524
1686
        try:
1525
1687
            if precomputed_delta is None:
1526
1688
                child_pb.update('Apply phase', 0, 2)
1546
1708
        finally:
1547
1709
            child_pb.finished()
1548
1710
        self._tree.apply_inventory_delta(inventory_delta)
 
1711
        self._apply_observed_sha1s()
1549
1712
        self._done = True
1550
1713
        self.finalize()
1551
1714
        return _TransformResults(modified_paths, self.rename_count)
1553
1716
    def _generate_inventory_delta(self):
1554
1717
        """Generate an inventory delta for the current transform."""
1555
1718
        inventory_delta = []
1556
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1719
        child_pb = ui.ui_factory.nested_progress_bar()
1557
1720
        new_paths = self._inventory_altered()
1558
1721
        total_entries = len(new_paths) + len(self._removed_id)
1559
1722
        try:
1583
1746
                if file_id is None:
1584
1747
                    continue
1585
1748
                needs_entry = False
1586
 
                try:
1587
 
                    kind = self.final_kind(trans_id)
1588
 
                except NoSuchFile:
 
1749
                kind = self.final_kind(trans_id)
 
1750
                if kind is None:
1589
1751
                    kind = self._tree.stored_kind(file_id)
1590
1752
                parent_trans_id = self.final_parent(trans_id)
1591
1753
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1622
1784
        """
1623
1785
        tree_paths = list(self._tree_path_ids.iteritems())
1624
1786
        tree_paths.sort(reverse=True)
1625
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1787
        child_pb = ui.ui_factory.nested_progress_bar()
1626
1788
        try:
1627
1789
            for num, data in enumerate(tree_paths):
1628
1790
                path, trans_id = data
1635
1797
                      or trans_id in self._new_parent):
1636
1798
                    try:
1637
1799
                        mover.rename(full_path, self._limbo_name(trans_id))
1638
 
                    except OSError, e:
 
1800
                    except errors.TransformRenameFailed, e:
1639
1801
                        if e.errno != errno.ENOENT:
1640
1802
                            raise
1641
1803
                    else:
1657
1819
        modified_paths = []
1658
1820
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1659
1821
                                 new_paths)
1660
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1822
        child_pb = ui.ui_factory.nested_progress_bar()
1661
1823
        try:
1662
1824
            for num, (path, trans_id) in enumerate(new_paths):
1663
1825
                if (num % 10) == 0:
1666
1828
                if trans_id in self._needs_rename:
1667
1829
                    try:
1668
1830
                        mover.rename(self._limbo_name(trans_id), full_path)
1669
 
                    except OSError, e:
 
1831
                    except errors.TransformRenameFailed, e:
1670
1832
                        # We may be renaming a dangling inventory id
1671
1833
                        if e.errno != errno.ENOENT:
1672
1834
                            raise
1673
1835
                    else:
1674
1836
                        self.rename_count += 1
 
1837
                    # TODO: if trans_id in self._observed_sha1s, we should
 
1838
                    #       re-stat the final target, since ctime will be
 
1839
                    #       updated by the change.
1675
1840
                if (trans_id in self._new_contents or
1676
1841
                    self.path_changed(trans_id)):
1677
1842
                    if trans_id in self._new_contents:
1678
1843
                        modified_paths.append(full_path)
1679
1844
                if trans_id in self._new_executability:
1680
1845
                    self._set_executability(path, trans_id)
 
1846
                if trans_id in self._observed_sha1s:
 
1847
                    o_sha1, o_st_val = self._observed_sha1s[trans_id]
 
1848
                    st = osutils.lstat(full_path)
 
1849
                    self._observed_sha1s[trans_id] = (o_sha1, st)
1681
1850
        finally:
1682
1851
            child_pb.finished()
 
1852
        for path, trans_id in new_paths:
 
1853
            # new_paths includes stuff like workingtree conflicts. Only the
 
1854
            # stuff in new_contents actually comes from limbo.
 
1855
            if trans_id in self._limbo_files:
 
1856
                del self._limbo_files[trans_id]
1683
1857
        self._new_contents.clear()
1684
1858
        return modified_paths
1685
1859
 
 
1860
    def _apply_observed_sha1s(self):
 
1861
        """After we have finished renaming everything, update observed sha1s
 
1862
 
 
1863
        This has to be done after self._tree.apply_inventory_delta, otherwise
 
1864
        it doesn't know anything about the files we are updating. Also, we want
 
1865
        to do this as late as possible, so that most entries end up cached.
 
1866
        """
 
1867
        # TODO: this doesn't update the stat information for directories. So
 
1868
        #       the first 'bzr status' will still need to rewrite
 
1869
        #       .bzr/checkout/dirstate. However, we at least don't need to
 
1870
        #       re-read all of the files.
 
1871
        # TODO: If the operation took a while, we could do a time.sleep(3) here
 
1872
        #       to allow the clock to tick over and ensure we won't have any
 
1873
        #       problems. (we could observe start time, and finish time, and if
 
1874
        #       it is less than eg 10% overhead, add a sleep call.)
 
1875
        paths = FinalPaths(self)
 
1876
        for trans_id, observed in self._observed_sha1s.iteritems():
 
1877
            path = paths.get_path(trans_id)
 
1878
            # We could get the file_id, but dirstate prefers to use the path
 
1879
            # anyway, and it is 'cheaper' to determine.
 
1880
            # file_id = self._new_id[trans_id]
 
1881
            self._tree._observed_sha1(None, path, observed)
 
1882
 
1686
1883
 
1687
1884
class TransformPreview(DiskTreeTransform):
1688
1885
    """A TreeTransform for generating preview trees.
1703
1900
    def tree_kind(self, trans_id):
1704
1901
        path = self._tree_id_paths.get(trans_id)
1705
1902
        if path is None:
1706
 
            raise NoSuchFile(None)
1707
 
        file_id = self._tree.path2id(path)
1708
 
        return self._tree.kind(file_id)
 
1903
            return None
 
1904
        kind = self._tree.path_content_summary(path)[0]
 
1905
        if kind == 'missing':
 
1906
            kind = None
 
1907
        return kind
1709
1908
 
1710
1909
    def _set_mode(self, trans_id, mode_id, typefunc):
1711
1910
        """Set the mode of new file contents.
1731
1930
            childpath = joinpath(path, child)
1732
1931
            yield self.trans_id_tree_path(childpath)
1733
1932
 
1734
 
 
1735
 
class _PreviewTree(tree.Tree):
 
1933
    def new_orphan(self, trans_id, parent_id):
 
1934
        raise NotImplementedError(self.new_orphan)
 
1935
 
 
1936
 
 
1937
class _PreviewTree(tree.InventoryTree):
1736
1938
    """Partial implementation of Tree to support show_diff_trees"""
1737
1939
 
1738
1940
    def __init__(self, transform):
1767
1969
                yield self._get_repository().revision_tree(revision_id)
1768
1970
 
1769
1971
    def _get_file_revision(self, file_id, vf, tree_revision):
1770
 
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
1972
        parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
1771
1973
                       self._iter_parent_trees()]
1772
1974
        vf.add_lines((file_id, tree_revision), parent_keys,
1773
 
                     self.get_file(file_id).readlines())
 
1975
                     self.get_file_lines(file_id))
1774
1976
        repo = self._get_repository()
1775
1977
        base_vf = repo.texts
1776
1978
        if base_vf not in vf.fallback_versionedfiles:
1777
1979
            vf.fallback_versionedfiles.append(base_vf)
1778
1980
        return tree_revision
1779
1981
 
1780
 
    def _stat_limbo_file(self, file_id):
1781
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
1982
    def _stat_limbo_file(self, file_id=None, trans_id=None):
 
1983
        if trans_id is None:
 
1984
            trans_id = self._transform.trans_id_file_id(file_id)
1782
1985
        name = self._transform._limbo_name(trans_id)
1783
1986
        return os.lstat(name)
1784
1987
 
1798
2001
            executable = self.is_executable(file_id, path)
1799
2002
        return kind, executable, None
1800
2003
 
 
2004
    def is_locked(self):
 
2005
        return False
 
2006
 
1801
2007
    def lock_read(self):
1802
2008
        # Perhaps in theory, this should lock the TreeTransform?
1803
 
        pass
 
2009
        return self
1804
2010
 
1805
2011
    def unlock(self):
1806
2012
        pass
1904
2110
            if (specific_file_ids is not None
1905
2111
                and file_id not in specific_file_ids):
1906
2112
                continue
1907
 
            try:
1908
 
                kind = self._transform.final_kind(trans_id)
1909
 
            except NoSuchFile:
 
2113
            kind = self._transform.final_kind(trans_id)
 
2114
            if kind is None:
1910
2115
                kind = self._transform._tree.stored_kind(file_id)
1911
2116
            new_entry = inventory.make_entry(
1912
2117
                kind,
1997
2202
 
1998
2203
    def get_file_size(self, file_id):
1999
2204
        """See Tree.get_file_size"""
 
2205
        trans_id = self._transform.trans_id_file_id(file_id)
 
2206
        kind = self._transform.final_kind(trans_id)
 
2207
        if kind != 'file':
 
2208
            return None
 
2209
        if trans_id in self._transform._new_contents:
 
2210
            return self._stat_limbo_file(trans_id=trans_id).st_size
2000
2211
        if self.kind(file_id) == 'file':
2001
2212
            return self._transform._tree.get_file_size(file_id)
2002
2213
        else:
2030
2241
            except errors.NoSuchId:
2031
2242
                return False
2032
2243
 
 
2244
    def has_filename(self, path):
 
2245
        trans_id = self._path2trans_id(path)
 
2246
        if trans_id in self._transform._new_contents:
 
2247
            return True
 
2248
        elif trans_id in self._transform._removed_contents:
 
2249
            return False
 
2250
        else:
 
2251
            return self._transform._tree.has_filename(path)
 
2252
 
2033
2253
    def path_content_summary(self, path):
2034
2254
        trans_id = self._path2trans_id(path)
2035
2255
        tt = self._transform
2123
2343
                                   self.get_file(file_id).readlines(),
2124
2344
                                   default_revision)
2125
2345
 
2126
 
    def get_symlink_target(self, file_id):
 
2346
    def get_symlink_target(self, file_id, path=None):
2127
2347
        """See Tree.get_symlink_target"""
2128
2348
        if not self._content_change(file_id):
2129
2349
            return self._transform._tree.get_symlink_target(file_id)
2144
2364
                path_from_root = self._final_paths.get_path(child_id)
2145
2365
                basename = self._transform.final_name(child_id)
2146
2366
                file_id = self._transform.final_file_id(child_id)
2147
 
                try:
2148
 
                    kind = self._transform.final_kind(child_id)
 
2367
                kind  = self._transform.final_kind(child_id)
 
2368
                if kind is not None:
2149
2369
                    versioned_kind = kind
2150
 
                except NoSuchFile:
 
2370
                else:
2151
2371
                    kind = 'unknown'
2152
2372
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2153
2373
                if versioned_kind == 'directory':
2266
2486
    for num, _unused in enumerate(wt.all_file_ids()):
2267
2487
        if num > 0:  # more than just a root
2268
2488
            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
2489
    file_trans_id = {}
2273
 
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2490
    top_pb = ui.ui_factory.nested_progress_bar()
2274
2491
    pp = ProgressPhase("Build phase", 2, top_pb)
2275
2492
    if tree.inventory.root is not None:
2276
2493
        # This is kind of a hack: we should be altering the root
2289
2506
        pp.next_phase()
2290
2507
        file_trans_id[wt.get_root_id()] = \
2291
2508
            tt.trans_id_tree_file_id(wt.get_root_id())
2292
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2509
        pb = ui.ui_factory.nested_progress_bar()
2293
2510
        try:
2294
2511
            deferred_contents = []
2295
2512
            num = 0
2298
2515
                precomputed_delta = []
2299
2516
            else:
2300
2517
                precomputed_delta = None
 
2518
            # Check if tree inventory has content. If so, we populate
 
2519
            # existing_files with the directory content. If there are no
 
2520
            # entries we skip populating existing_files as its not used.
 
2521
            # This improves performance and unncessary work on large
 
2522
            # directory trees. (#501307)
 
2523
            if total > 0:
 
2524
                existing_files = set()
 
2525
                for dir, files in wt.walkdirs():
 
2526
                    existing_files.update(f[0] for f in files)
2301
2527
            for num, (tree_path, entry) in \
2302
2528
                enumerate(tree.inventory.iter_entries_by_dir()):
2303
2529
                pb.update("Building tree", num - len(deferred_contents), total)
2333
2559
                    executable = tree.is_executable(file_id, tree_path)
2334
2560
                    if executable:
2335
2561
                        tt.set_executability(executable, trans_id)
2336
 
                    trans_data = (trans_id, tree_path)
 
2562
                    trans_data = (trans_id, tree_path, entry.text_sha1)
2337
2563
                    deferred_contents.append((file_id, trans_data))
2338
2564
                else:
2339
2565
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2355
2581
            precomputed_delta = None
2356
2582
        conflicts = cook_conflicts(raw_conflicts, tt)
2357
2583
        for conflict in conflicts:
2358
 
            warning(conflict)
 
2584
            trace.warning(unicode(conflict))
2359
2585
        try:
2360
2586
            wt.add_conflicts(conflicts)
2361
2587
        except errors.UnsupportedOperation:
2384
2610
        unchanged = dict(unchanged)
2385
2611
        new_desired_files = []
2386
2612
        count = 0
2387
 
        for file_id, (trans_id, tree_path) in desired_files:
 
2613
        for file_id, (trans_id, tree_path, text_sha1) in desired_files:
2388
2614
            accelerator_path = unchanged.get(file_id)
2389
2615
            if accelerator_path is None:
2390
 
                new_desired_files.append((file_id, (trans_id, tree_path)))
 
2616
                new_desired_files.append((file_id,
 
2617
                    (trans_id, tree_path, text_sha1)))
2391
2618
                continue
2392
2619
            pb.update('Adding file contents', count + offset, total)
2393
2620
            if hardlink:
2400
2627
                    contents = filtered_output_bytes(contents, filters,
2401
2628
                        ContentFilterContext(tree_path, tree))
2402
2629
                try:
2403
 
                    tt.create_file(contents, trans_id)
 
2630
                    tt.create_file(contents, trans_id, sha1=text_sha1)
2404
2631
                finally:
2405
2632
                    try:
2406
2633
                        contents.close()
2409
2636
                        pass
2410
2637
            count += 1
2411
2638
        offset += count
2412
 
    for count, ((trans_id, tree_path), contents) in enumerate(
 
2639
    for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
2413
2640
            tree.iter_files_bytes(new_desired_files)):
2414
2641
        if wt.supports_content_filtering():
2415
2642
            filters = wt._content_filter_stack(tree_path)
2416
2643
            contents = filtered_output_bytes(contents, filters,
2417
2644
                ContentFilterContext(tree_path, tree))
2418
 
        tt.create_file(contents, trans_id)
 
2645
        tt.create_file(contents, trans_id, sha1=text_sha1)
2419
2646
        pb.update('Adding file contents', count + offset, total)
2420
2647
 
2421
2648
 
2423
2650
    for child in tt.iter_tree_children(old_parent):
2424
2651
        tt.adjust_path(tt.final_name(child), new_parent, child)
2425
2652
 
 
2653
 
2426
2654
def _reparent_transform_children(tt, old_parent, new_parent):
2427
2655
    by_parent = tt.by_parent()
2428
2656
    for child in by_parent[old_parent]:
2429
2657
        tt.adjust_path(tt.final_name(child), new_parent, child)
2430
2658
    return by_parent[old_parent]
2431
2659
 
 
2660
 
2432
2661
def _content_match(tree, entry, file_id, kind, target_path):
2433
2662
    if entry.kind != kind:
2434
2663
        return False
2435
2664
    if entry.kind == "directory":
2436
2665
        return True
2437
2666
    if entry.kind == "file":
2438
 
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
2439
 
            return True
 
2667
        f = file(target_path, 'rb')
 
2668
        try:
 
2669
            if tree.get_file_text(file_id) == f.read():
 
2670
                return True
 
2671
        finally:
 
2672
            f.close()
2440
2673
    elif entry.kind == "symlink":
2441
2674
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2442
2675
            return True
2494
2727
        raise errors.BadFileKindError(name, kind)
2495
2728
 
2496
2729
 
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
2730
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2514
2731
    filter_tree_path=None):
2515
2732
    """Create new file contents according to tree contents.
2546
2763
        tt.set_executability(entry.executable, trans_id)
2547
2764
 
2548
2765
 
 
2766
@deprecated_function(deprecated_in((2, 3, 0)))
2549
2767
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2550
2768
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2551
2769
 
2552
2770
 
 
2771
@deprecated_function(deprecated_in((2, 3, 0)))
2553
2772
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2554
2773
    """Produce a backup-style name that appears to be available"""
2555
2774
    def name_gen():
2604
2823
                unversioned_filter=working_tree.is_ignored)
2605
2824
            delta.report_changes(tt.iter_changes(), change_reporter)
2606
2825
        for conflict in conflicts:
2607
 
            warning(conflict)
 
2826
            trace.warning(unicode(conflict))
2608
2827
        pp.next_phase()
2609
2828
        tt.apply()
2610
2829
        working_tree.set_merge_modified(merge_modified)
2618
2837
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2619
2838
                              backups, pp, basis_tree=None,
2620
2839
                              merge_modified=None):
2621
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2840
    child_pb = ui.ui_factory.nested_progress_bar()
2622
2841
    try:
2623
2842
        if merge_modified is None:
2624
2843
            merge_modified = working_tree.merge_modified()
2627
2846
                                      merge_modified, basis_tree)
2628
2847
    finally:
2629
2848
        child_pb.finished()
2630
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2849
    child_pb = ui.ui_factory.nested_progress_bar()
2631
2850
    try:
2632
2851
        raw_conflicts = resolve_conflicts(tt, child_pb,
2633
2852
            lambda t, c: conflict_pass(t, c, target_tree))
2641
2860
                 backups, merge_modified, basis_tree=None):
2642
2861
    if basis_tree is not None:
2643
2862
        basis_tree.lock_read()
2644
 
    change_list = target_tree.iter_changes(working_tree,
 
2863
    # We ask the working_tree for its changes relative to the target, rather
 
2864
    # than the target changes relative to the working tree. Because WT4 has an
 
2865
    # optimizer to compare itself to a target, but no optimizer for the
 
2866
    # reverse.
 
2867
    change_list = working_tree.iter_changes(target_tree,
2645
2868
        specific_files=specific_files, pb=pb)
2646
2869
    if target_tree.get_root_id() is None:
2647
2870
        skip_root = True
2651
2874
        deferred_files = []
2652
2875
        for id_num, (file_id, path, changed_content, versioned, parent, name,
2653
2876
                kind, executable) in enumerate(change_list):
2654
 
            if skip_root and file_id[0] is not None and parent[0] is None:
 
2877
            target_path, wt_path = path
 
2878
            target_versioned, wt_versioned = versioned
 
2879
            target_parent, wt_parent = parent
 
2880
            target_name, wt_name = name
 
2881
            target_kind, wt_kind = kind
 
2882
            target_executable, wt_executable = executable
 
2883
            if skip_root and wt_parent is None:
2655
2884
                continue
2656
2885
            trans_id = tt.trans_id_file_id(file_id)
2657
2886
            mode_id = None
2658
2887
            if changed_content:
2659
2888
                keep_content = False
2660
 
                if kind[0] == 'file' and (backups or kind[1] is None):
 
2889
                if wt_kind == 'file' and (backups or target_kind is None):
2661
2890
                    wt_sha1 = working_tree.get_file_sha1(file_id)
2662
2891
                    if merge_modified.get(file_id) != wt_sha1:
2663
2892
                        # acquire the basis tree lazily to prevent the
2669
2898
                        if file_id in basis_tree:
2670
2899
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
2671
2900
                                keep_content = True
2672
 
                        elif kind[1] is None and not versioned[1]:
 
2901
                        elif target_kind is None and not target_versioned:
2673
2902
                            keep_content = True
2674
 
                if kind[0] is not None:
 
2903
                if wt_kind is not None:
2675
2904
                    if not keep_content:
2676
2905
                        tt.delete_contents(trans_id)
2677
 
                    elif kind[1] is not None:
2678
 
                        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)
 
2906
                    elif target_kind is not None:
 
2907
                        parent_trans_id = tt.trans_id_file_id(wt_parent)
 
2908
                        backup_name = tt._available_backup_name(
 
2909
                            wt_name, parent_trans_id)
2682
2910
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2683
 
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2684
 
                        if versioned == (True, True):
 
2911
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
 
2912
                        if wt_versioned and target_versioned:
2685
2913
                            tt.unversion_file(trans_id)
2686
2914
                            tt.version_file(file_id, new_trans_id)
2687
2915
                        # New contents should have the same unix perms as old
2688
2916
                        # contents
2689
2917
                        mode_id = trans_id
2690
2918
                        trans_id = new_trans_id
2691
 
                if kind[1] in ('directory', 'tree-reference'):
 
2919
                if target_kind in ('directory', 'tree-reference'):
2692
2920
                    tt.create_directory(trans_id)
2693
 
                    if kind[1] == 'tree-reference':
 
2921
                    if target_kind == 'tree-reference':
2694
2922
                        revision = target_tree.get_reference_revision(file_id,
2695
 
                                                                      path[1])
 
2923
                                                                      target_path)
2696
2924
                        tt.set_tree_reference(revision, trans_id)
2697
 
                elif kind[1] == 'symlink':
 
2925
                elif target_kind == 'symlink':
2698
2926
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
2699
2927
                                      trans_id)
2700
 
                elif kind[1] == 'file':
 
2928
                elif target_kind == 'file':
2701
2929
                    deferred_files.append((file_id, (trans_id, mode_id)))
2702
2930
                    if basis_tree is None:
2703
2931
                        basis_tree = working_tree.basis_tree()
2711
2939
                        merge_modified[file_id] = new_sha1
2712
2940
 
2713
2941
                    # preserve the execute bit when backing up
2714
 
                    if keep_content and executable[0] == executable[1]:
2715
 
                        tt.set_executability(executable[1], trans_id)
2716
 
                elif kind[1] is not None:
2717
 
                    raise AssertionError(kind[1])
2718
 
            if versioned == (False, True):
 
2942
                    if keep_content and wt_executable == target_executable:
 
2943
                        tt.set_executability(target_executable, trans_id)
 
2944
                elif target_kind is not None:
 
2945
                    raise AssertionError(target_kind)
 
2946
            if not wt_versioned and target_versioned:
2719
2947
                tt.version_file(file_id, trans_id)
2720
 
            if versioned == (True, False):
 
2948
            if wt_versioned and not target_versioned:
2721
2949
                tt.unversion_file(trans_id)
2722
 
            if (name[1] is not None and
2723
 
                (name[0] != name[1] or parent[0] != parent[1])):
2724
 
                if name[1] == '' and parent[1] is None:
 
2950
            if (target_name is not None and
 
2951
                (wt_name != target_name or wt_parent != target_parent)):
 
2952
                if target_name == '' and target_parent is None:
2725
2953
                    parent_trans = ROOT_PARENT
2726
2954
                else:
2727
 
                    parent_trans = tt.trans_id_file_id(parent[1])
2728
 
                if parent[0] is None and versioned[0]:
2729
 
                    tt.adjust_root_path(name[1], parent_trans)
 
2955
                    parent_trans = tt.trans_id_file_id(target_parent)
 
2956
                if wt_parent is None and wt_versioned:
 
2957
                    tt.adjust_root_path(target_name, parent_trans)
2730
2958
                else:
2731
 
                    tt.adjust_path(name[1], parent_trans, trans_id)
2732
 
            if executable[0] != executable[1] and kind[1] == "file":
2733
 
                tt.set_executability(executable[1], trans_id)
 
2959
                    tt.adjust_path(target_name, parent_trans, trans_id)
 
2960
            if wt_executable != target_executable and target_kind == "file":
 
2961
                tt.set_executability(target_executable, trans_id)
2734
2962
        if working_tree.supports_content_filtering():
2735
2963
            for index, ((trans_id, mode_id), bytes) in enumerate(
2736
2964
                target_tree.iter_files_bytes(deferred_files)):
2807
3035
 
2808
3036
        elif c_type == 'missing parent':
2809
3037
            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:
 
3038
            if trans_id in tt._removed_contents:
 
3039
                cancel_deletion = True
 
3040
                orphans = tt._get_potential_orphans(trans_id)
 
3041
                if orphans:
 
3042
                    cancel_deletion = False
 
3043
                    # All children are orphans
 
3044
                    for o in orphans:
 
3045
                        try:
 
3046
                            tt.new_orphan(o, trans_id)
 
3047
                        except OrphaningError:
 
3048
                            # Something bad happened so we cancel the directory
 
3049
                            # deletion which will leave it in place with a
 
3050
                            # conflict. The user can deal with it from there.
 
3051
                            # Note that this also catch the case where we don't
 
3052
                            # want to create orphans and leave the directory in
 
3053
                            # place.
 
3054
                            cancel_deletion = True
 
3055
                            break
 
3056
                if cancel_deletion:
 
3057
                    # Cancel the directory deletion
 
3058
                    tt.cancel_deletion(trans_id)
 
3059
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
3060
                                       trans_id))
 
3061
            else:
2815
3062
                create = True
2816
3063
                try:
2817
3064
                    tt.final_name(trans_id)
2820
3067
                        file_id = tt.final_file_id(trans_id)
2821
3068
                        if file_id is None:
2822
3069
                            file_id = tt.inactive_file_id(trans_id)
2823
 
                        entry = path_tree.inventory[file_id]
 
3070
                        _, entry = path_tree.iter_entries_by_dir(
 
3071
                            [file_id]).next()
2824
3072
                        # special-case the other tree root (move its
2825
3073
                        # children to current root)
2826
3074
                        if entry.parent_id is None:
2842
3090
            file_id = tt.inactive_file_id(conflict[1])
2843
3091
            # special-case the other tree root (move its children instead)
2844
3092
            if path_tree and file_id in path_tree:
2845
 
                if path_tree.inventory[file_id].parent_id is None:
 
3093
                if path_tree.path2id('') == file_id:
 
3094
                    # This is the root entry, skip it
2846
3095
                    continue
2847
3096
            tt.version_file(file_id, conflict[1])
2848
3097
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2900
3149
    def rename(self, from_, to):
2901
3150
        """Rename a file from one path to another."""
2902
3151
        try:
2903
 
            osutils.rename(from_, to)
 
3152
            os.rename(from_, to)
2904
3153
        except OSError, e:
2905
3154
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2906
3155
                raise errors.FileExists(to, str(e))
2907
 
            raise
 
3156
            # normal OSError doesn't include filenames so it's hard to see where
 
3157
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
 
3158
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
2908
3159
        self.past_renames.append((from_, to))
2909
3160
 
2910
3161
    def pre_delete(self, from_, to):
2920
3171
    def rollback(self):
2921
3172
        """Reverse all renames that have been performed"""
2922
3173
        for from_, to in reversed(self.past_renames):
2923
 
            osutils.rename(to, from_)
 
3174
            try:
 
3175
                os.rename(to, from_)
 
3176
            except OSError, e:
 
3177
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2924
3178
        # after rollback, don't reuse _FileMover
2925
3179
        past_renames = None
2926
3180
        pending_deletions = None