/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: Martin Pool
  • Date: 2011-06-28 13:55:39 UTC
  • mfrom: (5995 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5996.
  • Revision ID: mbp@canonical.com-20110628135539-6541falwx39fl46i
merge news

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,
 
35
    conflicts,
28
36
    delta,
29
37
    errors,
30
38
    inventory,
32
40
    osutils,
33
41
    revision as _mod_revision,
34
42
    ui,
 
43
    urlutils,
35
44
    )
36
45
""")
37
46
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
39
48
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
40
49
                           UnableCreateSymlink)
41
50
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
42
 
from bzrlib.inventory import InventoryEntry
43
51
from bzrlib.osutils import (
44
52
    delete_any,
45
53
    file_kind,
46
54
    has_symlinks,
47
 
    lexists,
48
55
    pathjoin,
49
56
    sha_file,
50
57
    splitpath,
51
58
    supports_executable,
52
 
)
 
59
    )
53
60
from bzrlib.progress import ProgressPhase
54
61
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
 
62
    deprecated_function,
 
63
    deprecated_in,
 
64
    deprecated_method,
 
65
    )
62
66
 
63
67
 
64
68
ROOT_PARENT = "root-parent"
65
69
 
66
 
 
67
70
def unique_add(map, key, value):
68
71
    if key in map:
69
72
        raise DuplicateKey(key=key)
70
73
    map[key] = value
71
74
 
72
75
 
 
76
 
73
77
class _TransformResults(object):
74
78
    def __init__(self, modified_paths, rename_count):
75
79
        object.__init__(self)
99
103
        self._new_parent = {}
100
104
        # mapping of trans_id with new contents -> new file_kind
101
105
        self._new_contents = {}
 
106
        # mapping of trans_id => (sha1 of content, stat_value)
 
107
        self._observed_sha1s = {}
102
108
        # Set of trans_ids whose contents will be removed
103
109
        self._removed_contents = set()
104
110
        # Mapping of trans_id -> new execute-bit value
123
129
            self._new_root = self.trans_id_tree_file_id(root_id)
124
130
        else:
125
131
            self._new_root = None
126
 
        # Indictor of whether the transform has been applied
 
132
        # Indicator of whether the transform has been applied
127
133
        self._done = False
128
134
        # A progress bar
129
135
        self._pb = pb
132
138
        # A counter of how many files have been renamed
133
139
        self.rename_count = 0
134
140
 
 
141
    def __enter__(self):
 
142
        """Support Context Manager API."""
 
143
        return self
 
144
 
 
145
    def __exit__(self, exc_type, exc_val, exc_tb):
 
146
        """Support Context Manager API."""
 
147
        self.finalize()
 
148
 
135
149
    def finalize(self):
136
150
        """Release the working tree lock, if held.
137
151
 
239
253
        if (self.tree_file_id(self._new_root) is not None and
240
254
            self._new_root not in self._removed_id):
241
255
            self.unversion_file(self._new_root)
242
 
        self.version_file(file_id, self._new_root)
 
256
        if file_id is not None:
 
257
            self.version_file(file_id, self._new_root)
243
258
 
244
259
        # Now move children of new root into old root directory.
245
260
        # Ensure all children are registered with the transaction, but don't
314
329
 
315
330
    def delete_contents(self, trans_id):
316
331
        """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)
 
332
        kind = self.tree_kind(trans_id)
 
333
        if kind is not None:
 
334
            self._removed_contents.add(trans_id)
321
335
 
322
336
    def cancel_deletion(self, trans_id):
323
337
        """Cancel a scheduled deletion"""
380
394
        return sorted(FinalPaths(self).get_paths(new_ids))
381
395
 
382
396
    def _inventory_altered(self):
383
 
        """Get the trans_ids and paths of files needing new inv entries."""
384
 
        new_ids = set()
385
 
        for id_set in [self._new_name, self._new_parent, self._new_id,
 
397
        """Determine which trans_ids need new Inventory entries.
 
398
 
 
399
        An new entry is needed when anything that would be reflected by an
 
400
        inventory entry changes, including file name, file_id, parent file_id,
 
401
        file kind, and the execute bit.
 
402
 
 
403
        Some care is taken to return entries with real changes, not cases
 
404
        where the value is deleted and then restored to its original value,
 
405
        but some actually unchanged values may be returned.
 
406
 
 
407
        :returns: A list of (path, trans_id) for all items requiring an
 
408
            inventory change. Ordered by path.
 
409
        """
 
410
        changed_ids = set()
 
411
        # Find entries whose file_ids are new (or changed).
 
412
        new_file_id = set(t for t in self._new_id
 
413
                          if self._new_id[t] != self.tree_file_id(t))
 
414
        for id_set in [self._new_name, self._new_parent, new_file_id,
386
415
                       self._new_executability]:
387
 
            new_ids.update(id_set)
 
416
            changed_ids.update(id_set)
 
417
        # removing implies a kind change
388
418
        changed_kind = set(self._removed_contents)
 
419
        # so does adding
389
420
        changed_kind.intersection_update(self._new_contents)
390
 
        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
 
        new_ids.update(changed_kind)
394
 
        return sorted(FinalPaths(self).get_paths(new_ids))
 
421
        # Ignore entries that are already known to have changed.
 
422
        changed_kind.difference_update(changed_ids)
 
423
        #  to keep only the truly changed ones
 
424
        changed_kind = (t for t in changed_kind
 
425
                        if self.tree_kind(t) != self.final_kind(t))
 
426
        # all kind changes will alter the inventory
 
427
        changed_ids.update(changed_kind)
 
428
        # To find entries with changed parent_ids, find parents which existed,
 
429
        # but changed file_id.
 
430
        changed_file_id = set(t for t in new_file_id if t in self._removed_id)
 
431
        # Now add all their children to the set.
 
432
        for parent_trans_id in new_file_id:
 
433
            changed_ids.update(self.iter_tree_children(parent_trans_id))
 
434
        return sorted(FinalPaths(self).get_paths(changed_ids))
395
435
 
396
436
    def final_kind(self, trans_id):
397
437
        """Determine the final file kind, after any changes applied.
398
438
 
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)
 
439
        :return: None if the file does not exist/has no contents.  (It is
 
440
            conceivable that a path would be created without the corresponding
 
441
            contents insertion command)
402
442
        """
403
443
        if trans_id in self._new_contents:
404
444
            return self._new_contents[trans_id]
405
445
        elif trans_id in self._removed_contents:
406
 
            raise NoSuchFile(None)
 
446
            return None
407
447
        else:
408
448
            return self.tree_kind(trans_id)
409
449
 
522
562
        for trans_id in self._removed_id:
523
563
            file_id = self.tree_file_id(trans_id)
524
564
            if file_id is not None:
 
565
                # XXX: This seems like something that should go via a different
 
566
                #      indirection.
525
567
                if self._tree.inventory[file_id].kind == 'directory':
526
568
                    parents.append(trans_id)
527
569
            elif self.tree_kind(trans_id) == 'directory':
531
573
            # ensure that all children are registered with the transaction
532
574
            list(self.iter_tree_children(parent_id))
533
575
 
 
576
    @deprecated_method(deprecated_in((2, 3, 0)))
534
577
    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:
 
578
        return self._has_named_child(
 
579
            name, parent_id, known_children=by_parent.get(parent_id, []))
 
580
 
 
581
    def _has_named_child(self, name, parent_id, known_children):
 
582
        """Does a parent already have a name child.
 
