/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

Implement RemoteRepository side of write group HPSS methods.

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
 
    bzrdir,
 
33
    controldir,
 
34
    commit,
 
35
    conflicts,
28
36
    delta,
29
 
    errors,
30
37
    inventory,
31
38
    multiparent,
32
39
    osutils,
33
40
    revision as _mod_revision,
34
41
    ui,
 
42
    urlutils,
35
43
    )
 
44
from bzrlib.i18n import gettext
36
45
""")
37
 
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
 
46
from bzrlib.errors import (DuplicateKey, MalformedTransform,
38
47
                           ReusingTransform, CantMoveRoot,
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
 
212
226
        This means that the old root trans-id becomes obsolete, so it is
213
227
        recommended only to invoke this after the root trans-id has become
214
228
        irrelevant.
 
229
 
215
230
        """
216
231
        new_roots = [k for k, v in self._new_parent.iteritems() if v is
217
232
                     ROOT_PARENT]
223
238
            self._new_root = new_roots[0]
224
239
            return
225
240
        old_new_root = new_roots[0]
226
 
        # TODO: What to do if a old_new_root is present, but self._new_root is
227
 
        #       not listed as being removed? This code explicitly unversions
228
 
        #       the old root and versions it with the new file_id. Though that
229
 
        #       seems like an incomplete delta
230
 
 
231
241
        # unversion the new root's directory.
232
 
        file_id = self.final_file_id(old_new_root)
 
242
        if self.final_kind(self._new_root) is None:
 
243
            file_id = self.final_file_id(old_new_root)
 
244
        else:
 
245
            file_id = self.final_file_id(self._new_root)
233
246
        if old_new_root in self._new_id:
234
247
            self.cancel_versioning(old_new_root)
235
248
        else:
239
252
        if (self.tree_file_id(self._new_root) is not None and
240
253
            self._new_root not in self._removed_id):
241
254
            self.unversion_file(self._new_root)
242
 
        self.version_file(file_id, self._new_root)
 
255
        if file_id is not None:
 
256
            self.version_file(file_id, self._new_root)
243
257
 
244
258
        # Now move children of new root into old root directory.
245
259
        # Ensure all children are registered with the transaction, but don't
314
328
 
315
329
    def delete_contents(self, trans_id):
316
330
        """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)
 
331
        kind = self.tree_kind(trans_id)
 
332
        if kind is not None:
 
333
            self._removed_contents.add(trans_id)
321
334
 
322
335
    def cancel_deletion(self, trans_id):
323
336
        """Cancel a scheduled deletion"""
380
393
        return sorted(FinalPaths(self).get_paths(new_ids))
381
394
 
382
395
    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,
 
396
        """Determine which trans_ids need new Inventory entries.
 
397
 
 
398
        An new entry is needed when anything that would be reflected by an
 
399
        inventory entry changes, including file name, file_id, parent file_id,
 
400
        file kind, and the execute bit.
 
401
 
 
402
        Some care is taken to return entries with real changes, not cases
 
403
        where the value is deleted and then restored to its original value,
 
404
        but some actually unchanged values may be returned.
 
405
 
 
406
        :returns: A list of (path, trans_id) for all items requiring an
 
407
            inventory change. Ordered by path.
 
408
        """
 
409
        changed_ids = set()
 
410
        # Find entries whose file_ids are new (or changed).
 
411
        new_file_id = set(t for t in self._new_id
 
412
                          if self._new_id[t] != self.tree_file_id(t))
 
413
        for id_set in [self._new_name, self._new_parent, new_file_id,
386
414
                       self._new_executability]:
387
 
            new_ids.update(id_set)
 
415
            changed_ids.update(id_set)
 
416
        # removing implies a kind change
388
417
        changed_kind = set(self._removed_contents)
 
418
        # so does adding
389
419
        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))
 
420
        # Ignore entries that are already known to have changed.
 
421
        changed_kind.difference_update(changed_ids)
 
422
        #  to keep only the truly changed ones
 
423
        changed_kind = (t for t in changed_kind
 
424
                        if self.tree_kind(t) != self.final_kind(t))
 
425
        # all kind changes will alter the inventory
 
426
        changed_ids.update(changed_kind)
 
427
        # To find entries with changed parent_ids, find parents which existed,
 
428
        # but changed file_id.
 
429
        changed_file_id = set(t for t in new_file_id if t in self._removed_id)
 
430
        # Now add all their children to the set.
 
431
        for parent_trans_id in new_file_id:
 
432
            changed_ids.update(self.iter_tree_children(parent_trans_id))
 
433
        return sorted(FinalPaths(self).get_paths(changed_ids))
395
434
 
396
435
    def final_kind(self, trans_id):
397
436
        """Determine the final file kind, after any changes applied.
398
437
 
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)
 
438
        :return: None if the file does not exist/has no contents.  (It is
 
439
            conceivable that a path would be created without the corresponding
 
440
            contents insertion command)
402
441
        """
403
442
        if trans_id in self._new_contents:
404
443
            return self._new_contents[trans_id]
405
444
        elif trans_id in self._removed_contents:
406
 
            raise NoSuchFile(None)
 
445
            return None
407
446
        else:
408
447
            return self.tree_kind(trans_id)
409
448
 
522
561
        for trans_id in self._removed_id:
523
562
            file_id = self.tree_file_id(trans_id)
524
563
            if file_id is not None:
525
 
                if self._tree.inventory[file_id].kind == 'directory':
 
564
                if self._tree.stored_kind(file_id) == 'directory':
526
565
                    parents.append(trans_id)
527
566
            elif self.tree_kind(trans_id) == 'directory':
528
567
                parents.append(trans_id)
531
570
            # ensure that all children are registered with the transaction
532
571
            list(self.iter_tree_children(parent_id))
533
572
 
 
573
    @deprecated_method(deprecated_in((2, 3, 0)))
534
574
    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:
 
575
        return self._has_named_child(
 
576
            name, parent_id, known_children=by_parent.get(parent_id, []))
 
577
 
 
578
    def _has_named_child(self, name, parent_id, known_children):
 
579
        """Does a parent already have a name child.
 
580
 
 
581
        :param name: The searched for name.
 
582
 
 
583
        :param parent_id: The parent for which the check is made.
 
584
 
 
585
        :param known_children: The already known children. This should have
 
586
            been recently obtained from `self.by_parent.get(parent_id)`
 
587
            (or will be if None is passed).
 
588
        """
 
589
        if known_children is None:
 
590
            known_children = self.by_parent().get(parent_id, [])
 
591
        for child in known_children:
540
592
            if self.final_name(child) == name:
541
593
                return True
542
 
        try:
543
 
            path = self._tree_id_paths[parent_id]
544
 
        except KeyError:
 
594
        parent_path = self._tree_id_paths.get(parent_id, None)
 
595
        if parent_path is None:
 
596
            # No parent... no children
545
597
            return False
546
 
        childpath = joinpath(path, name)
547
 
        child_id = self._tree_path_ids.get(childpath)
 
598
        child_path = joinpath(parent_path, name)
 
599
        child_id = self._tree_path_ids.get(child_path, None)
548
600
        if child_id is None:
549
 
            return lexists(self._tree.abspath(childpath))
 
601
            # Not known by the tree transform yet, check the filesystem
 
602
            return osutils.lexists(self._tree.abspath(child_path))
550
603
        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
 
604
            raise AssertionError('child_id is missing: %s, %s, %s'
 
605
                                 % (name, parent_id, child_id))
 
606
 
 
607
    def _available_backup_name(self, name, target_id):
 
608
        """Find an available backup name.
 
609
 
 
610
        :param name: The basename of the file.
 
611
 
 
612
        :param target_id: The directory trans_id where the backup should 
 
613
            be placed.
 
