← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-08-14 05:49:27 UTC
  • mfrom: (4476.3.86 inventory-delta)
  • Revision ID: pqm@pqm.ubuntu.com-20090814054927-k0k18dn46ax4b91f
(andrew) Add inventory-delta streaming for cross-format fetch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008, 2009 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
17
17
import os
18
18
import errno
19
19
from stat import S_ISREG, S_IEXEC
20
 
import time
21
20
 
22
21
from bzrlib.lazy_import import lazy_import
23
22
lazy_import(globals(), """
25
24
    annotate,
26
25
    bencode,
27
26
    bzrdir,
28
 
    commit,
29
27
    delta,
30
28
    errors,
31
29
    inventory,
32
30
    multiparent,
33
31
    osutils,
34
32
    revision as _mod_revision,
35
 
    ui,
36
33
    )
37
34
""")
38
35
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
39
 
                           ReusingTransform, CantMoveRoot,
 
36
                           ReusingTransform, NotVersionedError, CantMoveRoot,
40
37
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
41
38
                           UnableCreateSymlink)
42
39
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
51
48
    splitpath,
52
49
    supports_executable,
53
50
)
54
 
from bzrlib.progress import ProgressPhase
 
51
from bzrlib.progress import DummyProgress, ProgressPhase
55
52
from bzrlib.symbol_versioning import (
56
53
        deprecated_function,
57
54
        deprecated_in,
81
78
class TreeTransformBase(object):
82
79
    """The base class for TreeTransform and its kin."""
83
80
 
84
 
    def __init__(self, tree, pb=None,
 
81
    def __init__(self, tree, pb=DummyProgress(),
85
82
                 case_sensitive=True):
86
83
        """Constructor.
87
84
 
88
85
        :param tree: The tree that will be transformed, but not necessarily
89
86
            the output tree.
90
 
        :param pb: ignored
 
87
        :param pb: A ProgressTask indicating how much progress is being made
91
88
        :param case_sensitive: If True, the target of the transform is
92
89
            case sensitive, not just case preserving.
93
90
        """
164
161
 
165
162
    def adjust_path(self, name, parent, trans_id):
166
163
        """Change the path that is assigned to a transaction id."""
167
 
        if parent is None:
168
 
            raise ValueError("Parent trans-id may not be None")
169
164
        if trans_id == self._new_root:
170
165
            raise CantMoveRoot
171
166
        self._new_name[trans_id] = name
172
167
        self._new_parent[trans_id] = parent
 
168
        if parent == ROOT_PARENT:
 
169
            if self._new_root is not None:
 
170
                raise ValueError("Cannot have multiple roots.")
 
171
            self._new_root = trans_id
173
172
 
174
173
    def adjust_root_path(self, name, parent):
175
174
        """Emulate moving the root by moving all children, instead.
203
202
        self.version_file(old_root_file_id, old_root)
204
203
        self.unversion_file(self._new_root)
205
204
 
206
 
    def fixup_new_roots(self):
207
 
        """Reinterpret requests to change the root directory
208
 
 
209
 
        Instead of creating a root directory, or moving an existing directory,
210
 
        all the attributes and children of the new root are applied to the
211
 
        existing root directory.
212
 
 
213
 
        This means that the old root trans-id becomes obsolete, so it is
214
 
        recommended only to invoke this after the root trans-id has become
215
 
        irrelevant.
216
 
        """
217
 
        new_roots = [k for k, v in self._new_parent.iteritems() if v is
218
 
                     ROOT_PARENT]
219
 
        if len(new_roots) < 1:
220
 
            return
221
 
        if len(new_roots) != 1:
222
 
            raise ValueError('A tree cannot have two roots!')
223
 
        if self._new_root is None:
224
 
            self._new_root = new_roots[0]
225
 
            return
226
 
        old_new_root = new_roots[0]
227
 
        # TODO: What to do if a old_new_root is present, but self._new_root is
228
 
        #       not listed as being removed? This code explicitly unversions
229
 
        #       the old root and versions it with the new file_id. Though that
230
 
        #       seems like an incomplete delta
231
 
 
232
 
        # unversion the new root's directory.
233
 
        file_id = self.final_file_id(old_new_root)
234
 
        if old_new_root in self._new_id:
235
 
            self.cancel_versioning(old_new_root)
236
 
        else:
237
 
            self.unversion_file(old_new_root)
238
 
        # if, at this stage, root still has an old file_id, zap it so we can
239
 
        # stick a new one in.
240
 
        if (self.tree_file_id(self._new_root) is not None and
241
 
            self._new_root not in self._removed_id):
242
 
            self.unversion_file(self._new_root)
243
 
        self.version_file(file_id, self._new_root)
244
 
 
245
 
        # Now move children of new root into old root directory.
246
 
        # Ensure all children are registered with the transaction, but don't
247
 
        # use directly-- some tree children have new parents
248
 
        list(self.iter_tree_children(old_new_root))
249
 
        # Move all children of new root into old root directory.
250
 
        for child in self.by_parent().get(old_new_root, []):
251
 
            self.adjust_path(self.final_name(child), self._new_root, child)
252
 
 
253
 
        # Ensure old_new_root has no directory.
254
 
        if old_new_root in self._new_contents:
255
 
            self.cancel_creation(old_new_root)
256
 
        else:
257
 
            self.delete_contents(old_new_root)
258
 
 
259
 
        # prevent deletion of root directory.
260
 
        if self._new_root in self._removed_contents:
261
 
            self.cancel_deletion(self._new_root)
262
 
 
263
 
        # destroy path info for old_new_root.
264
 
        del self._new_parent[old_new_root]
265
 
        del self._new_name[old_new_root]
266
 
 
267
205
    def trans_id_tree_file_id(self, inventory_id):
268
206
        """Determine the transaction id of a working tree file.
269
207
 
315
253
 
316
254
    def delete_contents(self, trans_id):
317
255
        """Schedule the contents of a path entry for deletion"""
318
 
        # Ensure that the object exists in the WorkingTree, this will raise an
319
 
        # exception if there is a problem
320
256
        self.tree_kind(trans_id)
321
257
        self._removed_contents.add(trans_id)
322
258
 
923
859
    def get_preview_tree(self):
924
860
        """Return a tree representing the result of the transform.
925
861
 
926
 
        The tree is a snapshot, and altering the TreeTransform will invalidate
927
 
        it.
 
862
        This tree only supports the subset of Tree functionality required
 
863
        by show_diff_trees.  It must only be compared to tt._tree.
928
864
        """
929
865
        return _PreviewTree(self)
930
866
 
931
 
    def commit(self, branch, message, merge_parents=None, strict=False,
932
 
               timestamp=None, timezone=None, committer=None, authors=None,
933
 
               revprops=None, revision_id=None):
 
867
    def commit(self, branch, message, merge_parents=None, strict=False):
934
868
        """Commit the result of this TreeTransform to a branch.
935
869
 
936
870
        :param branch: The branch to commit to.
937
871
        :param message: The message to attach to the commit.
938
 
        :param merge_parents: Additional parent revision-ids specified by
939
 
            pending merges.
940
 
        :param strict: If True, abort the commit if there are unversioned
941
 
            files.
942
 
        :param timestamp: if not None, seconds-since-epoch for the time and
943
 
            date.  (May be a float.)
944
 
        :param timezone: Optional timezone for timestamp, as an offset in
945
 
            seconds.
946
 
        :param committer: Optional committer in email-id format.
947
 
            (e.g. "J Random Hacker <jrandom@example.com>")
948
 
        :param authors: Optional list of authors in email-id format.
949
 
        :param revprops: Optional dictionary of revision properties.
950
 
        :param revision_id: Optional revision id.  (Specifying a revision-id
951
 
            may reduce performance for some non-native formats.)
 
872
        :param merge_parents: Additional parents specified by pending merges.
952
873
        :return: The revision_id of the revision committed.
953
874
        """
954
875
        self._check_malformed()
971
892
        if self._tree.get_revision_id() != last_rev_id:
972
893
            raise ValueError('TreeTransform not based on branch basis: %s' %
973
894
                             self._tree.get_revision_id())
974
 
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
975
 
        builder = branch.get_commit_builder(parent_ids,
976
 
                                            timestamp=timestamp,
977
 
                                            timezone=timezone,
978
 
                                            committer=committer,
979
 
                                            revprops=revprops,
980
 
                                            revision_id=revision_id)
 
895
        builder = branch.get_commit_builder(parent_ids)
981
896
        preview = self.get_preview_tree()
982
897
        list(builder.record_iter_changes(preview, last_rev_id,
983
898
                                         self.iter_changes()))
1085
1000
class DiskTreeTransform(TreeTransformBase):
1086
1001
    """Tree transform storing its contents on disk."""
1087
1002
 
1088
 
    def __init__(self, tree, limbodir, pb=None,
 
1003
    def __init__(self, tree, limbodir, pb=DummyProgress(),
1089
1004
                 case_sensitive=True):
1090
1005
        """Constructor.
1091
1006
        :param tree: The tree that will be transformed, but not necessarily
1092
1007
            the output tree.
1093
1008
        :param limbodir: A directory where new files can be stored until
1094
1009
            they are installed in their proper places
1095
 
        :param pb: ignored
 
1010
        :param pb: A ProgressBar indicating how much progress is being made
1096
1011
        :param case_sensitive: If True, the target of the transform is
1097
1012
            case sensitive, not just case preserving.
1098
1013
        """
1108
1023
        self._limbo_children_names = {}
1109
1024
        # List of transform ids that need to be renamed from limbo into place
1110
1025
        self._needs_rename = set()
1111
 
        self._creation_mtime = None
1112
1026
 
1113
1027
    def finalize(self):
1114
1028
        """Release the working tree lock, if held, clean up limbo dir.
1140
1054
    def _limbo_name(self, trans_id):
1141
1055
        """Generate the limbo name of a file"""
1142
1056
        limbo_name = self._limbo_files.get(trans_id)
1143
 
        if limbo_name is None:
1144
 
            limbo_name = self._generate_limbo_path(trans_id)
1145
 
            self._limbo_files[trans_id] = limbo_name
 
1057
        if limbo_name is not None:
 
1058
            return limbo_name
 
1059
        parent = self._new_parent.get(trans_id)
 
1060
        # if the parent directory is already in limbo (e.g. when building a
 
1061
        # tree), choose a limbo name inside the parent, to reduce further
 
1062
        # renames.
 
1063
        use_direct_path = False
 
1064
        if self._new_contents.get(parent) == 'directory':
 
1065
            filename = self._new_name.get(trans_id)
 
1066
            if filename is not None:
 
1067
                if parent not in self._limbo_children:
 
1068
                    self._limbo_children[parent] = set()
 
1069
                    self._limbo_children_names[parent] = {}
 
1070
                    use_direct_path = True
 
1071
                # the direct path can only be used if no other file has
 
1072
                # already taken this pathname, i.e. if the name is unused, or
 
1073
                # if it is already associated with this trans_id.
 
1074
                elif self._case_sensitive_target:
 
1075
                    if (self._limbo_children_names[parent].get(filename)
 
1076
                        in (trans_id, None)):
 
1077
                        use_direct_path = True
 
1078
                else:
 
1079
                    for l_filename, l_trans_id in\
 
1080
                        self._limbo_children_names[parent].iteritems():
 
1081
                        if l_trans_id == trans_id:
 
1082
                            continue
 
1083
                        if l_filename.lower() == filename.lower():
 
1084
                            break
 
1085
                    else:
 
1086
                        use_direct_path = True
 
1087
 
 
1088
        if use_direct_path:
 
1089
            limbo_name = pathjoin(self._limbo_files[parent], filename)
 
1090
            self._limbo_children[parent].add(trans_id)
 
1091
            self._limbo_children_names[parent][filename] = trans_id
 
1092
        else:
 
1093
            limbo_name = pathjoin(self._limbodir, trans_id)
 
1094
            self._needs_rename.add(trans_id)
 
1095
        self._limbo_files[trans_id] = limbo_name
1146
1096
        return limbo_name
1147
1097
 
1148
 
    def _generate_limbo_path(self, trans_id):
1149
 
        """Generate a limbo path using the trans_id as the relative path.
1150
 
 
1151
 
        This is suitable as a fallback, and when the transform should not be
1152
 
        sensitive to the path encoding of the limbo directory.
1153
 
        """
1154
 
        self._needs_rename.add(trans_id)
1155
 
        return pathjoin(self._limbodir, trans_id)
1156
 
 
1157
1098
    def adjust_path(self, name, parent, trans_id):
1158
1099
        previous_parent = self._new_parent.get(trans_id)
1159
1100
        previous_name = self._new_name.get(trans_id)
1161
1102
        if (trans_id in self._limbo_files and
1162
1103
            trans_id not in self._needs_rename):
1163
1104
            self._rename_in_limbo([trans_id])
1164
 
            if previous_parent != parent:
1165
 
                self._limbo_children[previous_parent].remove(trans_id)
1166
 
            if previous_parent != parent or previous_name != name:
1167
 
                del self._limbo_children_names[previous_parent][previous_name]
 
1105
            self._limbo_children[previous_parent].remove(trans_id)
 
1106
            del self._limbo_children_names[previous_parent][previous_name]
1168
1107
 
1169
1108
    def _rename_in_limbo(self, trans_ids):
1170
1109
        """Fix limbo names so that the right final path is produced.
1183
1122
                continue
1184
1123
            new_path = self._limbo_name(trans_id)
1185
1124
            os.rename(old_path, new_path)
1186
 
            for descendant in self._limbo_descendants(trans_id):
1187
 
                desc_path = self._limbo_files[descendant]
1188
 
                desc_path = new_path + desc_path[len(old_path):]
1189
 
                self._limbo_files[descendant] = desc_path
1190
 
 
1191
 
    def _limbo_descendants(self, trans_id):
1192
 
        """Return the set of trans_ids whose limbo paths descend from this."""
1193
 
        descendants = set(self._limbo_children.get(trans_id, []))
1194
 
        for descendant in list(descendants):
1195
 
            descendants.update(self._limbo_descendants(descendant))
1196
 
        return descendants
1197
1125
 
1198
1126
    def create_file(self, contents, trans_id, mode_id=None):
1199
1127
        """Schedule creation of a new file.
1221
1149
            f.writelines(contents)
1222
1150
        finally:
1223
1151
            f.close()
1224
 
        self._set_mtime(name)
1225
1152
        self._set_mode(trans_id, mode_id, S_ISREG)
1226
1153
 
1227
1154
    def _read_file_chunks(self, trans_id):
1234
1161
    def _read_symlink_target(self, trans_id):
1235
1162
        return os.readlink(self._limbo_name(trans_id))
1236
1163
 
1237
 
    def _set_mtime(self, path):
1238
 
        """All files that are created get the same mtime.
1239
 
 
1240
 
        This time is set by the first object to be created.
1241
 
        """
1242
 
        if self._creation_mtime is None:
1243
 
            self._creation_mtime = time.time()
1244
 
        os.utime(path, (self._creation_mtime, self._creation_mtime))
1245
 
 
1246
1164
    def create_hardlink(self, path, trans_id):
1247
1165
        """Schedule creation of a hard link"""
1248
1166
        name = self._limbo_name(trans_id)
1362
1280
    FileMover does not delete files until it is sure that a rollback will not
1363
1281
    happen.
1364
1282
    """
1365
 
    def __init__(self, tree, pb=None):
 
1283
    def __init__(self, tree, pb=DummyProgress()):
1366
1284
        """Note: a tree_write lock is taken on the tree.
1367
1285
 
1368
1286
        Use TreeTransform.finalize() to release the lock (can be omitted if
1478
1396
                continue
1479
1397
            yield self.trans_id_tree_path(childpath)
1480
1398
 
1481
 
    def _generate_limbo_path(self, trans_id):
1482
 
        """Generate a limbo path using the final path if possible.
1483
 
 
1484
 
        This optimizes the performance of applying the tree transform by
1485
 
        avoiding renames.  These renames can be avoided only when the parent
1486
 
        directory is already scheduled for creation.
1487
 
 
1488
 
        If the final path cannot be used, falls back to using the trans_id as
1489
 
        the relpath.
1490
 
        """
1491
 
        parent = self._new_parent.get(trans_id)
1492
 
        # if the parent directory is already in limbo (e.g. when building a
1493
 
        # tree), choose a limbo name inside the parent, to reduce further
1494
 
        # renames.
1495
 
        use_direct_path = False
1496
 
        if self._new_contents.get(parent) == 'directory':
1497
 
            filename = self._new_name.get(trans_id)
1498
 
            if filename is not None:
1499
 
                if parent not in self._limbo_children:
1500
 
                    self._limbo_children[parent] = set()
1501
 
                    self._limbo_children_names[parent] = {}
1502
 
                    use_direct_path = True
1503
 
                # the direct path can only be used if no other file has
1504
 
                # already taken this pathname, i.e. if the name is unused, or
1505
 
                # if it is already associated with this trans_id.
1506
 
                elif self._case_sensitive_target:
1507
 
                    if (self._limbo_children_names[parent].get(filename)
1508
 
                        in (trans_id, None)):
1509
 
                        use_direct_path = True
1510
 
                else:
1511
 
                    for l_filename, l_trans_id in\
1512
 
                        self._limbo_children_names[parent].iteritems():
1513
 
                        if l_trans_id == trans_id:
1514
 
                            continue
1515
 
                        if l_filename.lower() == filename.lower():
1516
 
                            break
1517
 
                    else:
1518
 
                        use_direct_path = True
1519
 
 
1520
 
        if not use_direct_path:
1521
 
            return DiskTreeTransform._generate_limbo_path(self, trans_id)
1522
 
 
1523
 
        limbo_name = pathjoin(self._limbo_files[parent], filename)
1524
 
        self._limbo_children[parent].add(trans_id)
1525
 
        self._limbo_children_names[parent][filename] = trans_id
1526
 
        return limbo_name
1527
 
 
1528
 
 
1529
1399
    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1530
1400
        """Apply all changes to the inventory and filesystem.
1531
1401
 
1651
1521
                child_pb.update('removing file', num, len(tree_paths))
1652
1522
                full_path = self._tree.abspath(path)
1653
1523
                if trans_id in self._removed_contents:
1654
 
                    delete_path = os.path.join(self._deletiondir, trans_id)
1655
 
                    mover.pre_delete(full_path, delete_path)
1656
 
                elif (trans_id in self._new_name
1657
 
                      or trans_id in self._new_parent):
 
1524
                    mover.pre_delete(full_path, os.path.join(self._deletiondir,
 
1525
                                     trans_id))
 
1526
                elif trans_id in self._new_name or trans_id in \
 
1527
                    self._new_parent:
1658
1528
                    try:
1659
1529
                        mover.rename(full_path, self._limbo_name(trans_id))
1660
 
                    except errors.TransformRenameFailed, e:
 
1530
                    except OSError, e:
1661
1531
                        if e.errno != errno.ENOENT:
1662
1532
                            raise
1663
1533
                    else:
1688
1558
                if trans_id in self._needs_rename:
1689
1559
                    try:
1690
1560
                        mover.rename(self._limbo_name(trans_id), full_path)
1691
 
                    except errors.TransformRenameFailed, e:
 
1561
                    except OSError, e:
1692
1562
                        # We may be renaming a dangling inventory id
1693
1563
                        if e.errno != errno.ENOENT:
1694
1564
                            raise
1714
1584
    unversioned files in the input tree.
1715
1585
    """
1716
1586
 
1717
 
    def __init__(self, tree, pb=None, case_sensitive=True):
 
1587
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1718
1588
        tree.lock_read()
1719
1589
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
1720
1590
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
1765
1635
        self._all_children_cache = {}
1766
1636
        self._path2trans_id_cache = {}
1767
1637
        self._final_name_cache = {}
1768
 
        self._iter_changes_cache = dict((c[0], c) for c in
1769
 
                                        self._transform.iter_changes())
 
1638
 
 
1639
    def _changes(self, file_id):
 
1640
        for changes in self._transform.iter_changes():
 
1641
            if changes[0] == file_id:
 
1642
                return changes
1770
1643
 
1771
1644
    def _content_change(self, file_id):
1772
1645
        """Return True if the content of this file changed"""
1773
 
        changes = self._iter_changes_cache.get(file_id)
 
1646
        changes = self._changes(file_id)
1774
1647
        # changes[2] is true if the file content changed.  See
1775
1648
        # InterTree.iter_changes.
1776
1649
        return (changes is not None and changes[2])
1792
1665
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1793
1666
                       self._iter_parent_trees()]
1794
1667
        vf.add_lines((file_id, tree_revision), parent_keys,
1795
 
                     self.get_file_lines(file_id))
 
1668
                     self.get_file(file_id).readlines())
1796
1669
        repo = self._get_repository()
1797
1670
        base_vf = repo.texts
1798
1671
        if base_vf not in vf.fallback_versionedfiles:
1820
1693
            executable = self.is_executable(file_id, path)
1821
1694
        return kind, executable, None
1822
1695
 
1823
 
    def is_locked(self):
1824
 
        return False
1825
 
 
1826
1696
    def lock_read(self):
1827
1697
        # Perhaps in theory, this should lock the TreeTransform?
1828
 
        return self
 
1698
        pass
1829
1699
 
1830
1700
    def unlock(self):
1831
1701
        pass
1920
1790
            if self._transform.final_file_id(trans_id) is None:
1921
1791
                yield self._final_paths._determine_path(trans_id)
1922
1792
 
1923
 
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
1924
 
        yield_parents=False):
 
1793
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None):
1925
1794
        for trans_id, parent_file_id in ordered_entries:
1926
1795
            file_id = self._transform.final_file_id(trans_id)
1927
1796
            if file_id is None:
1953
1822
                ordered_ids.append((trans_id, parent_file_id))
1954
1823
        return ordered_ids
1955
1824
 
1956
 
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
1825
    def iter_entries_by_dir(self, specific_file_ids=None):
1957
1826
        # This may not be a maximally efficient implementation, but it is
1958
1827
        # reasonably straightforward.  An implementation that grafts the
1959
1828
        # TreeTransform changes onto the tree's iter_entries_by_dir results
1961
1830
        # position.
1962
1831
        ordered_ids = self._list_files_by_dir()
1963
1832
        for entry, trans_id in self._make_inv_entries(ordered_ids,
1964
 
            specific_file_ids, yield_parents=yield_parents):
 
1833
                                                      specific_file_ids):
1965
1834
            yield unicode(self._final_paths.get_path(trans_id)), entry
1966
1835
 
1967
1836
    def _iter_entries_for_dir(self, dir_path):
2014
1883
    def get_file_mtime(self, file_id, path=None):
2015
1884
        """See Tree.get_file_mtime"""
2016
1885
        if not self._content_change(file_id):
2017
 
            return self._transform._tree.get_file_mtime(file_id)
 
1886
            return self._transform._tree.get_file_mtime(file_id, path)
2018
1887
        return self._stat_limbo_file(file_id).st_mtime
2019
1888
 
2020
1889
    def _file_size(self, entry, stat_value):
2074
1943
                statval = os.lstat(limbo_name)
2075
1944
                size = statval.st_size
2076
1945
                if not supports_executable():
2077
 
                    executable = False
 
1946
                    executable = None
2078
1947
                else:
2079
1948
                    executable = statval.st_mode & S_IEXEC
2080
1949
            else:
2082
1951
                executable = None
2083
1952
            if kind == 'symlink':
2084
1953
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
2085
 
        executable = tt._new_executability.get(trans_id, executable)
 
1954
        if supports_executable():
 
1955
            executable = tt._new_executability.get(trans_id, executable)
2086
1956
        return kind, size, executable, link_or_sha1
2087
1957
 
2088
1958
    def iter_changes(self, from_tree, include_unchanged=False,
2119
1989
 
2120
1990
    def annotate_iter(self, file_id,
2121
1991
                      default_revision=_mod_revision.CURRENT_REVISION):
2122
 
        changes = self._iter_changes_cache.get(file_id)
 
1992
        changes = self._changes(file_id)
2123
1993
        if changes is None:
2124
1994
            get_old = True
2125
1995
        else:
2291
2161
    for num, _unused in enumerate(wt.all_file_ids()):
2292
2162
        if num > 0:  # more than just a root
2293
2163
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
2164
    existing_files = set()
 
2165
    for dir, files in wt.walkdirs():
 
2166
        existing_files.update(f[0] for f in files)
2294
2167
    file_trans_id = {}
2295
2168
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2296
2169
    pp = ProgressPhase("Build phase", 2, top_pb)
2320
2193
                precomputed_delta = []
2321
2194
            else:
2322
2195
                precomputed_delta = None
2323
 
            # Check if tree inventory has content. If so, we populate
2324
 
            # existing_files with the directory content. If there are no
2325
 
            # entries we skip populating existing_files as its not used.
2326
 
            # This improves performance and unncessary work on large
2327
 
            # directory trees. (#501307)
2328
 
            if total > 0:
2329
 
                existing_files = set()
2330
 
                for dir, files in wt.walkdirs():
2331
 
                    existing_files.update(f[0] for f in files)
2332
2196
            for num, (tree_path, entry) in \
2333
2197
                enumerate(tree.inventory.iter_entries_by_dir()):
2334
2198
                pb.update("Building tree", num - len(deferred_contents), total)
2407
2271
        new_desired_files = desired_files
2408
2272
    else:
2409
2273
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2410
 
        unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2411
 
                     in iter if not (c or e[0] != e[1])]
2412
 
        if accelerator_tree.supports_content_filtering():
2413
 
            unchanged = [(f, p) for (f, p) in unchanged
2414
 
                         if not accelerator_tree.iter_search_rules([p]).next()]
2415
 
        unchanged = dict(unchanged)
 
2274
        unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
 
2275
                         in iter if not (c or e[0] != e[1]))
2416
2276
        new_desired_files = []
2417
2277
        count = 0
2418
2278
        for file_id, (trans_id, tree_path) in desired_files:
2466
2326
    if entry.kind == "directory":
2467
2327
        return True
2468
2328
    if entry.kind == "file":
2469
 
        f = file(target_path, 'rb')
2470
 
        try:
2471
 
            if tree.get_file_text(file_id) == f.read():
2472
 
                return True
2473
 
        finally:
2474
 
            f.close()
 
2329
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
 
2330
            return True
2475
2331
    elif entry.kind == "symlink":
2476
2332
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2477
2333
            return True
2529
2385
        raise errors.BadFileKindError(name, kind)
2530
2386
 
2531
2387
 
2532
 
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2533
 
    filter_tree_path=None):
2534
 
    """Create new file contents according to tree contents.
2535
 
    
2536
 
    :param filter_tree_path: the tree path to use to lookup
2537
 
      content filters to apply to the bytes output in the working tree.
2538
 
      This only applies if the working tree supports content filtering.
 
2388
@deprecated_function(deprecated_in((1, 9, 0)))
 
2389
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
 
2390
    """Create new file contents according to an inventory entry.
 
2391
 
 
2392
    DEPRECATED.  Use create_from_tree instead.
2539
2393
    """
 
2394
    if entry.kind == "file":
 
2395
        if lines is None:
 
2396
            lines = tree.get_file(entry.file_id).readlines()
 
2397
        tt.create_file(lines, trans_id, mode_id=mode_id)
 
2398
    elif entry.kind == "symlink":
 
2399
        tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
 
2400
    elif entry.kind == "directory":
 
2401
        tt.create_directory(trans_id)
 
2402
 
 
2403
 
 
2404
def create_from_tree(tt, trans_id, tree, file_id, bytes=None):
 
2405
    """Create new file contents according to tree contents."""
2540
2406
    kind = tree.kind(file_id)
2541
2407
    if kind == 'directory':
2542
2408
        tt.create_directory(trans_id)
2547
2413
                bytes = tree_file.readlines()
2548
2414
            finally:
2549
2415
                tree_file.close()
2550
 
        wt = tt._tree
2551
 
        if wt.supports_content_filtering() and filter_tree_path is not None:
2552
 
            filters = wt._content_filter_stack(filter_tree_path)
2553
 
            bytes = filtered_output_bytes(bytes, filters,
2554
 
                ContentFilterContext(filter_tree_path, tree))
2555
2416
        tt.create_file(bytes, trans_id)
2556
2417
    elif kind == "symlink":
2557
2418
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
2609
2470
 
2610
2471
 
2611
2472
def revert(working_tree, target_tree, filenames, backups=False,
2612
 
           pb=None, change_reporter=None):
 
2473
           pb=DummyProgress(), change_reporter=None):
2613
2474
    """Revert a working tree's contents to those of a target tree."""
2614
2475
    target_tree.lock_read()
2615
 
    pb = ui.ui_factory.nested_progress_bar()
2616
2476
    tt = TreeTransform(working_tree, pb)
2617
2477
    try:
2618
2478
        pp = ProgressPhase("Revert phase", 3, pb)
2637
2497
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2638
2498
                              backups, pp, basis_tree=None,
2639
2499
                              merge_modified=None):
 
2500
    pp.next_phase()
2640
2501
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2641
2502
    try:
2642
2503
        if merge_modified is None:
2646
2507
                                      merge_modified, basis_tree)