583
 
 
584
        :param name: The searched for name.
 
585
 
 
586
        :param parent_id: The parent for which the check is made.
 
587
 
 
588
        :param known_children: The already known children. This should have
 
589
            been recently obtained from `self.by_parent.get(parent_id)`
 
590
            (or will be if None is passed).
 
591
        """
 
592
        if known_children is None:
 
593
            known_children = self.by_parent().get(parent_id, [])
 
594
        for child in known_children:
540
595
            if self.final_name(child) == name:
541
596
                return True
542
 
        try:
543
 
            path = self._tree_id_paths[parent_id]
544
 
        except KeyError:
 
597
        parent_path = self._tree_id_paths.get(parent_id, None)
 
598
        if parent_path is None:
 
599
            # No parent... no children
545
600
            return False
546
 
        childpath = joinpath(path, name)
547
 
        child_id = self._tree_path_ids.get(childpath)
 
601
        child_path = joinpath(parent_path, name)
 
602
        child_id = self._tree_path_ids.get(child_path, None)
548
603
        if child_id is None:
549
 
            return lexists(self._tree.abspath(childpath))
 
604
            # Not known by the tree transform yet, check the filesystem
 
605
            return osutils.lexists(self._tree.abspath(child_path))
550
606
        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
 
607
            raise AssertionError('child_id is missing: %s, %s, %s'
 
608
                                 % (name, parent_id, child_id))
 
609
 
 
610
    def _available_backup_name(self, name, target_id):
 
611
        """Find an available backup name.
 
612
 
 
613
        :param name: The basename of the file.
 
614
 
 
615
        :param target_id: The directory trans_id where the backup should 
 
616
            be placed.
 
617
        """
 
618
        known_children = self.by_parent().get(target_id, [])
 
619
        return osutils.available_backup_name(
 
620
            name,
 
621
            lambda base: self._has_named_child(
 
622
                base, target_id, known_children))
558
623
 
559
624
    def _parent_loops(self):
560
625
        """No entry should be its own ancestor"""
595
660
        """
596
661
        conflicts = []
597
662
        for trans_id in self._new_id.iterkeys():
598
 
            try:
599
 
                kind = self.final_kind(trans_id)
600
 
            except NoSuchFile:
 
663
            kind = self.final_kind(trans_id)
 
664
            if kind is None:
601
665
                conflicts.append(('versioning no contents', trans_id))
602
666
                continue
603
 
            if not InventoryEntry.versionable_kind(kind):
 
667
            if not inventory.InventoryEntry.versionable_kind(kind):
604
668
                conflicts.append(('versioning bad kind', trans_id, kind))
605
669
        return conflicts
606
670
 
617
681
            if self.final_file_id(trans_id) is None:
618
682
                conflicts.append(('unversioned executability', trans_id))
619
683
            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:
 
684
                if self.final_kind(trans_id) != "file":
625
685
                    conflicts.append(('non-file executability', trans_id))
626
686
        return conflicts
627
687
 
629
689
        """Check for overwrites (not permitted on Win32)"""
630
690
        conflicts = []
631
691
        for trans_id in self._new_contents:
632
 
            try:
633
 
                self.tree_kind(trans_id)
634
 
            except NoSuchFile:
 
692
            if self.tree_kind(trans_id) is None:
635
693
                continue
636
694
            if trans_id not in self._removed_contents:
637
695
                conflicts.append(('overwrite', trans_id,
644
702
        if (self._new_name, self._new_parent) == ({}, {}):
645
703
            return conflicts
646
704
        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]
 
705
            name_ids = []
 
706
            for child_tid in children:
 
707
                name = self.final_name(child_tid)
 
708
                if name is not None:
 
709
                    # Keep children only if they still exist in the end
 
710
                    if not self._case_sensitive_target:
 
711
                        name = name.lower()
 
712
                    name_ids.append((name, child_tid))
650
713
            name_ids.sort()
651
714
            last_name = None
652
715
            last_trans_id = None
653
716
            for name, trans_id in name_ids:
654
 
                try:
655
 
                    kind = self.final_kind(trans_id)
656
 
                except NoSuchFile:
657
 
                    kind = None
 
717
                kind = self.final_kind(trans_id)
658
718
                file_id = self.final_file_id(trans_id)
659
719
                if kind is None and file_id is None:
660
720
                    continue
679
739
        return conflicts
680
740
 
681
741
    def _parent_type_conflicts(self, by_parent):
682
 
        """parents must have directory 'contents'."""
 
742
        """Children must have a directory parent"""
683
743
        conflicts = []
684
744
        for parent_id, children in by_parent.iteritems():
685
745
            if parent_id is ROOT_PARENT:
686
746
                continue
687
 
            if not self._any_contents(children):
 
747
            no_children = True
 
748
            for child_id in children:
 
749
                if self.final_kind(child_id) is not None:
 
750
                    no_children = False
 
751
                    break
 
752
            if no_children:
688
753
                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
 
754
            # There is at least a child, so we need an existing directory to
 
755
            # contain it.
 
756
            kind = self.final_kind(parent_id)
698
757
            if kind is None:
 
758
                # The directory will be deleted
699
759
                conflicts.append(('missing parent', parent_id))
700
760
            elif kind != "directory":
 
761
                # Meh, we need a *directory* to put something in it
701
762
                conflicts.append(('non-directory parent', parent_id))
702
763
        return conflicts
703
764
 
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
765
    def _set_executability(self, path, trans_id):
715
766
        """Set the executability of versioned files """
716
767
        if supports_executable():
738
789
        return trans_id
739
790
 
740
791
    def new_file(self, name, parent_id, contents, file_id=None,
741
 
                 executable=None):
 
792
                 executable=None, sha1=None):
742
793
        """Convenience method to create files.
743
794
 
744
795
        name is the name of the file to create.
751
802
        trans_id = self._new_entry(name, parent_id, file_id)
752
803
        # TODO: rather than scheduling a set_executable call,
753
804
        # have create_file create the file with the right mode.
754
 
        self.create_file(contents, trans_id)
 
805
        self.create_file(contents, trans_id, sha1=sha1)
755
806
        if executable is not None:
756
807
            self.set_executability(executable, trans_id)
757
808
        return trans_id
780
831
        self.create_symlink(target, trans_id)
781
832
        return trans_id
782
833
 
 
834
    def new_orphan(self, trans_id, parent_id):
 
835
        """Schedule an item to be orphaned.
 
836
 
 
837
        When a directory is about to be removed, its children, if they are not
 
838
        versioned are moved out of the way: they don't have a parent anymore.
 
839
 
 
840
        :param trans_id: The trans_id of the existing item.
 