614
        """
 
615
        known_children = self.by_parent().get(target_id, [])
 
616
        return osutils.available_backup_name(
 
617
            name,
 
618
            lambda base: self._has_named_child(
 
619
                base, target_id, known_children))
558
620
 
559
621
    def _parent_loops(self):
560
622
        """No entry should be its own ancestor"""
595
657
        """
596
658
        conflicts = []
597
659
        for trans_id in self._new_id.iterkeys():
598
 
            try:
599
 
                kind = self.final_kind(trans_id)
600
 
            except NoSuchFile:
 
660
            kind = self.final_kind(trans_id)
 
661
            if kind is None:
601
662
                conflicts.append(('versioning no contents', trans_id))
602
663
                continue
603
 
            if not InventoryEntry.versionable_kind(kind):
 
664
            if not inventory.InventoryEntry.versionable_kind(kind):
604
665
                conflicts.append(('versioning bad kind', trans_id, kind))
605
666
        return conflicts
606
667
 
617
678
            if self.final_file_id(trans_id) is None:
618
679
                conflicts.append(('unversioned executability', trans_id))
619
680
            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:
 
681
                if self.final_kind(trans_id) != "file":
625
682
                    conflicts.append(('non-file executability', trans_id))
626
683
        return conflicts
627
684
 
629
686
        """Check for overwrites (not permitted on Win32)"""
630
687
        conflicts = []
631
688
        for trans_id in self._new_contents:
632
 
            try:
633
 
                self.tree_kind(trans_id)
634
 
            except NoSuchFile:
 
689
            if self.tree_kind(trans_id) is None:
635
690
                continue
636
691
            if trans_id not in self._removed_contents:
637
692
                conflicts.append(('overwrite', trans_id,
644
699
        if (self._new_name, self._new_parent) == ({}, {}):
645
700
            return conflicts
646
701
        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]
 
702
            name_ids = []
 
703
            for child_tid in children:
 
704
                name = self.final_name(child_tid)
 
705
                if name is not None:
 
706
                    # Keep children only if they still exist in the end
 
707
                    if not self._case_sensitive_target:
 
708
                        name = name.lower()
 
709
                    name_ids.append((name, child_tid))
650
710
            name_ids.sort()
651
711
            last_name = None
652
712
            last_trans_id = None
653
713
            for name, trans_id in name_ids:
654
 
                try:
655
 
                    kind = self.final_kind(trans_id)
656
 
                except NoSuchFile:
657
 
                    kind = None
 
714
                kind = self.final_kind(trans_id)
658
715
                file_id = self.final_file_id(trans_id)
659
716
                if kind is None and file_id is None:
660
717
                    continue
679
736
        return conflicts
680
737
 
681
738
    def _parent_type_conflicts(self, by_parent):
682
 
        """parents must have directory 'contents'."""
 
739
        """Children must have a directory parent"""
683
740
        conflicts = []
684
741
        for parent_id, children in by_parent.iteritems():
685
742
            if parent_id is ROOT_PARENT:
686
743
                continue
687
 
            if not self._any_contents(children):
 
744
            no_children = True
 
745
            for child_id in children:
 
746
                if self.final_kind(child_id) is not None:
 
747
                    no_children = False
 
748
                    break
 
749
            if no_children:
688
750
                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
 
751
            # There is at least a child, so we need an existing directory to
 
752
            # contain it.
 
753
            kind = self.final_kind(parent_id)
698
754
            if kind is None:
 
755
                # The directory will be deleted
699
756
                conflicts.append(('missing parent', parent_id))
700
757
            elif kind != "directory":
 
758
                # Meh, we need a *directory* to put something in it
701
759
                conflicts.append(('non-directory parent', parent_id))
702
760
        return conflicts
703
761
 
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
762
    def _set_executability(self, path, trans_id):
715
763
        """Set the executability of versioned files """
716
764
        if supports_executable():
738
786
        return trans_id
739
787
 
740
788
    def new_file(self, name, parent_id, contents, file_id=None,
741
 
                 executable=None):
 
789
                 executable=None, sha1=None):
742
790
        """Convenience method to create files.
743
791
 
744
792
        name is the name of the file to create.
751
799
        trans_id = self._new_entry(name, parent_id, file_id)
752
800
        # TODO: rather than scheduling a set_executable call,
753
801
        # have create_file create the file with the right mode.
754
 
        self.create_file(contents, trans_id)
 
802
        self.create_file(contents, trans_id, sha1=sha1)
755
803
        if executable is not None:
756
804
            self.set_executability(executable, trans_id)
757
805
        return trans_id
780
828
        self.create_symlink(target, trans_id)
781
829
        return trans_id
782
830
 
 
831
    def new_orphan(self, trans_id, parent_id):
 
832
        """Schedule an item to be orphaned.
 
833
 
 
834
        When a directory is about to be removed, its children, if they are not
 
835
        versioned are moved out of the way: they don't have a parent anymore.
 
836
 
 
837
        :param trans_id: The trans_id of the existing item.
 
838
        :param parent_id: The parent trans_id of the item.
 
839
        """
 
840
        raise NotImplementedError(self.new_orphan)
 
841
 
 
842
    def _get_potential_orphans(self, dir_id):
 
843
        """Find the potential orphans in a directory.
 
844
 
 
845
        A directory can't be safely deleted if there are versioned files in it.
 
846
        If all the contained files are unversioned then they can be orphaned.
 
847
 
 
848
        The 'None' return value means that the directory contains at least one
 
849
        versioned file and should not be deleted.
 
850
 
 
851
        :param dir_id: The directory trans id.
 
852
 
 
853
        :return: A list of the orphan trans ids or None if at least one
 
854
             versioned file is present.
 
855
        """
 
856
        orphans = []
 
857
        # Find the potential orphans, stop if one item should be kept
 
858
        for child_tid in self.by_parent()[dir_id]:
 
859
            if child_tid in self._removed_contents:
 
860
                # The child is removed as part of the transform. Since it was
 
861
                # versioned before, it's not an orphan
 
862
                continue
 
863
            elif self.final_file_id(child_tid) is None:
 
864
                # The child is not versioned
 
865
                orphans.append(child_tid)
 
866
            else:
 
867
                # We have a versioned file here, searching for orphans is
 
868
                # meaningless.
 
869
                orphans = None
 
870
                break
 
871
        return orphans
 
872
 
783
873
    def _affected_ids(self):
784
874
        """Return the set of transform ids affected by the transform"""
785
875
        trans_ids = set(self._removed_id)
844
934
        Return a (name, parent, kind, executable) tuple
845
935
        """
846
936
        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
 
937
        to_kind = self.final_kind(to_trans_id)
851
938
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
852
939
        if to_trans_id in self._new_executability:
853
940
            to_executable = self._new_executability[to_trans_id]
927
1014
        """
928
1015
        return _PreviewTree(self)
929
1016
 
930
 
    def commit(self, branch, message, merge_parents=None, strict=False):
 
1017
    def commit(self, branch, message, merge_parents=None, strict=False,
 
1018
               timestamp=None, timezone=None, committer=None, authors=None,
 
1019
               revprops=None, revision_id=None):
931
1020
        """Commit the result of this TreeTransform to a branch.
932
1021
 
933
1022
        :param branch: The branch to commit to.
934
1023
        :param message: The message to attach to the commit.
935
 
        :param merge_parents: Additional parents specified by pending merges.
 
1024
        :param merge_parents: Additional parent revision-ids specified by
 
1025
            pending merges.
 
1026
        :param strict: If True, abort the commit if there are unversioned
 
1027
            files.
 
1028
        :param timestamp: if not None, seconds-since-epoch for the time and
 
1029
            date.  (May be a float.)
 
1030
        :param timezone: Optional timezone for timestamp, as an offset in
 
1031
            seconds.
 