2647
2508
    finally:
2648
2509
        child_pb.finished()
 
2510
    pp.next_phase()
2649
2511
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2650
2512
    try:
2651
2513
        raw_conflicts = resolve_conflicts(tt, child_pb,
2744
2606
                    parent_trans = ROOT_PARENT
2745
2607
                else:
2746
2608
                    parent_trans = tt.trans_id_file_id(parent[1])
2747
 
                if parent[0] is None and versioned[0]:
2748
 
                    tt.adjust_root_path(name[1], parent_trans)
2749
 
                else:
2750
 
                    tt.adjust_path(name[1], parent_trans, trans_id)
 
2609
                tt.adjust_path(name[1], parent_trans, trans_id)
2751
2610
            if executable[0] != executable[1] and kind[1] == "file":
2752
2611
                tt.set_executability(executable[1], trans_id)
2753
 
        if working_tree.supports_content_filtering():
2754
 
            for index, ((trans_id, mode_id), bytes) in enumerate(
2755
 
                target_tree.iter_files_bytes(deferred_files)):
2756
 
                file_id = deferred_files[index][0]
2757
 
                # We're reverting a tree to the target tree so using the
2758
 
                # target tree to find the file path seems the best choice
2759
 
                # here IMO - Ian C 27/Oct/2009
2760
 
                filter_tree_path = target_tree.id2path(file_id)
2761
 
                filters = working_tree._content_filter_stack(filter_tree_path)
2762
 
                bytes = filtered_output_bytes(bytes, filters,
2763
 
                    ContentFilterContext(filter_tree_path, working_tree))
2764
 
                tt.create_file(bytes, trans_id, mode_id)
2765
 
        else:
2766
 
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2767
 
                deferred_files):