841
        :param parent_id: The parent trans_id of the item.
 
842
        """
 
843
        raise NotImplementedError(self.new_orphan)
 
844
 
 
845
    def _get_potential_orphans(self, dir_id):
 
846
        """Find the potential orphans in a directory.
 
847
 
 
848
        A directory can't be safely deleted if there are versioned files in it.
 
849
        If all the contained files are unversioned then they can be orphaned.
 
850
 
 
851
        The 'None' return value means that the directory contains at least one
 
852
        versioned file and should not be deleted.
 
853
 
 
854
        :param dir_id: The directory trans id.
 
855
 
 
856
        :return: A list of the orphan trans ids or None if at least one
 
857
             versioned file is present.
 
858
        """
 
859
        orphans = []
 
860
        # Find the potential orphans, stop if one item should be kept
 
861
        for child_tid in self.by_parent()[dir_id]:
 
862
            if child_tid in self._removed_contents:
 
863
                # The child is removed as part of the transform. Since it was
 
864
                # versioned before, it's not an orphan
 
865
                continue
 
866
            elif self.final_file_id(child_tid) is None:
 
867
                # The child is not versioned
 
868
                orphans.append(child_tid)
 
869
            else:
 
870
                # We have a versioned file here, searching for orphans is
 
871
                # meaningless.
 
872
                orphans = None
 
873
                break
 
874
        return orphans
 
875
 
783
876
    def _affected_ids(self):
784
877
        """Return the set of transform ids affected by the transform"""
785
878
        trans_ids = set(self._removed_id)
844
937
        Return a (name, parent, kind, executable) tuple
845
938
        """
846
939
        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
 
940
        to_kind = self.final_kind(to_trans_id)
851
941
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
852
942
        if to_trans_id in self._new_executability:
853
943
            to_executable = self._new_executability[to_trans_id]
927
1017
        """
928
1018
        return _PreviewTree(self)
929
1019
 
930
 
    def commit(self, branch, message, merge_parents=None, strict=False):
 
1020
    def commit(self, branch, message, merge_parents=None, strict=False,
 
1021
               timestamp=None, timezone=None, committer=None, authors=None,
 
1022
               revprops=None, revision_id=None):
931
1023
        """Commit the result of this TreeTransform to a branch.
932
1024
 
933
1025
        :param branch: The branch to commit to.
934
1026
        :param message: The message to attach to the commit.
935
 
        :param merge_parents: Additional parents specified by pending merges.
 
1027
        :param merge_parents: Additional parent revision-ids specified by
 
1028
            pending merges.
 
1029
        :param strict: If True, abort the commit if there are unversioned
 
1030
            files.
 
1031
        :param timestamp: if not None, seconds-since-epoch for the time and
 
1032
            date.  (May be a float.)
 
1033
        :param timezone: Optional timezone for timestamp, as an offset in
 
1034
            seconds.
 
1035
        :param committer: Optional committer in email-id format.
 
1036
            (e.g. "J Random Hacker <jrandom@example.com>")
 
1037
        :param authors: Optional list of authors in email-id format.
 
1038
        :param revprops: Optional dictionary of revision properties.
 
1039
        :param revision_id: Optional revision id.  (Specifying a revision-id
 
1040
            may reduce performance for some non-native formats.)
936
1041
        :return: The revision_id of the revision committed.
937
1042
        """
938
1043
        self._check_malformed()
955
1060
        if self._tree.get_revision_id() != last_rev_id:
956
1061
            raise ValueError('TreeTransform not based on branch basis: %s' %
957
1062
                             self._tree.get_revision_id())
958
 
        builder = branch.get_commit_builder(parent_ids)
 
1063
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1064
        builder = branch.get_commit_builder(parent_ids,
 
1065
                                            timestamp=timestamp,
 
1066
                                            timezone=timezone,
 
1067
                                            committer=committer,
 
1068
                                            revprops=revprops,
 
1069
                                            revision_id=revision_id)
959
1070
        preview = self.get_preview_tree()
960
1071
        list(builder.record_iter_changes(preview, last_rev_id,
961
1072
                                         self.iter_changes()))
1079
1190
        self._deletiondir = None
1080
1191
        # A mapping of transform ids to their limbo filename
1081
1192
        self._limbo_files = {}
 
1193
        self._possibly_stale_limbo_files = set()
1082
1194
        # A mapping of transform ids to a set of the transform ids of children
1083
1195
        # that their limbo directory has
1084
1196
        self._limbo_children = {}
1097
1209
        if self._tree is None:
1098
1210
            return
1099
1211
        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)
 
1212
            limbo_paths = self._limbo_files.values() + list(
 
1213
                self._possibly_stale_limbo_files)
 
1214
            limbo_paths = sorted(limbo_paths, reverse=True)
 
1215
            for path in limbo_paths:
 
1216
                try:
 
1217
                    delete_any(path)
 
1218
                except OSError, e:
 
1219
                    if e.errno != errno.ENOENT:
 
1220
                        raise
 
1221
                    # XXX: warn? perhaps we just got interrupted at an
 
1222
                    # inconvenient moment, but perhaps files are disappearing
 
1223
                    # from under us?
1105
1224
            try:
1106
1225
                delete_any(self._limbodir)
1107
1226
            except OSError:
1156
1275
        entries from _limbo_files, because they are now stale.
1157
1276
        """
1158
1277
        for trans_id in trans_ids:
1159
 
            old_path = self._limbo_files.pop(trans_id)
 
1278
            old_path = self._limbo_files[trans_id]
 
1279
            self._possibly_stale_limbo_files.add(old_path)
 
1280
            del self._limbo_files[trans_id]
1160
1281
            if trans_id not in self._new_contents:
1161
1282
                continue
1162
1283
            new_path = self._limbo_name(trans_id)
1163
 
            osutils.rename(old_path, new_path)
 
1284
            os.rename(old_path, new_path)
 
1285
            self._possibly_stale_limbo_files.remove(old_path)
1164
1286
            for descendant in self._limbo_descendants(trans_id):
1165
1287
                desc_path = self._limbo_files[descendant]
1166
1288
                desc_path = new_path + desc_path[len(old_path):]
1173
1295
            descendants.update(self._limbo_descendants(descendant))
1174
1296
        return descendants
1175
1297
 
1176
 
    def create_file(self, contents, trans_id, mode_id=None):
 
1298
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
1177
1299
        """Schedule creation of a new file.
1178
1300
 
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.
 
1301
        :seealso: new_file.
 
1302
 
 
1303
        :param contents: an iterator of strings, all of which will be written
 
1304
            to the target destination.
 
1305
        :param trans_id: TreeTransform handle
 
1306
        :param mode_id: If not None, force the mode of the target file to match
 
1307
            the mode of the object referenced by mode_id.
 
1308
            Otherwise, we will try to preserve mode bits of an existing file.
 
1309
        :param sha1: If the sha1 of this content is already known, pass it in.
 
1310
            We can use it to prevent future sha1 computations.
1186
1311
        """
1187
1312
        name = self._limbo_name(trans_id)