1032
        :param committer: Optional committer in email-id format.
 
1033
            (e.g. "J Random Hacker <jrandom@example.com>")
 
1034
        :param authors: Optional list of authors in email-id format.
 
1035
        :param revprops: Optional dictionary of revision properties.
 
1036
        :param revision_id: Optional revision id.  (Specifying a revision-id
 
1037
            may reduce performance for some non-native formats.)
936
1038
        :return: The revision_id of the revision committed.
937
1039
        """
938
1040
        self._check_malformed()
955
1057
        if self._tree.get_revision_id() != last_rev_id:
956
1058
            raise ValueError('TreeTransform not based on branch basis: %s' %
957
1059
                             self._tree.get_revision_id())
958
 
        builder = branch.get_commit_builder(parent_ids)
 
1060
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1061
        builder = branch.get_commit_builder(parent_ids,
 
1062
                                            timestamp=timestamp,
 
1063
                                            timezone=timezone,
 
1064
                                            committer=committer,
 
1065
                                            revprops=revprops,
 
1066
                                            revision_id=revision_id)
959
1067
        preview = self.get_preview_tree()
960
1068
        list(builder.record_iter_changes(preview, last_rev_id,
961
1069
                                         self.iter_changes()))
1079
1187
        self._deletiondir = None
1080
1188
        # A mapping of transform ids to their limbo filename
1081
1189
        self._limbo_files = {}
 
1190
        self._possibly_stale_limbo_files = set()
1082
1191
        # A mapping of transform ids to a set of the transform ids of children
1083
1192
        # that their limbo directory has
1084
1193
        self._limbo_children = {}
1097
1206
        if self._tree is None:
1098
1207
            return
1099
1208
        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)
 
1209
            limbo_paths = self._limbo_files.values() + list(
 
1210
                self._possibly_stale_limbo_files)
 
1211
            limbo_paths = sorted(limbo_paths, reverse=True)
 
1212
            for path in limbo_paths:
 
1213
                try:
 
1214
                    delete_any(path)
 
1215
                except OSError, e:
 
1216
                    if e.errno != errno.ENOENT:
 
1217
                        raise
 
1218
                    # XXX: warn? perhaps we just got interrupted at an
 
1219
                    # inconvenient moment, but perhaps files are disappearing
 
1220
                    # from under us?
1105
1221
            try:
1106
1222
                delete_any(self._limbodir)
1107
1223
            except OSError:
1156
1272
        entries from _limbo_files, because they are now stale.
1157
1273
        """
1158
1274
        for trans_id in trans_ids:
1159
 
            old_path = self._limbo_files.pop(trans_id)
 
1275
            old_path = self._limbo_files[trans_id]
 
1276
            self._possibly_stale_limbo_files.add(old_path)
 
1277
            del self._limbo_files[trans_id]
1160
1278
            if trans_id not in self._new_contents:
1161
1279
                continue
1162
1280
            new_path = self._limbo_name(trans_id)
1163
 
            osutils.rename(old_path, new_path)
 
1281
            os.rename(old_path, new_path)
 
1282
            self._possibly_stale_limbo_files.remove(old_path)
1164
1283
            for descendant in self._limbo_descendants(trans_id):
1165
1284
                desc_path = self._limbo_files[descendant]
1166
1285
                desc_path = new_path + desc_path[len(old_path):]
1173
1292
            descendants.update(self._limbo_descendants(descendant))
1174
1293
        return descendants
1175
1294
 
1176
 
    def create_file(self, contents, trans_id, mode_id=None):
 
1295
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
1177
1296
        """Schedule creation of a new file.
1178
1297
 
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.
 
1298
        :seealso: new_file.
 
1299
 
 
1300
        :param contents: an iterator of strings, all of which will be written
 
1301
            to the target destination.
 
1302
        :param trans_id: TreeTransform handle
 
1303
        :param mode_id: If not None, force the mode of the target file to match
 
1304
            the mode of the object referenced by mode_id.
 
1305
            Otherwise, we will try to preserve mode bits of an existing file.
 
1306
        :param sha1: If the sha1 of this content is already known, pass it in.
 
1307
            We can use it to prevent future sha1 computations.
1186
1308
        """
1187
1309
        name = self._limbo_name(trans_id)
1188
1310
        f = open(name, 'wb')
1189
1311
        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
 
 
 
1312
            unique_add(self._new_contents, trans_id, 'file')
1199
1313
            f.writelines(contents)
1200
1314
        finally:
1201
1315
            f.close()
1202
1316
        self._set_mtime(name)
1203
1317
        self._set_mode(trans_id, mode_id, S_ISREG)
 
1318
        # It is unfortunate we have to use lstat instead of fstat, but we just
 
1319
        # used utime and chmod on the file, so we need the accurate final
 
1320
        # details.
 
1321
        if sha1 is not None:
 
1322
            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
1204
1323
 
1205
1324
    def _read_file_chunks(self, trans_id):
1206
1325
        cur_file = open(self._limbo_name(trans_id), 'rb')
1265
1384
    def cancel_creation(self, trans_id):
1266
1385
        """Cancel the creation of new file contents."""
1267
1386
        del self._new_contents[trans_id]
 
1387
        if trans_id in self._observed_sha1s:
 
1388
            del self._observed_sha1s[trans_id]
1268
1389
        children = self._limbo_children.get(trans_id)
1269
1390
        # if this is a limbo directory with children, move them before removing
1270
1391
        # the directory
1274
1395
            del self._limbo_children_names[trans_id]
1275
1396
        delete_any(self._limbo_name(trans_id))
1276
1397
 
 
1398
    def new_orphan(self, trans_id, parent_id):
 
1399
        # FIXME: There is no tree config, so we use the branch one (it's weird
 
1400
        # to define it this way as orphaning can only occur in a working tree,
 
1401
        # but that's all we have (for now). It will find the option in
 
1402
        # locations.conf or bazaar.conf though) -- vila 20100916
 
1403
        conf = self._tree.branch.get_config()
 
1404
        conf_var_name = 'bzr.transform.orphan_policy'
 
1405
        orphan_policy = conf.get_user_option(conf_var_name)
 
1406
        default_policy = orphaning_registry.default_key
 
1407
        if orphan_policy is None:
 
1408
            orphan_policy = default_policy
 
1409
        if orphan_policy not in orphaning_registry:
 
1410
            trace.warning('%s (from %s) is not a known policy, defaulting '
 
1411
                'to %s' % (orphan_policy, conf_var_name, default_policy))
 
1412
            orphan_policy = default_policy
 
1413
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1414
        handle_orphan(self, trans_id, parent_id)
 
1415
 
 
1416
 
 
1417
class OrphaningError(errors.BzrError):
 
1418
 
 
1419
    # Only bugs could lead to such exception being seen by the user
 
1420
    internal_error = True
 
1421
    _fmt = "Error while orphaning %s in %s directory"
 
1422
 
 
1423
    def __init__(self, orphan, parent):
 
1424
        errors.BzrError.__init__(self)
 
1425
        self.orphan = orphan
 
1426
        self.parent = parent
 
1427
 
 
1428
 
 
1429
class OrphaningForbidden(OrphaningError):
 
1430
 
 
1431
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1432
 
 
1433
    def __init__(self, policy):
 
1434
        errors.BzrError.__init__(self)
 
1435
        self.policy = policy
 
1436
 
 
1437
 
 
1438
def move_orphan(tt, orphan_id, parent_id):
 
1439
    """See TreeTransformBase.new_orphan.
 
1440
 
 
1441
    This creates a new orphan in the `bzr-orphans` dir at the root of the
 
1442
    `TreeTransform`.
 
1443
 
 
1444
    :param tt: The TreeTransform orphaning `trans_id`.
 
1445
 
 
1446
    :param orphan_id: The trans id that should be orphaned.
 
1447
 
 
1448
    :param parent_id: The orphan parent trans id.
 
1449
    """
 