2768
 
                tt.create_file(bytes, trans_id, mode_id)
2769
 
        tt.fixup_new_roots()
 
2612
        for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
 
2613
            deferred_files):
 
2614
            tt.create_file(bytes, trans_id, mode_id)
2770
2615
    finally:
2771
2616
        if basis_tree is not None:
2772
2617
            basis_tree.unlock()
2773
2618
    return merge_modified
2774
2619
 
2775
2620
 
2776
 
def resolve_conflicts(tt, pb=None, pass_func=None):
 
2621
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
2777
2622
    """Make many conflict-resolution attempts, but die if they fail"""
2778
2623
    if pass_func is None:
2779
2624
        pass_func = conflict_pass
2780
2625
    new_conflicts = set()
2781
 
    pb = ui.ui_factory.nested_progress_bar()
2782
2626
    try:
2783
2627
        for n in range(10):
2784
2628
            pb.update('Resolution pass', n+1, 10)
2788
2632
            new_conflicts.update(pass_func(tt, conflicts))
2789
2633
        raise MalformedTransform(conflicts=conflicts)
2790
2634
    finally:
2791
 
        pb.finished()
 
2635
        pb.clear()
2792
2636
 
2793
2637
 
2794
2638
def conflict_pass(tt, conflicts, path_tree=None):
2843
2687
                        # special-case the other tree root (move its