1188
1313
        f = open(name, 'wb')
1189
1314
        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
 
 
 
1315
            unique_add(self._new_contents, trans_id, 'file')
1199
1316
            f.writelines(contents)
1200
1317
        finally:
1201
1318
            f.close()
1202
1319
        self._set_mtime(name)
1203
1320
        self._set_mode(trans_id, mode_id, S_ISREG)
 
1321
        # It is unfortunate we have to use lstat instead of fstat, but we just
 
1322
        # used utime and chmod on the file, so we need the accurate final
 
1323
        # details.
 
1324
        if sha1 is not None:
 
1325
            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
1204
1326
 
1205
1327
    def _read_file_chunks(self, trans_id):
1206
1328
        cur_file = open(self._limbo_name(trans_id), 'rb')
1265
1387
    def cancel_creation(self, trans_id):
1266
1388
        """Cancel the creation of new file contents."""
1267
1389
        del self._new_contents[trans_id]
 
1390
        if trans_id in self._observed_sha1s:
 
1391
            del self._observed_sha1s[trans_id]
1268
1392
        children = self._limbo_children.get(trans_id)
1269
1393
        # if this is a limbo directory with children, move them before removing
1270
1394
        # the directory
1274
1398
            del self._limbo_children_names[trans_id]
1275
1399
        delete_any(self._limbo_name(trans_id))
1276
1400
 
 
1401
    def new_orphan(self, trans_id, parent_id):
 
1402
        # FIXME: There is no tree config, so we use the branch one (it's weird
 
1403
        # to define it this way as orphaning can only occur in a working tree,
 
1404
        # but that's all we have (for now). It will find the option in
 
1405
        # locations.conf or bazaar.conf though) -- vila 20100916
 
1406
        conf = self._tree.branch.get_config()
 
1407
        conf_var_name = 'bzr.transform.orphan_policy'
 
1408
        orphan_policy = conf.get_user_option(conf_var_name)
 
1409
        default_policy = orphaning_registry.default_key
 
1410
        if orphan_policy is None:
 
1411
            orphan_policy = default_policy
 
1412
        if orphan_policy not in orphaning_registry:
 
1413
            trace.warning('%s (from %s) is not a known policy, defaulting '
 
1414
                'to %s' % (orphan_policy, conf_var_name, default_policy))
 
1415
            orphan_policy = default_policy
 
1416
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1417
        handle_orphan(self, trans_id, parent_id)
 
1418
 
 
1419
 
 
1420
class OrphaningError(errors.BzrError):
 
1421
 
 
1422
    # Only bugs could lead to such exception being seen by the user
 
1423
    internal_error = True
 
1424
    _fmt = "Error while orphaning %s in %s directory"
 
1425
 
 
1426
    def __init__(self, orphan, parent):
 
1427
        errors.BzrError.__init__(self)
 
1428
        self.orphan = orphan
 
1429
        self.parent = parent
 
1430
 
 
1431
 
 
1432
class OrphaningForbidden(OrphaningError):
 
1433
 
 
1434
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1435
 
 
1436
    def __init__(self, policy):
 
1437
        errors.BzrError.__init__(self)
 
1438
        self.policy = policy
 
1439
 
 
1440
 
 
1441
def move_orphan(tt, orphan_id, parent_id):
 
1442
    """See TreeTransformBase.new_orphan.
 
1443
 
 
1444
    This creates a new orphan in the `bzr-orphans` dir at the root of the
 
1445
    `TreeTransform`.
 
1446
 
 
1447
    :param tt: The TreeTransform orphaning `trans_id`.
 
1448
 
 
1449
    :param orphan_id: The trans id that should be orphaned.
 
1450
 
 
1451
    :param parent_id: The orphan parent trans id.
 
1452
    """
 
1453
    # Add the orphan dir if it doesn't exist
 
1454
    orphan_dir_basename = 'bzr-orphans'
 
1455
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1456
    if tt.final_kind(od_id) is None:
 
1457
        tt.create_directory(od_id)
 
1458
    parent_path = tt._tree_id_paths[parent_id]
 
1459
    # Find a name that doesn't exist yet in the orphan dir
 
1460
    actual_name = tt.final_name(orphan_id)
 
1461
    new_name = tt._available_backup_name(actual_name, od_id)
 
1462
    tt.adjust_path(new_name, od_id, orphan_id)
 
1463
    trace.warning('%s has been orphaned in %s'
 
1464
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1465
 
 
1466
 
 
1467
def refuse_orphan(tt, orphan_id, parent_id):
 
1468
    """See TreeTransformBase.new_orphan.
 
1469
 
 
1470
    This refuses to create orphan, letting the caller handle the conflict.
 
1471
    """
 
1472
    raise OrphaningForbidden('never')
 
1473
 
 
1474
 
 
1475
orphaning_registry = registry.Registry()
 
1476
orphaning_registry.register(
 
1477
    'conflict', refuse_orphan,
 
1478
    'Leave orphans in place and create a conflict on the directory.')
 
1479
orphaning_registry.register(
 
1480
    'move', move_orphan,
 
1481
    'Move orphans into the bzr-orphans directory.')
 
1482
orphaning_registry._set_default_key('conflict')
 
1483
 
1277
1484
 
1278
1485
class TreeTransform(DiskTreeTransform):
1279
1486
    """Represent a tree transformation.
1397
1604
    def tree_kind(self, trans_id):
1398
1605
        """Determine the file kind in the working tree.
1399
1606
 
1400
 
        Raises NoSuchFile if the file does not exist
 
1607
        :returns: The file kind or None if the file does not exist
1401
1608
        """
1402
1609
        path = self._tree_id_paths.get(trans_id)
1403
1610
        if path is None:
1404
 
            raise NoSuchFile(None)
 
1611
            return None
1405
1612
        try:
1406
1613
            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)
 
1614
        except errors.NoSuchFile:
 
1615
            return None
1412
1616
 
1413
1617
    def _set_mode(self, trans_id, mode_id, typefunc):
1414
1618
        """Set the mode of new file contents.
1520
1724
        """
1521
1725
        if not no_conflicts:
1522
1726
            self._check_malformed()
1523
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1727
        child_pb = ui.ui_factory.nested_progress_bar()
1524
1728
        try:
1525
1729
            if precomputed_delta is None:
1526
1730
                child_pb.update('Apply phase', 0, 2)
1546
1750
        finally:
1547
1751
            child_pb.finished()
1548
1752
        self._tree.apply_inventory_delta(inventory_delta)
 
1753
        self._apply_observed_sha1s()
1549
1754
        self._done = True
1550
1755
        self.finalize()
1551
1756
        return _TransformResults(modified_paths, self.rename_count)
1553
1758
    def _generate_inventory_delta(self):
1554
1759
        """Generate an inventory delta for the current transform."""
1555
1760
        inventory_delta = []
1556
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1761
        child_pb = ui.ui_factory.nested_progress_bar()
1557
1762
        new_paths = self._inventory_altered()
1558
1763
        total_entries = len(new_paths) + len(self._removed_id)
1559
1764
        try:
1583
1788
                if file_id is None:
1584
1789
                    continue
1585
1790
                needs_entry = False
1586
 
                try:
1587
 
                    kind = self.final_kind(trans_id)
1588
 
                except NoSuchFile:
 
1791
                kind = self.final_kind(trans_id)
 
1792
                if kind is None:
1589
1793
                    kind = self._tree.stored_kind(file_id)
1590
1794
                parent_trans_id = self.final_parent(trans_id)
1591
1795
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1622
1826
        """
1623
1827
        tree_paths = list(self._tree_path_ids.iteritems())
1624
1828
        tree_paths.sort(reverse=True)
1625
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1829
        child_pb = ui.ui_factory.nested_progress_bar()
1626
1830
        try:
1627
 
            for num, data in enumerate(tree_paths):
1628
 
                path, trans_id = data
 
1831
            for num, (path, trans_id) in enumerate(tree_paths):
 
1832
                # do not attempt to move root into a subdirectory of itself.
 
1833
                if path == '':
 
1834
                    continue
1629
1835
                child_pb.update('removing file', num, len(tree_paths))
1630
1836
                full_path = self._tree.abspath(path)
1631
1837
                if trans_id in self._removed_contents:
1635
1841
                      or trans_id in self._new_parent):