1450
    # Add the orphan dir if it doesn't exist
 
1451
    orphan_dir_basename = 'bzr-orphans'
 
1452
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1453
    if tt.final_kind(od_id) is None:
 
1454
        tt.create_directory(od_id)
 
1455
    parent_path = tt._tree_id_paths[parent_id]
 
1456
    # Find a name that doesn't exist yet in the orphan dir
 
1457
    actual_name = tt.final_name(orphan_id)
 
1458
    new_name = tt._available_backup_name(actual_name, od_id)
 
1459
    tt.adjust_path(new_name, od_id, orphan_id)
 
1460
    trace.warning('%s has been orphaned in %s'
 
1461
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1462
 
 
1463
 
 
1464
def refuse_orphan(tt, orphan_id, parent_id):
 
1465
    """See TreeTransformBase.new_orphan.
 
1466
 
 
1467
    This refuses to create orphan, letting the caller handle the conflict.
 
1468
    """
 
1469
    raise OrphaningForbidden('never')
 
1470
 
 
1471
 
 
1472
orphaning_registry = registry.Registry()
 
1473
orphaning_registry.register(
 
1474
    'conflict', refuse_orphan,
 
1475
    'Leave orphans in place and create a conflict on the directory.')
 
1476
orphaning_registry.register(
 
1477
    'move', move_orphan,
 
1478
    'Move orphans into the bzr-orphans directory.')
 
1479
orphaning_registry._set_default_key('conflict')
 
1480
 
1277
1481
 
1278
1482
class TreeTransform(DiskTreeTransform):
1279
1483
    """Represent a tree transformation.
1397
1601
    def tree_kind(self, trans_id):
1398
1602
        """Determine the file kind in the working tree.
1399
1603
 
1400
 
        Raises NoSuchFile if the file does not exist
 
1604
        :returns: The file kind or None if the file does not exist
1401
1605
        """
1402
1606
        path = self._tree_id_paths.get(trans_id)
1403
1607
        if path is None:
1404
 
            raise NoSuchFile(None)
 
1608
            return None
1405
1609
        try:
1406
1610
            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)
 
1611
        except errors.NoSuchFile:
 
1612
            return None
1412
1613
 
1413
1614
    def _set_mode(self, trans_id, mode_id, typefunc):
1414
1615
        """Set the mode of new file contents.
1520
1721
        """
1521
1722
        if not no_conflicts:
1522
1723
            self._check_malformed()
1523
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1724
        child_pb = ui.ui_factory.nested_progress_bar()
1524
1725
        try:
1525
1726
            if precomputed_delta is None:
1526
 
                child_pb.update('Apply phase', 0, 2)
 
1727
                child_pb.update(gettext('Apply phase'), 0, 2)
1527
1728
                inventory_delta = self._generate_inventory_delta()
1528
1729
                offset = 1
1529
1730
            else:
1534
1735
            else:
1535
1736
                mover = _mover
1536
1737
            try:
1537
 
                child_pb.update('Apply phase', 0 + offset, 2 + offset)
 
1738
                child_pb.update(gettext('Apply phase'), 0 + offset, 2 + offset)
1538
1739
                self._apply_removals(mover)
1539
 
                child_pb.update('Apply phase', 1 + offset, 2 + offset)
 
1740
                child_pb.update(gettext('Apply phase'), 1 + offset, 2 + offset)
1540
1741
                modified_paths = self._apply_insertions(mover)
1541
1742
            except:
1542
1743
                mover.rollback()
1545
1746
                mover.apply_deletions()
1546
1747
        finally:
1547
1748
            child_pb.finished()
 
1749
        if self.final_file_id(self.root) is None:
 
1750
            inventory_delta = [e for e in inventory_delta if e[0] != '']
1548
1751
        self._tree.apply_inventory_delta(inventory_delta)
 
1752
        self._apply_observed_sha1s()
1549
1753
        self._done = True
1550
1754
        self.finalize()
1551
1755
        return _TransformResults(modified_paths, self.rename_count)
1553
1757
    def _generate_inventory_delta(self):
1554
1758
        """Generate an inventory delta for the current transform."""
1555
1759
        inventory_delta = []
1556
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1760
        child_pb = ui.ui_factory.nested_progress_bar()
1557
1761
        new_paths = self._inventory_altered()
1558
1762
        total_entries = len(new_paths) + len(self._removed_id)
1559
1763
        try:
1560
1764
            for num, trans_id in enumerate(self._removed_id):
1561
1765
                if (num % 10) == 0:
1562
 
                    child_pb.update('removing file', num, total_entries)
 
1766
                    child_pb.update(gettext('removing file'), num, total_entries)
1563
1767
                if trans_id == self._new_root:
1564
1768
                    file_id = self._tree.get_root_id()
1565
1769
                else:
1577
1781
            final_kinds = {}
1578
1782
            for num, (path, trans_id) in enumerate(new_paths):
1579
1783
                if (num % 10) == 0:
1580
 
                    child_pb.update('adding file',
 
1784
                    child_pb.update(gettext('adding file'),
1581
1785
                                    num + len(self._removed_id), total_entries)
1582
1786
                file_id = new_path_file_ids[trans_id]
1583
1787
                if file_id is None:
1584
1788
                    continue
1585
1789
                needs_entry = False
1586
 
                try:
1587
 
                    kind = self.final_kind(trans_id)
1588
 
                except NoSuchFile:
 
1790
                kind = self.final_kind(trans_id)
 
1791
                if kind is None:
1589
1792
                    kind = self._tree.stored_kind(file_id)
1590
1793
                parent_trans_id = self.final_parent(trans_id)
1591
1794
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1622
1825
        """
1623
1826
        tree_paths = list(self._tree_path_ids.iteritems())
1624
1827
        tree_paths.sort(reverse=True)
1625
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1828
        child_pb = ui.ui_factory.nested_progress_bar()
1626
1829
        try:
1627
 
            for num, data in enumerate(tree_paths):
1628
 
                path, trans_id = data
1629
 
                child_pb.update('removing file', num, len(tree_paths))
 
1830
            for num, (path, trans_id) in enumerate(tree_paths):
 
1831
                # do not attempt to move root into a subdirectory of itself.
 
1832
                if path == '':
 
1833
                    continue
 
1834
                child_pb.update(gettext('removing file'), num, len(tree_paths))
1630
1835
                full_path = self._tree.abspath(path)
1631
1836
                if trans_id in self._removed_contents:
1632
1837
                    delete_path = os.path.join(self._deletiondir, trans_id)
1635
1840
                      or trans_id in self._new_parent):
1636
1841
                    try:
1637
1842
                        mover.rename(full_path, self._limbo_name(trans_id))
1638
 
                    except OSError, e:
 
1843
                    except errors.TransformRenameFailed, e:
1639
1844
                        if e.errno != errno.ENOENT:
1640
1845
                            raise
1641
1846
                    else:
1657
1862
        modified_paths = []
1658
1863
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1659
1864
                                 new_paths)
1660
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1865
        child_pb = ui.ui_factory.nested_progress_bar()
1661
1866
        try:
1662
1867
            for num, (path, trans_id) in enumerate(new_paths):
1663
1868
                if (num % 10) == 0:
1664
 
                    child_pb.update('adding file', num, len(new_paths))
 
1869
                    child_pb.update(gettext('adding file'), num, len(new_paths))
1665
1870
                full_path = self._tree.abspath(path)
1666
1871
                if trans_id in self._needs_rename:
1667
1872
                    try:
1668
1873
                        mover.rename(self._limbo_name(trans_id), full_path)
1669
 
                    except OSError, e:
 
1874
                    except errors.TransformRenameFailed, e:
1670
1875
                        # We may be renaming a dangling inventory id