2844
2688
                        # children to current root)
2845
2689
                        if entry.parent_id is None:
2846
 
                            create = False
 
2690
                            create=False
2847
2691
                            moved = _reparent_transform_children(
2848
2692
                                tt, trans_id, tt.root)
2849
2693
                            for child in moved:
2917
2761
        self.pending_deletions = []
2918
2762
 
2919
2763
    def rename(self, from_, to):
2920
 
        """Rename a file from one path to another."""
 
2764
        """Rename a file from one path to another.  Functions like os.rename"""
2921
2765
        try:
2922
2766
            os.rename(from_, to)
2923
2767
        except OSError, e:
2924
2768
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2925
2769
                raise errors.FileExists(to, str(e))
2926
 
            # normal OSError doesn't include filenames so it's hard to see where
2927
 
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
2928
 
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
 
2770
            raise
2929
2771
        self.past_renames.append((from_, to))
2930
2772
 
2931
2773
    def pre_delete(self, from_, to):
2941
2783
    def rollback(self):
2942
2784
        """Reverse all renames that have been performed"""
2943
2785
        for from_, to in reversed(self.past_renames):
2944
 
            try:
2945
 
                os.rename(to, from_)
2946
 
            except OSError, e:
2947
 
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)                
 
2786
            os.rename(to, from_)
2948
2787
        # after rollback, don't reuse _FileMover
2949
2788
        past_renames = None
2950
2789
        pending_deletions = None