1636
1842
                    try:
1637
1843
                        mover.rename(full_path, self._limbo_name(trans_id))
1638
 
                    except OSError, e:
 
1844
                    except errors.TransformRenameFailed, e:
1639
1845
                        if e.errno != errno.ENOENT:
1640
1846
                            raise
1641
1847
                    else:
1657
1863
        modified_paths = []
1658
1864
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1659
1865
                                 new_paths)
1660
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1866
        child_pb = ui.ui_factory.nested_progress_bar()
1661
1867
        try:
1662
1868
            for num, (path, trans_id) in enumerate(new_paths):
1663
1869
                if (num % 10) == 0:
1666
1872
                if trans_id in self._needs_rename:
1667
1873
                    try:
1668
1874
                        mover.rename(self._limbo_name(trans_id), full_path)
1669
 
                    except OSError, e:
 
1875
                    except errors.TransformRenameFailed, e:
1670
1876
                        # We may be renaming a dangling inventory id
1671
1877
                        if e.errno != errno.ENOENT:
1672
1878
                            raise
1673
1879
                    else:
1674
1880
                        self.rename_count += 1
 
1881
                    # TODO: if trans_id in self._observed_sha1s, we should
 
1882
                    #       re-stat the final target, since ctime will be
 
1883
                    #       updated by the change.
1675
1884
                if (trans_id in self._new_contents or
1676
1885
                    self.path_changed(trans_id)):
1677
1886
                    if trans_id in self._new_contents:
1678
1887
                        modified_paths.append(full_path)
1679
1888
                if trans_id in self._new_executability:
1680
1889
                    self._set_executability(path, trans_id)
 
1890
                if trans_id in self._observed_sha1s:
 
1891
                    o_sha1, o_st_val = self._observed_sha1s[trans_id]
 
1892
                    st = osutils.lstat(full_path)
 
1893
                    self._observed_sha1s[trans_id] = (o_sha1, st)
1681
1894
        finally:
1682
1895
            child_pb.finished()
 
1896
        for path, trans_id in new_paths:
 
1897
            # new_paths includes stuff like workingtree conflicts. Only the
 
1898
            # stuff in new_contents actually comes from limbo.
 
1899
            if trans_id in self._limbo_files:
 
1900
                del self._limbo_files[trans_id]
1683
1901
        self._new_contents.clear()
1684
1902
        return modified_paths
1685
1903
 
 
1904
    def _apply_observed_sha1s(self):
 
1905
        """After we have finished renaming everything, update observed sha1s
 
1906
 
 
1907
        This has to be done after self._tree.apply_inventory_delta, otherwise
 
1908
        it doesn't know anything about the files we are updating. Also, we want
 
1909
        to do this as late as possible, so that most entries end up cached.
 
1910
        """
 
1911
        # TODO: this doesn't update the stat information for directories. So
 
1912
        #       the first 'bzr status' will still need to rewrite
 
1913
        #       .bzr/checkout/dirstate. However, we at least don't need to
 
1914
        #       re-read all of the files.
 
1915
        # TODO: If the operation took a while, we could do a time.sleep(3) here
 
1916
        #       to allow the clock to tick over and ensure we won't have any
 
1917
        #       problems. (we could observe start time, and finish time, and if
 
1918
        #       it is less than eg 10% overhead, add a sleep call.)
 
1919
        paths = FinalPaths(self)
 
1920
        for trans_id, observed in self._observed_sha1s.iteritems():
 
1921
            path = paths.get_path(trans_id)
 
1922
            # We could get the file_id, but dirstate prefers to use the path
 
1923
            # anyway, and it is 'cheaper' to determine.
 
1924
            # file_id = self._new_id[trans_id]
 
1925
            self._tree._observed_sha1(None, path, observed)
 
1926
 
1686
1927
 
1687
1928
class TransformPreview(DiskTreeTransform):
1688
1929
    """A TreeTransform for generating preview trees.
1703
1944
    def tree_kind(self, trans_id):
1704
1945
        path = self._tree_id_paths.get(trans_id)
1705
1946
        if path is None:
1706
 
            raise NoSuchFile(None)
1707
 
        file_id = self._tree.path2id(path)
1708
 
        return self._tree.kind(file_id)
 
1947
            return None
 
1948
        kind = self._tree.path_content_summary(path)[0]
 
1949
        if kind == 'missing':
 
1950
            kind = None
 
1951
        return kind
1709
1952
 
1710
1953
    def _set_mode(self, trans_id, mode_id, typefunc):
1711
1954
        """Set the mode of new file contents.
1731
1974
            childpath = joinpath(path, child)
1732
1975
            yield self.trans_id_tree_path(childpath)
1733
1976
 
1734
 
 
1735
 
class _PreviewTree(tree.Tree):
 
1977
    def new_orphan(self, trans_id, parent_id):
 
1978
        raise NotImplementedError(self.new_orphan)
 
1979
 
 
1980
 
 
1981
class _PreviewTree(tree.InventoryTree):
1736
1982
    """Partial implementation of Tree to support show_diff_trees"""
1737
1983
 
1738
1984
    def __init__(self, transform):
1767
2013
                yield self._get_repository().revision_tree(revision_id)
1768
2014
 
1769
2015
    def _get_file_revision(self, file_id, vf, tree_revision):
1770
 
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
2016
        parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
1771
2017
                       self._iter_parent_trees()]
1772
2018
        vf.add_lines((file_id, tree_revision), parent_keys,
1773
 
                     self.get_file(file_id).readlines())
 
2019
                     self.get_file_lines(file_id))
1774
2020
        repo = self._get_repository()
1775
2021
        base_vf = repo.texts
1776
2022
        if base_vf not in vf.fallback_versionedfiles:
1777
2023
            vf.fallback_versionedfiles.append(base_vf)
1778
2024
        return tree_revision
1779
2025
 