1671
1876
                        if e.errno != errno.ENOENT:
1672
1877
                            raise
1673
1878
                    else:
1674
1879
                        self.rename_count += 1
 
1880
                    # TODO: if trans_id in self._observed_sha1s, we should
 
1881
                    #       re-stat the final target, since ctime will be
 
1882
                    #       updated by the change.
1675
1883
                if (trans_id in self._new_contents or
1676
1884
                    self.path_changed(trans_id)):
1677
1885
                    if trans_id in self._new_contents:
1678
1886
                        modified_paths.append(full_path)
1679
1887
                if trans_id in self._new_executability:
1680
1888
                    self._set_executability(path, trans_id)
 
1889
                if trans_id in self._observed_sha1s:
 
1890
                    o_sha1, o_st_val = self._observed_sha1s[trans_id]
 
1891
                    st = osutils.lstat(full_path)
 
1892
                    self._observed_sha1s[trans_id] = (o_sha1, st)
1681
1893
        finally:
1682
1894
            child_pb.finished()
 
1895
        for path, trans_id in new_paths:
 
1896
            # new_paths includes stuff like workingtree conflicts. Only the
 
1897
            # stuff in new_contents actually comes from limbo.
 
1898
            if trans_id in self._limbo_files:
 
1899
                del self._limbo_files[trans_id]
1683
1900
        self._new_contents.clear()
1684
1901
        return modified_paths
1685
1902
 
 
1903
    def _apply_observed_sha1s(self):
 
1904
        """After we have finished renaming everything, update observed sha1s
 
1905
 
 
1906
        This has to be done after self._tree.apply_inventory_delta, otherwise
 
1907
        it doesn't know anything about the files we are updating. Also, we want
 
1908
        to do this as late as possible, so that most entries end up cached.
 
1909
        """
 
1910
        # TODO: this doesn't update the stat information for directories. So
 
1911
        #       the first 'bzr status' will still need to rewrite
 
1912
        #       .bzr/checkout/dirstate. However, we at least don't need to
 
1913
        #       re-read all of the files.
 
1914
        # TODO: If the operation took a while, we could do a time.sleep(3) here
 
1915
        #       to allow the clock to tick over and ensure we won't have any
 
1916
        #       problems. (we could observe start time, and finish time, and if
 
1917
        #       it is less than eg 10% overhead, add a sleep call.)
 
1918
        paths = FinalPaths(self)
 
1919
        for trans_id, observed in self._observed_sha1s.iteritems():
 
1920
            path = paths.get_path(trans_id)
 
1921
            # We could get the file_id, but dirstate prefers to use the path
 
1922
            # anyway, and it is 'cheaper' to determine.
 
1923
            # file_id = self._new_id[trans_id]
 
1924
            self._tree._observed_sha1(None, path, observed)
 
1925
 
1686
1926
 
1687
1927
class TransformPreview(DiskTreeTransform):
1688
1928
    """A TreeTransform for generating preview trees.
1703
1943
    def tree_kind(self, trans_id):
1704
1944
        path = self._tree_id_paths.get(trans_id)
1705
1945
        if path is None:
1706
 
            raise NoSuchFile(None)
1707
 
        file_id = self._tree.path2id(path)
1708
 
        return self._tree.kind(file_id)
 
1946
            return None
 
1947
        kind = self._tree.path_content_summary(path)[0]
 
1948
        if kind == 'missing':
 
1949
            kind = None
 
1950
        return kind
1709
1951
 
1710
1952
    def _set_mode(self, trans_id, mode_id, typefunc):
1711
1953
        """Set the mode of new file contents.
1731
1973
            childpath = joinpath(path, child)
1732
1974
            yield self.trans_id_tree_path(childpath)
1733
1975
 
1734
 
 
1735
 
class _PreviewTree(tree.Tree):
 
1976
    def new_orphan(self, trans_id, parent_id):
 
1977
        raise NotImplementedError(self.new_orphan)
 
1978
 
 
1979
 
 
1980
class _PreviewTree(tree.InventoryTree):
1736
1981
    """Partial implementation of Tree to support show_diff_trees"""
1737
1982
 
1738
1983
    def __init__(self, transform):
1767
2012
                yield self._get_repository().revision_tree(revision_id)
1768
2013
 
1769
2014
    def _get_file_revision(self, file_id, vf, tree_revision):
1770
 
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
2015
        parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
1771
2016
                       self._iter_parent_trees()]
1772
2017
        vf.add_lines((file_id, tree_revision), parent_keys,
1773
 
                     self.get_file(file_id).readlines())
 
2018
                     self.get_file_lines(file_id))
1774
2019
        repo = self._get_repository()
1775
2020
        base_vf = repo.texts
1776
2021
        if base_vf not in vf.fallback_versionedfiles:
1777
2022
            vf.fallback_versionedfiles.append(base_vf)
1778
2023
        return tree_revision
1779
2024
 
1780
 
    def _stat_limbo_file(self, file_id):
1781
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2025
    def _stat_limbo_file(self, file_id=None, trans_id=None):
 
2026
        if trans_id is None:
 
2027
            trans_id = self._transform.trans_id_file_id(file_id)
1782
2028
        name = self._transform._limbo_name(trans_id)
1783
2029
        return os.lstat(name)
1784
2030
 
1798
2044
            executable = self.is_executable(file_id, path)
1799
2045
        return kind, executable, None
1800
2046
 
 
2047
    def is_locked(self):
 
2048
        return False
 
2049
 
1801
2050
    def lock_read(self):
1802
2051
        # Perhaps in theory, this should lock the TreeTransform?
1803
 
        pass
 
2052
        return self
1804
2053
 
1805
2054
    def unlock(self):
1806
2055
        pass
1904
2153
            if (specific_file_ids is not None
1905
2154
                and file_id not in specific_file_ids):
1906
2155
                continue
1907
 
            try:
1908
 
                kind = self._transform.final_kind(trans_id)
1909
 
            except NoSuchFile:
 
2156
            kind = self._transform.final_kind(trans_id)
 
2157
            if kind is None:
1910
2158
                kind = self._transform._tree.stored_kind(file_id)
1911
2159
            new_entry = inventory.make_entry(
1912
2160
                kind,
1997
2245
 
1998
2246
    def get_file_size(self, file_id):
1999
2247
        """See Tree.get_file_size"""
 
2248
        trans_id = self._transform.trans_id_file_id(file_id)
 
2249
        kind = self._transform.final_kind(trans_id)
 
2250
        if kind != 'file':
 
2251
            return None
 
2252
        if trans_id in self._transform._new_contents:
 
2253
            return self._stat_limbo_file(trans_id=trans_id).st_size
2000
2254
        if self.kind(file_id) == 'file':
2001
2255
            return self._transform._tree.get_file_size(file_id)
2002
2256
        else:
2003
2257
            return None
2004
2258
 
 
2259
    def get_file_verifier(self, file_id, path=None, stat_value=None):
 
2260
        trans_id = self._transform.trans_id_file_id(file_id)
 
2261
        kind = self._transform._new_contents.get(trans_id)
 
2262
        if kind is None:
 
2263
            return self._transform._tree.get_file_verifier(file_id)
 
2264
        if kind == 'file':
 
2265
            fileobj = self.get_file(file_id)
 
2266
            try:
 
2267
                return ("SHA1", sha_file(fileobj))
 
2268
            finally:
 
2269
                fileobj.close()
 
2270
 
2005
2271
    def get_file_sha1(self, file_id, path=None, stat_value=None):
2006
2272
        trans_id = self._transform.trans_id_file_id(file_id)
2007
2273
        kind = self._transform._new_contents.get(trans_id)
2030
2296
            except errors.NoSuchId:
2031
2297
                return False
2032
2298
 
 
2299
    def has_filename(self, path):
 
2300
        trans_id = self._path2trans_id(path)
 
2301
        if trans_id in self._transform._new_contents:
 
2302
            return True
 
2303
        elif trans_id in self._transform._removed_contents:
 
2304
            return False
 
2305
        else:
 
2306
            return self._transform._tree.has_filename(path)
 
2307
 
2033
2308
    def path_content_summary(self, path):
2034
2309
        trans_id = self._path2trans_id(path)
2035
2310
        tt = self._transform
2123
2398
                                   self.get_file(file_id).readlines(),
2124
2399
                                   default_revision)