1780
 
    def _stat_limbo_file(self, file_id):
1781
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2026
    def _stat_limbo_file(self, file_id=None, trans_id=None):
 
2027
        if trans_id is None:
 
2028
            trans_id = self._transform.trans_id_file_id(file_id)
1782
2029
        name = self._transform._limbo_name(trans_id)
1783
2030
        return os.lstat(name)
1784
2031
 
1798
2045
            executable = self.is_executable(file_id, path)
1799
2046
        return kind, executable, None
1800
2047
 
 
2048
    def is_locked(self):
 
2049
        return False
 
2050
 
1801
2051
    def lock_read(self):
1802
2052
        # Perhaps in theory, this should lock the TreeTransform?
1803
 
        pass
 
2053
        return self
1804
2054
 
1805
2055
    def unlock(self):
1806
2056
        pass
1904
2154
            if (specific_file_ids is not None
1905
2155
                and file_id not in specific_file_ids):
1906
2156
                continue
1907
 
            try:
1908
 
                kind = self._transform.final_kind(trans_id)
1909
 
            except NoSuchFile:
 
2157
            kind = self._transform.final_kind(trans_id)
 
2158
            if kind is None:
1910
2159
                kind = self._transform._tree.stored_kind(file_id)
1911
2160
            new_entry = inventory.make_entry(
1912
2161
                kind,
1997
2246
 
1998
2247
    def get_file_size(self, file_id):
1999
2248
        """See Tree.get_file_size"""
 
2249
        trans_id = self._transform.trans_id_file_id(file_id)
 
2250
        kind = self._transform.final_kind(trans_id)
 
2251
        if kind != 'file':
 
2252
            return None
 
2253
        if trans_id in self._transform._new_contents:
 
2254
            return self._stat_limbo_file(trans_id=trans_id).st_size
2000
2255
        if self.kind(file_id) == 'file':
2001
2256
            return self._transform._tree.get_file_size(file_id)
2002
2257
        else:
2030
2285
            except errors.NoSuchId:
2031
2286
                return False
2032
2287
 
 
2288
    def has_filename(self, path):
 
2289
        trans_id = self._path2trans_id(path)
 
2290
        if trans_id in self._transform._new_contents:
 
2291
            return True
 
2292
        elif trans_id in self._transform._removed_contents:
 
2293
            return False
 
2294
        else:
 
2295
            return self._transform._tree.has_filename(path)
 
2296
 
2033
2297
    def path_content_summary(self, path):
2034
2298
        trans_id = self._path2trans_id(path)
2035
2299
        tt = self._transform
2123
2387
                                   self.get_file(file_id).readlines(),
2124
2388
                                   default_revision)
2125
2389
 
2126
 
    def get_symlink_target(self, file_id):
 
2390
    def get_symlink_target(self, file_id, path=None):
2127
2391
        """See Tree.get_symlink_target"""
2128
2392
        if not self._content_change(file_id):
2129
2393
            return self._transform._tree.get_symlink_target(file_id)
2144
2408
                path_from_root = self._final_paths.get_path(child_id)
2145
2409
                basename = self._transform.final_name(child_id)
2146
2410
                file_id = self._transform.final_file_id(child_id)
2147
 
                try:
2148
 
                    kind = self._transform.final_kind(child_id)
 
2411
                kind  = self._transform.final_kind(child_id)
 
2412
                if kind is not None:
2149
2413
                    versioned_kind = kind
2150
 
                except NoSuchFile:
 
2414
                else:
2151
2415
                    kind = 'unknown'
2152
2416
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2153
2417
                if versioned_kind == 'directory':
2266
2530
    for num, _unused in enumerate(wt.all_file_ids()):
2267
2531
        if num > 0:  # more than just a root
2268
2532
            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
2533
    file_trans_id = {}
2273
 
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2534
    top_pb = ui.ui_factory.nested_progress_bar()
2274
2535
    pp = ProgressPhase("Build phase", 2, top_pb)
2275
2536
    if tree.inventory.root is not None:
2276
2537
        # This is kind of a hack: we should be altering the root
2289
2550
        pp.next_phase()
2290
2551
        file_trans_id[wt.get_root_id()] = \
2291
2552
            tt.trans_id_tree_file_id(wt.get_root_id())
2292
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2553
        pb = ui.ui_factory.nested_progress_bar()
2293
2554
        try:
2294
2555
            deferred_contents = []
2295
2556
            num = 0
2298
2559
                precomputed_delta = []
2299
2560
            else:
2300
2561
                precomputed_delta = None
 
2562
            # Check if tree inventory has content. If so, we populate
 
2563
            # existing_files with the directory content. If there are no
 
2564
            # entries we skip populating existing_files as its not used.
 
2565
            # This improves performance and unncessary work on large
 
2566
            # directory trees. (#501307)
 
2567
            if total > 0:
 
2568
                existing_files = set()
 
2569
                for dir, files in wt.walkdirs():
 
2570
                    existing_files.update(f[0] for f in files)
2301
2571
            for num, (tree_path, entry) in \
2302
2572
                enumerate(tree.inventory.iter_entries_by_dir()):
2303
2573
                pb.update("Building tree", num - len(deferred_contents), total)
2333
2603
                    executable = tree.is_executable(file_id, tree_path)
2334
2604
                    if executable:
2335
2605
                        tt.set_executability(executable, trans_id)
2336
 
                    trans_data = (trans_id, tree_path)
 
2606
                    trans_data = (trans_id, tree_path, entry.text_sha1)
2337
2607
                    deferred_contents.append((file_id, trans_data))
2338
2608
                else:
2339
2609
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2355
2625
            precomputed_delta = None
2356
2626
        conflicts = cook_conflicts(raw_conflicts, tt)
2357
2627
        for conflict in conflicts:
2358
 
            warning(conflict)
 
2628
            trace.warning(unicode(conflict))
2359
2629
        try:
2360
2630
            wt.add_conflicts(conflicts)
2361
2631
        except errors.UnsupportedOperation:
2384
2654
        unchanged = dict(unchanged)
2385
2655
        new_desired_files = []
2386
2656
        count = 0
2387
 
        for file_id, (trans_id, tree_path) in desired_files:
 
2657
        for file_id, (trans_id, tree_path, text_sha1) in desired_files:
2388
2658
            accelerator_path = unchanged.get(file_id)
2389
2659
            if accelerator_path is None:
2390
 
                new_desired_files.append((file_id, (trans_id, tree_path)))
 
2660
                new_desired_files.append((file_id,
 
2661
                    (trans_id, tree_path, text_sha1)))
2391
2662
                continue
2392
2663
            pb.update('Adding file contents', count + offset, total)
2393
2664
            if hardlink:
2400
2671
                    contents = filtered_output_bytes(contents, filters,
2401
2672
                        ContentFilterContext(tree_path, tree))
2402
2673
                try:
2403
 
                    tt.create_file(contents, trans_id)
 
2674
                    tt.create_file(contents, trans_id, sha1=text_sha1)
2404
2675
                finally:
2405
2676
                    try:
2406
2677
                        contents.close()