2125
2400
 
2126
 
    def get_symlink_target(self, file_id):
 
2401
    def get_symlink_target(self, file_id, path=None):
2127
2402
        """See Tree.get_symlink_target"""
2128
2403
        if not self._content_change(file_id):
2129
2404
            return self._transform._tree.get_symlink_target(file_id)
2144
2419
                path_from_root = self._final_paths.get_path(child_id)
2145
2420
                basename = self._transform.final_name(child_id)
2146
2421
                file_id = self._transform.final_file_id(child_id)
2147
 
                try:
2148
 
                    kind = self._transform.final_kind(child_id)
 
2422
                kind  = self._transform.final_kind(child_id)
 
2423
                if kind is not None:
2149
2424
                    versioned_kind = kind
2150
 
                except NoSuchFile:
 
2425
                else:
2151
2426
                    kind = 'unknown'
2152
2427
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2153
2428
                if versioned_kind == 'directory':
2266
2541
    for num, _unused in enumerate(wt.all_file_ids()):
2267
2542
        if num > 0:  # more than just a root
2268
2543
            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
2544
    file_trans_id = {}
2273
 
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2545
    top_pb = ui.ui_factory.nested_progress_bar()
2274
2546
    pp = ProgressPhase("Build phase", 2, top_pb)
2275
 
    if tree.inventory.root is not None:
 
2547
    if tree.get_root_id() is not None:
2276
2548
        # This is kind of a hack: we should be altering the root
2277
2549
        # as part of the regular tree shape diff logic.
2278
2550
        # The conditional test here is to avoid doing an
2289
2561
        pp.next_phase()
2290
2562
        file_trans_id[wt.get_root_id()] = \
2291
2563
            tt.trans_id_tree_file_id(wt.get_root_id())
2292
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2564
        pb = ui.ui_factory.nested_progress_bar()
2293
2565
        try:
2294
2566
            deferred_contents = []
2295
2567
            num = 0
2296
 
            total = len(tree.inventory)
 
2568
            total = len(tree.all_file_ids())
2297
2569
            if delta_from_tree:
2298
2570
                precomputed_delta = []
2299
2571
            else:
2300
2572
                precomputed_delta = None
 
2573
            # Check if tree inventory has content. If so, we populate
 
2574
            # existing_files with the directory content. If there are no
 
2575
            # entries we skip populating existing_files as its not used.
 
2576
            # This improves performance and unncessary work on large
 
2577
            # directory trees. (#501307)
 
2578
            if total > 0:
 
2579
                existing_files = set()
 
2580
                for dir, files in wt.walkdirs():
 
2581
                    existing_files.update(f[0] for f in files)
2301
2582
            for num, (tree_path, entry) in \
2302
 
                enumerate(tree.inventory.iter_entries_by_dir()):
2303
 
                pb.update("Building tree", num - len(deferred_contents), total)
 
2583
                enumerate(tree.iter_entries_by_dir()):
 
2584
                pb.update(gettext("Building tree"), num - len(deferred_contents), total)
2304
2585
                if entry.parent_id is None:
2305
2586
                    continue
2306
2587
                reparent = False
2312
2593
                    kind = file_kind(target_path)
2313
2594
                    if kind == "directory":
2314
2595
                        try:
2315
 
                            bzrdir.BzrDir.open(target_path)
 
2596
                            controldir.ControlDir.open(target_path)
2316
2597
                        except errors.NotBranchError:
2317
2598
                            pass
2318
2599
                        else:
2333
2614
                    executable = tree.is_executable(file_id, tree_path)
2334
2615
                    if executable:
2335
2616
                        tt.set_executability(executable, trans_id)
2336
 
                    trans_data = (trans_id, tree_path)
 
2617
                    trans_data = (trans_id, tree_path, entry.text_sha1)
2337
2618
                    deferred_contents.append((file_id, trans_data))
2338
2619
                else:
2339
2620
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2355
2636
            precomputed_delta = None
2356
2637
        conflicts = cook_conflicts(raw_conflicts, tt)
2357
2638
        for conflict in conflicts:
2358
 
            warning(conflict)
 
2639
            trace.warning(unicode(conflict))
2359
2640
        try:
2360
2641
            wt.add_conflicts(conflicts)
2361
2642
        except errors.UnsupportedOperation:
2384
2665
        unchanged = dict(unchanged)
2385
2666
        new_desired_files = []
2386
2667
        count = 0
2387
 
        for file_id, (trans_id, tree_path) in desired_files:
 
2668
        for file_id, (trans_id, tree_path, text_sha1) in desired_files:
2388
2669
            accelerator_path = unchanged.get(file_id)
2389
2670
            if accelerator_path is None:
2390
 
                new_desired_files.append((file_id, (trans_id, tree_path)))
 
2671
                new_desired_files.append((file_id,
 
2672
                    (trans_id, tree_path, text_sha1)))
2391
2673
                continue
2392
 
            pb.update('Adding file contents', count + offset, total)
 
2674
            pb.update(gettext('Adding file contents'), count + offset, total)
2393
2675
            if hardlink:
2394
2676
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2395
2677
                                   trans_id)
2400
2682
                    contents = filtered_output_bytes(contents, filters,
2401
2683
                        ContentFilterContext(tree_path, tree))
2402
2684
                try:
2403
 
                    tt.create_file(contents, trans_id)
 
2685
                    tt.create_file(contents, trans_id, sha1=text_sha1)
2404
2686
                finally:
2405
2687
                    try:
2406
2688
                        contents.close()
2409
2691
                        pass
2410
2692
            count += 1
2411
2693
        offset += count
2412
 
    for count, ((trans_id, tree_path), contents) in enumerate(
 
2694
    for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
2413
2695
            tree.iter_files_bytes(new_desired_files)):
2414
2696
        if wt.supports_content_filtering():
2415
2697
            filters = wt._content_filter_stack(tree_path)
2416
2698
            contents = filtered_output_bytes(contents, filters,
2417
2699
                ContentFilterContext(tree_path, tree))
2418
 
        tt.create_file(contents, trans_id)
2419
 
        pb.update('Adding file contents', count + offset, total)
 
2700
        tt.create_file(contents, trans_id, sha1=text_sha1)
 
2701
        pb.update(gettext('Adding file contents'), count + offset, total)
2420
2702
 
2421
2703
 
2422
2704
def _reparent_children(tt, old_parent, new_parent):
2423
2705
    for child in tt.iter_tree_children(old_parent):
2424
2706
        tt.adjust_path(tt.final_name(child), new_parent, child)
2425
2707
 
 
2708
 
2426
2709
def _reparent_transform_children(tt, old_parent, new_parent):
2427
2710
    by_parent = tt.by_parent()
2428
2711
    for child in by_parent[old_parent]:
2429
2712
        tt.adjust_path(tt.final_name(child), new_parent, child)
2430
2713
    return by_parent[old_parent]
2431
2714
 
 
2715
 
2432
2716
def _content_match(tree, entry, file_id, kind, target_path):
2433
2717
    if entry.kind != kind:
2434
2718
        return False
2435
2719
    if entry.kind == "directory":
2436
2720
        return True
2437
2721
    if entry.kind == "file":
2438
 
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
2439
 
            return True
 