2409
2680
                        pass
2410
2681
            count += 1
2411
2682
        offset += count
2412
 
    for count, ((trans_id, tree_path), contents) in enumerate(
 
2683
    for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
2413
2684
            tree.iter_files_bytes(new_desired_files)):
2414
2685
        if wt.supports_content_filtering():
2415
2686
            filters = wt._content_filter_stack(tree_path)
2416
2687
            contents = filtered_output_bytes(contents, filters,
2417
2688
                ContentFilterContext(tree_path, tree))
2418
 
        tt.create_file(contents, trans_id)
 
2689
        tt.create_file(contents, trans_id, sha1=text_sha1)
2419
2690
        pb.update('Adding file contents', count + offset, total)
2420
2691
 
2421
2692
 
2423
2694
    for child in tt.iter_tree_children(old_parent):
2424
2695
        tt.adjust_path(tt.final_name(child), new_parent, child)
2425
2696
 
 
2697
 
2426
2698
def _reparent_transform_children(tt, old_parent, new_parent):
2427
2699
    by_parent = tt.by_parent()
2428
2700
    for child in by_parent[old_parent]:
2429
2701
        tt.adjust_path(tt.final_name(child), new_parent, child)
2430
2702
    return by_parent[old_parent]
2431
2703
 
 
2704
 
2432
2705
def _content_match(tree, entry, file_id, kind, target_path):
2433
2706
    if entry.kind != kind:
2434
2707
        return False
2435
2708
    if entry.kind == "directory":
2436
2709
        return True
2437
2710
    if entry.kind == "file":
2438
 
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
2439
 
            return True
 
2711
        f = file(target_path, 'rb')
 
2712
        try:
 
2713
            if tree.get_file_text(file_id) == f.read():
 
2714
                return True
 
2715
        finally:
 
2716
            f.close()
2440
2717
    elif entry.kind == "symlink":
2441
2718
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2442
2719
            return True
2494
2771
        raise errors.BadFileKindError(name, kind)
2495
2772
 
2496
2773
 
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
2774
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2514
2775
    filter_tree_path=None):