2722
        f = file(target_path, 'rb')
 
2723
        try:
 
2724
            if tree.get_file_text(file_id) == f.read():
 
2725
                return True
 
2726
        finally:
 
2727
            f.close()
2440
2728
    elif entry.kind == "symlink":
2441
2729
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2442
2730
            return True
2494
2782
        raise errors.BadFileKindError(name, kind)
2495
2783
 
2496
2784
 
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
2785
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2514
2786
    filter_tree_path=None):
2515
2787
    """Create new file contents according to tree contents.
2546
2818
        tt.set_executability(entry.executable, trans_id)
2547
2819
 
2548
2820
 
 
2821
@deprecated_function(deprecated_in((2, 3, 0)))
2549
2822
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2550
2823
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2551
2824
 
2552
2825
 
 
2826
@deprecated_function(deprecated_in((2, 3, 0)))
2553
2827
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2554
2828
    """Produce a backup-style name that appears to be available"""
2555
2829
    def name_gen():
2562
2836
            return new_name
2563
2837
 
2564
2838
 
2565
 
def _entry_changes(file_id, entry, working_tree):
2566
 
    """Determine in which ways the inventory entry has changed.
2567
 
 
2568
 
    Returns booleans: has_contents, content_mod, meta_mod
2569
 
    has_contents means there are currently contents, but they differ
2570
 
    contents_mod means contents need to be modified
2571
 
    meta_mod means the metadata needs to be modified
2572
 
    """
2573
 
    cur_entry = working_tree.inventory[file_id]
2574
 
    try:
2575
 
        working_kind = working_tree.kind(file_id)
2576
 
        has_contents = True
2577
 
    except NoSuchFile:
2578
 
        has_contents = False
2579
 
        contents_mod = True
2580
 
        meta_mod = False
2581
 
    if has_contents is True:
2582
 
        if entry.kind != working_kind:
2583
 
            contents_mod, meta_mod = True, False
2584
 
        else:
2585
 
            cur_entry._read_tree_state(working_tree.id2path(file_id),
2586
 
                                       working_tree)
2587
 
            contents_mod, meta_mod = entry.detect_changes(cur_entry)
2588
 
            cur_entry._forget_tree_state()
2589
 
    return has_contents, contents_mod, meta_mod
2590
 
 
2591
 
 
2592
2839
def revert(working_tree, target_tree, filenames, backups=False,
2593
2840
           pb=None, change_reporter=None):
2594
2841
    """Revert a working tree's contents to those of a target tree."""
2604
2851
                unversioned_filter=working_tree.is_ignored)
2605
2852
            delta.report_changes(tt.iter_changes(), change_reporter)
2606
2853
        for conflict in conflicts:
2607
 
            warning(conflict)
 
2854
            trace.warning(unicode(conflict))
2608
2855
        pp.next_phase()
2609
2856
        tt.apply()
2610
2857
        working_tree.set_merge_modified(merge_modified)
2618
2865
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2619
2866
                              backups, pp, basis_tree=None,
2620
2867
                              merge_modified=None):
2621
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2868
    child_pb = ui.ui_factory.nested_progress_bar()
2622
2869
    try:
2623
2870
        if merge_modified is None:
2624
2871
            merge_modified = working_tree.merge_modified()
2627
2874
                                      merge_modified, basis_tree)
2628
2875
    finally:
2629
2876
        child_pb.finished()
2630
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2877
    child_pb = ui.ui_factory.nested_progress_bar()
2631
2878
    try:
2632
2879
        raw_conflicts = resolve_conflicts(tt, child_pb,
2633
2880
            lambda t, c: conflict_pass(t, c, target_tree))
2641
2888
                 backups, merge_modified, basis_tree=None):
2642
2889
    if basis_tree is not None:
2643
2890
        basis_tree.lock_read()
2644
 
    change_list = target_tree.iter_changes(working_tree,
 
2891
    # We ask the working_tree for its changes relative to the target, rather
 
2892
    # than the target changes relative to the working tree. Because WT4 has an
 
2893
    # optimizer to compare itself to a target, but no optimizer for the
 
2894
    # reverse.
 
2895
    change_list = working_tree.iter_changes(target_tree,
2645
2896
        specific_files=specific_files, pb=pb)
2646
2897
    if target_tree.get_root_id() is None:
2647
2898
        skip_root = True
2651
2902
        deferred_files = []
2652
2903
        for id_num, (file_id, path, changed_content, versioned, parent, name,
2653
2904
                kind, executable) in enumerate(change_list):
2654
 
            if skip_root and file_id[0] is not None and parent[0] is None:
 
2905
            target_path, wt_path = path
 
2906
            target_versioned, wt_versioned = versioned
 
2907
            target_parent, wt_parent = parent
 
2908
            target_name, wt_name = name
 
2909
            target_kind, wt_kind = kind
 
2910
            target_executable, wt_executable = executable
 
2911
            if skip_root and wt_parent is None:
2655
2912
                continue
2656
2913
            trans_id = tt.trans_id_file_id(file_id)
2657
2914
            mode_id = None
2658
2915
            if changed_content:
2659
2916
                keep_content = False
2660
 
                if kind[0] == 'file' and (backups or kind[1] is None):
 
2917
                if wt_kind == 'file' and (backups or target_kind is None):
2661
2918
                    wt_sha1 = working_tree.get_file_sha1(file_id)
2662
2919
                    if merge_modified.get(file_id) != wt_sha1:
2663
2920
                        # acquire the basis tree lazily to prevent the
2666
2923
                        if basis_tree is None:
2667
2924
                            basis_tree = working_tree.basis_tree()
2668
2925
                            basis_tree.lock_read()
2669
 
                        if file_id in basis_tree:
 
2926
                        if basis_tree.has_id(file_id):
2670
2927
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
2671
2928
                                keep_content = True
2672
 
                        elif kind[1] is None and not versioned[1]:
 
2929
                        elif target_kind is None and not target_versioned:
2673
2930
                            keep_content = True
2674
 
                if kind[0] is not None:
 
2931
                if wt_kind is not None:
2675
2932
                    if not keep_content:
2676
2933
                        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)
 
2934
                    elif target_kind is not None:
 
2935
                        parent_trans_id = tt.trans_id_file_id(wt_parent)
 
2936
                        backup_name = tt._available_backup_name(
 
2937
                            wt_name, parent_trans_id)
2682
2938
                        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):
 
2939
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
 
2940
                        if wt_versioned and target_versioned:
2685
2941
                            tt.unversion_file(trans_id)
2686
2942
                            tt.version_file(file_id, new_trans_id)
2687
2943
                        # New contents should have the same unix perms as old
2688
2944
                        # contents
2689
2945
                        mode_id = trans_id
2690
2946
                        trans_id = new_trans_id
2691
 
                if kind[1] in ('directory', 'tree-reference'):
 
2947
                if target_kind in ('directory', 'tree-reference'):
2692
2948
                    tt.create_directory(trans_id)
2693
 
                    if kind[1] == 'tree-reference':
 
2949
                    if target_kind == 'tree-reference':
2694
2950
                        revision = target_tree.get_reference_revision(file_id,
2695
 
                                                                      path[1])
 
2951
                                                                      target_path)
2696
2952
                        tt.set_tree_reference(revision, trans_id)
2697
 
                elif kind[1] == 'symlink':
 
2953
                elif target_kind == 'symlink':
2698
2954
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
2699
2955
                                      trans_id)
2700
 
                elif kind[1] == 'file':
 
2956
                elif target_kind == 'file':
2701
2957
                    deferred_files.append((file_id, (trans_id, mode_id)))
2702
2958
                    if basis_tree is None:
2703
2959
                        basis_tree = working_tree.basis_tree()
2704
2960
                        basis_tree.lock_read()
2705
2961
                    new_sha1 = target_tree.get_file_sha1(file_id)
2706
 
                    if (file_id in basis_tree and new_sha1 ==
2707
 
                        basis_tree.get_file_sha1(file_id)):
 
2962
                    if (basis_tree.has_id(file_id) and
 
2963
                        new_sha1 == basis_tree.get_file_sha1(file_id)):
2708
2964
                        if file_id in merge_modified:
2709
2965
                            del merge_modified[file_id]
2710
2966
                    else:
2711
2967
                        merge_modified[file_id] = new_sha1
2712
2968
 
2713
2969
                    # 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):
 
2970
                    if keep_content and wt_executable == target_executable:
 
2971
                        tt.set_executability(target_executable, trans_id)
 
2972
                elif target_kind is not None:
 
2973
                    raise AssertionError(target_kind)
 
2974
            if not wt_versioned and target_versioned:
2719
2975
                tt.version_file(file_id, trans_id)
2720
 
            if versioned == (True, False):
 
2976
            if wt_versioned and not target_versioned:
2721
2977
                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:
 
2978
            if (target_name is not None and
 
2979
                (wt_name != target_name or wt_parent != target_parent)):
 
2980
                if target_name == '' and target_parent is None:
2725
2981
                    parent_trans = ROOT_PARENT
2726
2982
                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)
 
2983
                    parent_trans = tt.trans_id_file_id(target_parent)
 
2984
                if wt_parent is None and wt_versioned:
 
2985
                    tt.adjust_root_path(target_name, parent_trans)
2730
2986
                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)
 
2987
                    tt.adjust_path(target_name, parent_trans, trans_id)
 
2988
            if wt_executable != target_executable and target_kind == "file":
 
2989
                tt.set_executability(target_executable, trans_id)
2734
2990
        if working_tree.supports_content_filtering():
2735
2991
            for index, ((trans_id, mode_id), bytes) in enumerate(
2736
2992
                target_tree.iter_files_bytes(deferred_files)):
2762
3018
    pb = ui.ui_factory.nested_progress_bar()
2763
3019
    try:
2764
3020
        for n in range(10):
2765
 
            pb.update('Resolution pass', n+1, 10)
 
3021
            pb.update(gettext('Resolution pass'), n+1, 10)
2766
3022
            conflicts = tt.find_conflicts()
2767
3023
            if len(conflicts) == 0:
2768
3024
                return new_conflicts
2792
3048
                existing_file, new_file = conflict[2], conflict[1]
2793
3049
            else:
2794
3050
                existing_file, new_file = conflict[1], conflict[2]
2795
 
            new_name = tt.final_name(existing_file)+'.moved'
 
3051
            new_name = tt.final_name(existing_file) + '.moved'
2796
3052
            tt.adjust_path(new_name, final_parent, existing_file)
2797
3053
            new_conflicts.add((c_type, 'Moved existing file to',
2798
3054
                               existing_file, new_file))
2807
3063
 
2808
3064
        elif c_type == 'missing parent':
2809
3065
            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:
 
3066
            if trans_id in tt._removed_contents:
 
3067
                cancel_deletion = True
 
3068
                orphans = tt._get_potential_orphans(trans_id)
 
3069
                if orphans:
 
3070
                    cancel_deletion = False
 
3071
                    # All children are orphans
 
3072
                    for o in orphans:
 
3073
                        try:
 
3074
                            tt.new_orphan(o, trans_id)
 
3075
                        except OrphaningError:
 
3076
                            # Something bad happened so we cancel the directory
 
3077
                            # deletion which will leave it in place with a
 
3078
                            # conflict. The user can deal with it from there.
 
3079
                            # Note that this also catch the case where we don't
 
3080
                            # want to create orphans and leave the directory in
 
3081
                            # place.
 
3082
                            cancel_deletion = True
 
3083
                            break
 
3084
                if cancel_deletion:
 
3085
                    # Cancel the directory deletion
 
3086
                    tt.cancel_deletion(trans_id)
 
3087
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
3088
                                       trans_id))
 
3089
            else:
2815
3090
                create = True
2816
3091
                try:
2817
3092
                    tt.final_name(trans_id)
2820
3095
                        file_id = tt.final_file_id(trans_id)
2821
3096
                        if file_id is None:
2822
3097
                            file_id = tt.inactive_file_id(trans_id)
2823
 
                        entry = path_tree.inventory[file_id]
 
3098
                        _, entry = path_tree.iter_entries_by_dir(
 
3099
                            [file_id]).next()
2824
3100
                        # special-case the other tree root (move its
2825
3101
                        # children to current root)
2826
3102
                        if entry.parent_id is None:
2841
3117
        elif c_type == 'unversioned parent':
2842
3118
            file_id = tt.inactive_file_id(conflict[1])
2843
3119
            # special-case the other tree root (move its children instead)
2844
 
            if path_tree and file_id in path_tree:
2845
 
                if path_tree.inventory[file_id].parent_id is None:
 
3120
            if path_tree and path_tree.has_id(file_id):
 
3121
                if path_tree.path2id('') == file_id:
 
3122
                    # This is the root entry, skip it
2846
3123
                    continue
2847
3124
            tt.version_file(file_id, conflict[1])
2848
3125
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2864
3141
 
2865
3142
def cook_conflicts(raw_conflicts, tt):
2866
3143
    """Generate a list of cooked conflicts, sorted by file path"""
2867
 
    from bzrlib.conflicts import Conflict
2868
3144
    conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
2869
 
    return sorted(conflict_iter, key=Conflict.sort_key)
 
3145
    return sorted(conflict_iter, key=conflicts.Conflict.sort_key)
2870
3146
 
2871
3147
 
2872
3148
def iter_cook_conflicts(raw_conflicts, tt):
2873
 
    from bzrlib.conflicts import Conflict
2874
3149
    fp = FinalPaths(tt)
2875
3150
    for conflict in raw_conflicts:
2876
3151
        c_type = conflict[0]
2878
3153
        modified_path = fp.get_path(conflict[2])
2879
3154
        modified_id = tt.final_file_id(conflict[2])
2880
3155
        if len(conflict) == 3:
2881
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
2882
 
                                     file_id=modified_id)
 
3156
            yield conflicts.Conflict.factory(
 
3157
                c_type, action=action, path=modified_path, file_id=modified_id)
2883
3158
 
2884
3159
        else:
2885
3160
            conflicting_path = fp.get_path(conflict[3])
2886
3161
            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)
 
3162
            yield conflicts.Conflict.factory(
 
3163
                c_type, action=action, path=modified_path,
 
3164
                file_id=modified_id,
 
3165
                conflict_path=conflicting_path,
 
3166
                conflict_file_id=conflicting_id)
2891
3167
 
2892
3168
 
2893
3169
class _FileMover(object):
2900
3176
    def rename(self, from_, to):
2901
3177
        """Rename a file from one path to another."""
2902
3178
        try:
2903
 
            osutils.rename(from_, to)
 
3179
            os.rename(from_, to)
2904
3180
        except OSError, e:
2905
3181
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2906
3182
                raise errors.FileExists(to, str(e))
2907
 
            raise
 
3183
            # normal OSError doesn't include filenames so it's hard to see where
 
3184
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
 
3185
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
2908
3186
        self.past_renames.append((from_, to))
2909
3187
 
2910
3188
    def pre_delete(self, from_, to):
2920
3198
    def rollback(self):
2921
3199
        """Reverse all renames that have been performed"""
2922
3200
        for from_, to in reversed(self.past_renames):
2923
 
            osutils.rename(to, from_)
 
3201
            try:
 
3202
                os.rename(to, from_)
 
3203
            except OSError, e:
 
3204
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2924
3205
        # after rollback, don't reuse _FileMover
2925
3206
        past_renames = None
2926
3207
        pending_deletions = None