2515
2776
    """Create new file contents according to tree contents.
2546
2807
        tt.set_executability(entry.executable, trans_id)
2547
2808
 
2548
2809
 
 
2810
@deprecated_function(deprecated_in((2, 3, 0)))
2549
2811
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2550
2812
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2551
2813
 
2552
2814
 
 
2815
@deprecated_function(deprecated_in((2, 3, 0)))
2553
2816
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2554
2817
    """Produce a backup-style name that appears to be available"""
2555
2818
    def name_gen():
2604
2867
                unversioned_filter=working_tree.is_ignored)
2605
2868
            delta.report_changes(tt.iter_changes(), change_reporter)
2606
2869
        for conflict in conflicts:
2607
 
            warning(conflict)
 
2870
            trace.warning(unicode(conflict))
2608
2871
        pp.next_phase()
2609
2872
        tt.apply()
2610
2873
        working_tree.set_merge_modified(merge_modified)
2618
2881
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2619
2882
                              backups, pp, basis_tree=None,
2620
2883
                              merge_modified=None):
2621
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2884
    child_pb = ui.ui_factory.nested_progress_bar()
2622
2885
    try:
2623
2886
        if merge_modified is None:
2624
2887
            merge_modified = working_tree.merge_modified()
2627
2890
                                      merge_modified, basis_tree)
2628
2891
    finally:
2629
2892
        child_pb.finished()
2630
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2893
    child_pb = ui.ui_factory.nested_progress_bar()
2631
2894
    try:
2632
2895
        raw_conflicts = resolve_conflicts(tt, child_pb,
2633
2896
            lambda t, c: conflict_pass(t, c, target_tree))
2641
2904
                 backups, merge_modified, basis_tree=None):
2642
2905
    if basis_tree is not None:
2643
2906
        basis_tree.lock_read()
2644
 
    change_list = target_tree.iter_changes(working_tree,
 
2907
    # We ask the working_tree for its changes relative to the target, rather
 
2908
    # than the target changes relative to the working tree. Because WT4 has an
 
2909
    # optimizer to compare itself to a target, but no optimizer for the
 
2910
    # reverse.
 
2911
    change_list = working_tree.iter_changes(target_tree,
2645
2912
        specific_files=specific_files, pb=pb)
2646
2913
    if target_tree.get_root_id() is None:
2647
2914
        skip_root = True
2651
2918
        deferred_files = []
2652
2919
        for id_num, (file_id, path, changed_content, versioned, parent, name,
2653
2920
                kind, executable) in enumerate(change_list):
2654
 
            if skip_root and file_id[0] is not None and parent[0] is None:
 
2921
            target_path, wt_path = path
 
2922
            target_versioned, wt_versioned = versioned
 
2923
            target_parent, wt_parent = parent
 
2924
            target_name, wt_name = name
 
2925
            target_kind, wt_kind = kind
 
2926
            target_executable, wt_executable = executable
 
2927
            if skip_root and wt_parent is None:
2655
2928
                continue
2656
2929
            trans_id = tt.trans_id_file_id(file_id)
2657
2930
            mode_id = None
2658
2931
            if changed_content:
2659
2932
                keep_content = False
2660
 
                if kind[0] == 'file' and (backups or kind[1] is None):
 
2933
                if wt_kind == 'file' and (backups or target_kind is None):
2661
2934
                    wt_sha1 = working_tree.get_file_sha1(file_id)
2662
2935
                    if merge_modified.get(file_id) != wt_sha1:
2663
2936
                        # acquire the basis tree lazily to prevent the
2669
2942
                        if file_id in basis_tree:
2670
2943
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
2671
2944
                                keep_content = True
2672
 
                        elif kind[1] is None and not versioned[1]:
 
2945
                        elif target_kind is None and not target_versioned:
2673
2946
                            keep_content = True
2674
 
                if kind[0] is not None:
 
2947
                if wt_kind is not None:
2675
2948
                    if not keep_content:
2676
2949
                        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)
 
2950
                    elif target_kind is not None:
 
2951
                        parent_trans_id = tt.trans_id_file_id(wt_parent)
 
2952
                        backup_name = tt._available_backup_name(
 
2953
                            wt_name, parent_trans_id)
2682
2954
                        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):
 
2955
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
 
2956
                        if wt_versioned and target_versioned:
2685
2957
                            tt.unversion_file(trans_id)
2686
2958
                            tt.version_file(file_id, new_trans_id)
2687
2959
                        # New contents should have the same unix perms as old
2688
2960
                        # contents
2689
2961
                        mode_id = trans_id
2690
2962
                        trans_id = new_trans_id
2691
 
                if kind[1] in ('directory', 'tree-reference'):
 
2963
                if target_kind in ('directory', 'tree-reference'):
2692
2964
                    tt.create_directory(trans_id)
2693
 
                    if kind[1] == 'tree-reference':
 
2965
                    if target_kind == 'tree-reference':
2694
2966
                        revision = target_tree.get_reference_revision(file_id,
2695
 
                                                                      path[1])
 
2967
                                                                      target_path)
2696
2968
                        tt.set_tree_reference(revision, trans_id)
2697
 
                elif kind[1] == 'symlink':
 
2969
                elif target_kind == 'symlink':
2698
2970
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
2699
2971
                                      trans_id)
2700
 
                elif kind[1] == 'file':
 
2972
                elif target_kind == 'file':
2701
2973
                    deferred_files.append((file_id, (trans_id, mode_id)))
2702
2974
                    if basis_tree is None:
2703
2975
                        basis_tree = working_tree.basis_tree()
2711
2983
                        merge_modified[file_id] = new_sha1
2712
2984
 
2713
2985
                    # 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):
 
2986
                    if keep_content and wt_executable == target_executable:
 
2987
                        tt.set_executability(target_executable, trans_id)
 
2988
                elif target_kind is not None:
 
2989
                    raise AssertionError(target_kind)
 
2990
            if not wt_versioned and target_versioned:
2719
2991
                tt.version_file(file_id, trans_id)
2720
 
            if versioned == (True, False):
 
2992
            if wt_versioned and not target_versioned:
2721
2993
                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:
 
2994
            if (target_name is not None and
 
2995
                (wt_name != target_name or wt_parent != target_parent)):
 
2996
                if target_name == '' and target_parent is None:
2725
2997
                    parent_trans = ROOT_PARENT
2726
2998
                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)
 
2999
                    parent_trans = tt.trans_id_file_id(target_parent)
 
3000
                if wt_parent is None and wt_versioned:
 
3001
                    tt.adjust_root_path(target_name, parent_trans)
2730
3002
                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)
 
3003
                    tt.adjust_path(target_name, parent_trans, trans_id)
 
3004
            if wt_executable != target_executable and target_kind == "file":
 
3005
                tt.set_executability(target_executable, trans_id)
2734
3006
        if working_tree.supports_content_filtering():
2735
3007
            for index, ((trans_id, mode_id), bytes) in enumerate(
2736
3008
                target_tree.iter_files_bytes(deferred_files)):
2807
3079
 
2808
3080
        elif c_type == 'missing parent':
2809
3081
            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:
 
3082
            if trans_id in tt._removed_contents:
 
3083
                cancel_deletion = True
 
3084
                orphans = tt._get_potential_orphans(trans_id)
 
3085
                if orphans:
 
3086
                    cancel_deletion = False
 
3087
                    # All children are orphans
 
3088
                    for o in orphans:
 
3089
                        try:
 
3090
                            tt.new_orphan(o, trans_id)
 
3091
                        except OrphaningError:
 
3092
                            # Something bad happened so we cancel the directory
 
3093
                            # deletion which will leave it in place with a
 
3094
                            # conflict. The user can deal with it from there.
 
3095
                            # Note that this also catch the case where we don't
 
3096
                            # want to create orphans and leave the directory in
 
3097
                            # place.
 
3098
                            cancel_deletion = True
 
3099
                            break
 
3100
                if cancel_deletion:
 
3101
                    # Cancel the directory deletion
 
3102
                    tt.cancel_deletion(trans_id)
 
3103
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
3104
                                       trans_id))
 
3105
            else:
2815
3106
                create = True
2816
3107
                try:
2817
3108
                    tt.final_name(trans_id)
2820
3111
                        file_id = tt.final_file_id(trans_id)
2821
3112
                        if file_id is None:
2822
3113
                            file_id = tt.inactive_file_id(trans_id)
2823
 
                        entry = path_tree.inventory[file_id]
 
3114
                        _, entry = path_tree.iter_entries_by_dir(
 
3115
                            [file_id]).next()
2824
3116
                        # special-case the other tree root (move its
2825
3117
                        # children to current root)
2826
3118
                        if entry.parent_id is None:
2842
3134
            file_id = tt.inactive_file_id(conflict[1])
2843
3135
            # special-case the other tree root (move its children instead)
2844
3136
            if path_tree and file_id in path_tree:
2845
 
                if path_tree.inventory[file_id].parent_id is None:
 
3137
                if path_tree.path2id('') == file_id:
 
3138
                    # This is the root entry, skip it
2846
3139
                    continue
2847
3140
            tt.version_file(file_id, conflict[1])
2848
3141
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2864
3157
 
2865
3158
def cook_conflicts(raw_conflicts, tt):
2866
3159
    """Generate a list of cooked conflicts, sorted by file path"""
2867
 
    from bzrlib.conflicts import Conflict
2868
3160
    conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
2869
 
    return sorted(conflict_iter, key=Conflict.sort_key)
 
3161
    return sorted(conflict_iter, key=conflicts.Conflict.sort_key)
2870
3162
 
2871
3163
 
2872
3164
def iter_cook_conflicts(raw_conflicts, tt):
2873
 
    from bzrlib.conflicts import Conflict
2874
3165
    fp = FinalPaths(tt)
2875
3166
    for conflict in raw_conflicts:
2876
3167
        c_type = conflict[0]
2878
3169
        modified_path = fp.get_path(conflict[2])
2879
3170
        modified_id = tt.final_file_id(conflict[2])
2880
3171
        if len(conflict) == 3:
2881
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
2882
 
                                     file_id=modified_id)
 
3172
            yield conflicts.Conflict.factory(
 
3173
                c_type, action=action, path=modified_path, file_id=modified_id)
2883
3174
 
2884
3175
        else:
2885
3176
            conflicting_path = fp.get_path(conflict[3])
2886
3177
            conflicting_id = tt.final_file_id(conflict[3])
2887
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
2888
 
                                   file_id=modified_id,
2889
 
                                   conflict_path=conflicting_path,
2890
 
                                   conflict_file_id=conflicting_id)
 
3178
            yield conflicts.Conflict.factory(
 
3179
                c_type, action=action, path=modified_path,
 
3180
                file_id=modified_id,
 
3181
                conflict_path=conflicting_path,
 
3182
                conflict_file_id=conflicting_id)
2891
3183
 
2892
3184
 
2893
3185
class _FileMover(object):
2900
3192
    def rename(self, from_, to):
2901
3193
        """Rename a file from one path to another."""
2902
3194
        try:
2903
 
            osutils.rename(from_, to)
 
3195
            os.rename(from_, to)
2904
3196
        except OSError, e:
2905
3197
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2906
3198
                raise errors.FileExists(to, str(e))
2907
 
            raise
 
3199
            # normal OSError doesn't include filenames so it's hard to see where
 
3200
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
 
3201
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
2908
3202
        self.past_renames.append((from_, to))
2909
3203
 
2910
3204
    def pre_delete(self, from_, to):
2920
3214
    def rollback(self):
2921
3215
        """Reverse all renames that have been performed"""
2922
3216
        for from_, to in reversed(self.past_renames):
2923
 
            osutils.rename(to, from_)
 
3217
            try:
 
3218
                os.rename(to, from_)
 
3219
            except OSError, e:
 
3220
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2924
3221
        # after rollback, don't reuse _FileMover
2925
3222
        past_renames = None
2926
3223
        pending_deletions = None