~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: John Arbash Meinel
  • Date: 2007-05-04 18:59:36 UTC
  • mto: This revision was merged to the branch mainline in revision 2643.
  • Revision ID: john@arbash-meinel.com-20070504185936-1mjdoqmtz74xe5mg
A C implementation of _fields_to_entry_0_parents drops the time from 400ms to 330ms for a 21k-entry tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
20
 
import tempfile
21
20
 
22
21
from bzrlib.lazy_import import lazy_import
23
22
lazy_import(globals(), """
30
29
""")
31
30
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
32
31
                           ReusingTransform, NotVersionedError, CantMoveRoot,
33
 
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
34
 
                           UnableCreateSymlink)
 
32
                           ExistingLimbo, ImmortalLimbo, NoFinalPath)
35
33
from bzrlib.inventory import InventoryEntry
36
34
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
37
 
                            delete_any, has_symlinks)
 
35
                            delete_any)
38
36
from bzrlib.progress import DummyProgress, ProgressPhase
39
 
from bzrlib.symbol_versioning import (
40
 
        deprecated_function,
41
 
        zero_fifteen,
42
 
        zero_ninety,
43
 
        )
 
37
from bzrlib.symbol_versioning import deprecated_function, zero_fifteen
44
38
from bzrlib.trace import mutter, warning
45
39
from bzrlib import tree
46
40
import bzrlib.ui
57
51
 
58
52
 
59
53
class _TransformResults(object):
60
 
    def __init__(self, modified_paths, rename_count):
 
54
    def __init__(self, modified_paths):
61
55
        object.__init__(self)
62
56
        self.modified_paths = modified_paths
63
 
        self.rename_count = rename_count
64
 
 
65
 
 
66
 
class TreeTransformBase(object):
67
 
    """The base class for TreeTransform and TreeTransformBase"""
68
 
 
69
 
    def __init__(self, tree, limbodir, pb=DummyProgress(),
70
 
                 case_sensitive=True):
71
 
        """Constructor.
72
 
 
73
 
        :param tree: The tree that will be transformed, but not necessarily
74
 
            the output tree.
75
 
        :param limbodir: A directory where new files can be stored until
76
 
            they are installed in their proper places
77
 
        :param pb: A ProgressBar indicating how much progress is being made
78
 
        :param case_sensitive: If True, the target of the transform is
79
 
            case sensitive, not just case preserving.
 
57
 
 
58
 
 
59
class TreeTransform(object):
 
60
    """Represent a tree transformation.
 
61
    
 
62
    This object is designed to support incremental generation of the transform,
 
63
    in any order.  
 
64
    
 
65
    It is easy to produce malformed transforms, but they are generally
 
66
    harmless.  Attempting to apply a malformed transform will cause an
 
67
    exception to be raised before any modifications are made to the tree.  
 
68
 
 
69
    Many kinds of malformed transforms can be corrected with the 
 
70
    resolve_conflicts function.  The remaining ones indicate programming error,
 
71
    such as trying to create a file with no path.
 
72
 
 
73
    Two sets of file creation methods are supplied.  Convenience methods are:
 
74
     * new_file
 
75
     * new_directory
 
76
     * new_symlink
 
77
 
 
78
    These are composed of the low-level methods:
 
79
     * create_path
 
80
     * create_file or create_directory or create_symlink
 
81
     * version_file
 
82
     * set_executability
 
83
    """
 
84
    def __init__(self, tree, pb=DummyProgress()):
 
85
        """Note: a tree_write lock is taken on the tree.
 
86
        
 
87
        Use TreeTransform.finalize() to release the lock
80
88
        """
81
89
        object.__init__(self)
82
90
        self._tree = tree
83
 
        self._limbodir = limbodir
84
 
        self._deletiondir = None
 
91
        self._tree.lock_tree_write()
 
92
        try:
 
93
            control_files = self._tree._control_files
 
94
            self._limbodir = urlutils.local_path_from_url(
 
95
                control_files.controlfilename('limbo'))
 
96
            try:
 
97
                os.mkdir(self._limbodir)
 
98
            except OSError, e:
 
99
                if e.errno == errno.EEXIST:
 
100
                    raise ExistingLimbo(self._limbodir)
 
101
        except: 
 
102
            self._tree.unlock()
 
103
            raise
 
104
 
85
105
        self._id_number = 0
86
 
        # mapping of trans_id -> new basename
87
106
        self._new_name = {}
88
 
        # mapping of trans_id -> new parent trans_id
89
107
        self._new_parent = {}
90
 
        # mapping of trans_id with new contents -> new file_kind
91
108
        self._new_contents = {}
92
 
        # A mapping of transform ids to their limbo filename
93
 
        self._limbo_files = {}
94
 
        # A mapping of transform ids to a set of the transform ids of children
95
 
        # that their limbo directory has
96
 
        self._limbo_children = {}
97
 
        # Map transform ids to maps of child filename to child transform id
98
 
        self._limbo_children_names = {}
99
 
        # List of transform ids that need to be renamed from limbo into place
100
 
        self._needs_rename = set()
101
 
        # Set of trans_ids whose contents will be removed
102
109
        self._removed_contents = set()
103
 
        # Mapping of trans_id -> new execute-bit value
104
110
        self._new_executability = {}
105
 
        # Mapping of trans_id -> new tree-reference value
106
111
        self._new_reference_revision = {}
107
 
        # Mapping of trans_id -> new file_id
108
112
        self._new_id = {}
109
 
        # Mapping of old file-id -> trans_id
110
113
        self._non_present_ids = {}
111
 
        # Mapping of new file_id -> trans_id
112
114
        self._r_new_id = {}
113
 
        # Set of file_ids that will be removed
114
115
        self._removed_id = set()
115
 
        # Mapping of path in old tree -> trans_id
116
116
        self._tree_path_ids = {}
117
 
        # Mapping trans_id -> path in old tree
118
117
        self._tree_id_paths = {}
 
118
        self._realpaths = {}
119
119
        # Cache of realpath results, to speed up canonical_path
120
 
        self._realpaths = {}
 
120
        self._relpaths = {}
121
121
        # Cache of relpath results, to speed up canonical_path
122
 
        self._relpaths = {}
123
 
        # The trans_id that will be used as the tree root
124
122
        self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
125
 
        # Indictor of whether the transform has been applied
126
 
        self._done = False
127
 
        # A progress bar
 
123
        self.__done = False
128
124
        self._pb = pb
129
 
        # Whether the target is case sensitive
130
 
        self._case_sensitive_target = case_sensitive
131
 
        # A counter of how many files have been renamed
132
 
        self.rename_count = 0
133
125
 
134
126
    def __get_root(self):
135
127
        return self._new_root
137
129
    root = property(__get_root)
138
130
 
139
131
    def finalize(self):
140
 
        """Release the working tree lock, if held, clean up limbo dir.
141
 
 
142
 
        This is required if apply has not been invoked, but can be invoked
143
 
        even after apply.
144
 
        """
 
132
        """Release the working tree lock, if held, clean up limbo dir."""
145
133
        if self._tree is None:
146
134
            return
147
135
        try:
148
 
            entries = [(self._limbo_name(t), t, k) for t, k in
149
 
                       self._new_contents.iteritems()]
150
 
            entries.sort(reverse=True)
151
 
            for path, trans_id, kind in entries:
 
136
            for trans_id, kind in self._new_contents.iteritems():
 
137
                path = self._limbo_name(trans_id)
152
138
                if kind == "directory":
153
139
                    os.rmdir(path)
154
140
                else:
158
144
            except OSError:
159
145
                # We don't especially care *why* the dir is immortal.
160
146
                raise ImmortalLimbo(self._limbodir)
161
 
            try:
162
 
                if self._deletiondir is not None:
163
 
                    os.rmdir(self._deletiondir)
164
 
            except OSError:
165
 
                raise errors.ImmortalPendingDeletion(self._deletiondir)
166
147
        finally:
167
148
            self._tree.unlock()
168
149
            self._tree = None
184
165
        """Change the path that is assigned to a transaction id."""
185
166
        if trans_id == self._new_root:
186
167
            raise CantMoveRoot
187
 
        previous_parent = self._new_parent.get(trans_id)
188
 
        previous_name = self._new_name.get(trans_id)
189
168
        self._new_name[trans_id] = name
190
169
        self._new_parent[trans_id] = parent
191
 
        if (trans_id in self._limbo_files and
192
 
            trans_id not in self._needs_rename):
193
 
            self._rename_in_limbo([trans_id])
194
 
            self._limbo_children[previous_parent].remove(trans_id)
195
 
            del self._limbo_children_names[previous_parent][previous_name]
196
 
 
197
 
    def _rename_in_limbo(self, trans_ids):
198
 
        """Fix limbo names so that the right final path is produced.
199
 
 
200
 
        This means we outsmarted ourselves-- we tried to avoid renaming
201
 
        these files later by creating them with their final names in their
202
 
        final parents.  But now the previous name or parent is no longer
203
 
        suitable, so we have to rename them.
204
 
 
205
 
        Even for trans_ids that have no new contents, we must remove their
206
 
        entries from _limbo_files, because they are now stale.
207
 
        """
208
 
        for trans_id in trans_ids:
209
 
            old_path = self._limbo_files.pop(trans_id)
210
 
            if trans_id not in self._new_contents:
211
 
                continue
212
 
            new_path = self._limbo_name(trans_id)
213
 
            os.rename(old_path, new_path)
214
170
 
215
171
    def adjust_root_path(self, name, parent):
216
172
        """Emulate moving the root by moving all children, instead.
250
206
        This reflects only files that already exist, not ones that will be
251
207
        added by transactions.
252
208
        """
253
 
        path = self._tree.id2path(inventory_id)
 
209
        path = self._tree.inventory.id2path(inventory_id)
254
210
        return self.trans_id_tree_path(path)
255
211
 
256
212
    def trans_id_file_id(self, file_id):
354
310
        if typefunc(mode):
355
311
            os.chmod(self._limbo_name(trans_id), mode)
356
312
 
357
 
    def create_hardlink(self, path, trans_id):
358
 
        """Schedule creation of a hard link"""
359
 
        name = self._limbo_name(trans_id)
360
 
        try:
361
 
            os.link(path, name)
362
 
        except OSError, e:
363
 
            if e.errno != errno.EPERM:
364
 
                raise
365
 
            raise errors.HardLinkNotSupported(path)
366
 
        try:
367
 
            unique_add(self._new_contents, trans_id, 'file')
368
 
        except:
369
 
            # Clean up the file, it never got registered so
370
 
            # TreeTransform.finalize() won't clean it up.
371
 
            os.unlink(name)
372
 
            raise
373
 
 
374
313
    def create_directory(self, trans_id):
375
314
        """Schedule creation of a new directory.
376
315
        
385
324
        target is a bytestring.
386
325
        See also new_symlink.
387
326
        """
388
 
        if has_symlinks():
389
 
            os.symlink(target, self._limbo_name(trans_id))
390
 
            unique_add(self._new_contents, trans_id, 'symlink')
391
 
        else:
392
 
            try:
393
 
                path = FinalPaths(self).get_path(trans_id)
394
 
            except KeyError:
395
 
                path = None
396
 
            raise UnableCreateSymlink(path=path)
 
327
        os.symlink(target, self._limbo_name(trans_id))
 
328
        unique_add(self._new_contents, trans_id, 'symlink')
397
329
 
398
330
    def cancel_creation(self, trans_id):
399
331
        """Cancel the creation of new file contents."""
400
332
        del self._new_contents[trans_id]
401
 
        children = self._limbo_children.get(trans_id)
402
 
        # if this is a limbo directory with children, move them before removing
403
 
        # the directory
404
 
        if children is not None:
405
 
            self._rename_in_limbo(children)
406
 
            del self._limbo_children[trans_id]
407
 
            del self._limbo_children_names[trans_id]
408
333
        delete_any(self._limbo_name(trans_id))
409
334
 
410
335
    def delete_contents(self, trans_id):
500
425
            return None
501
426
        # the file is old; the old id is still valid
502
427
        if self._new_root == trans_id:
503
 
            return self._tree.get_root_id()
 
428
            return self._tree.inventory.root.file_id
504
429
        return self._tree.inventory.path2id(path)
505
430
 
506
431
    def final_file_id(self, trans_id):
574
499
 
575
500
    def find_conflicts(self):
576
501
        """Find any violations of inventory or filesystem invariants"""
577
 
        if self._done is True:
 
502
        if self.__done is True:
578
503
            raise ReusingTransform()
579
504
        conflicts = []
580
505
        # ensure all children of all existent parents are known
602
527
                        self.tree_kind(t) == 'directory'])
603
528
        for trans_id in self._removed_id:
604
529
            file_id = self.tree_file_id(trans_id)
605
 
            if file_id is not None:
606
 
                if self._tree.inventory[file_id].kind == 'directory':
607
 
                    parents.append(trans_id)
608
 
            elif self.tree_kind(trans_id) == 'directory':
 
530
            if self._tree.inventory[file_id].kind == 'directory':
609
531
                parents.append(trans_id)
610
532
 
611
533
        for parent_id in parents:
621
543
        try:
622
544
            children = os.listdir(self._tree.abspath(path))
623
545
        except OSError, e:
624
 
            if e.errno not in (errno.ENOENT, errno.ESRCH, errno.ENOTDIR):
 
546
            if e.errno != errno.ENOENT and e.errno != errno.ESRCH:
625
547
                raise
626
548
            return
627
549
            
741
663
    def _duplicate_entries(self, by_parent):
742
664
        """No directory may have two entries with the same name."""
743
665
        conflicts = []
744
 
        if (self._new_name, self._new_parent) == ({}, {}):
745
 
            return conflicts
746
666
        for children in by_parent.itervalues():
747
667
            name_ids = [(self.final_name(t), t) for t in children]
748
 
            if not self._case_sensitive_target:
749
 
                name_ids = [(n.lower(), t) for n, t in name_ids]
750
668
            name_ids.sort()
751
669
            last_name = None
752
670
            last_trans_id = None
770
688
        conflicts = []
771
689
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
772
690
                                self._removed_id))
773
 
        all_ids = self._tree.all_file_ids()
774
 
        active_tree_ids = all_ids.difference(removed_tree_ids)
 
691
        active_tree_ids = set((f for f in self._tree.inventory if
 
692
                               f not in removed_tree_ids))
775
693
        for trans_id, file_id in self._new_id.iteritems():
776
694
            if file_id in active_tree_ids:
777
695
                old_trans_id = self.trans_id_tree_file_id(file_id)
810
728
                continue
811
729
            return True
812
730
        return False
 
731
            
 
732
    def apply(self):
 
733
        """Apply all changes to the inventory and filesystem.
 
734
        
 
735
        If filesystem or inventory conflicts are present, MalformedTransform
 
736
        will be thrown.
 
737
        """
 
738
        conflicts = self.find_conflicts()
 
739
        if len(conflicts) != 0:
 
740
            raise MalformedTransform(conflicts=conflicts)
 
741
        inv = self._tree.inventory
 
742
        inventory_delta = []
 
743
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
744
        try:
 
745
            child_pb.update('Apply phase', 0, 2)
 
746
            self._apply_removals(inv, inventory_delta)
 
747
            child_pb.update('Apply phase', 1, 2)
 
748
            modified_paths = self._apply_insertions(inv, inventory_delta)
 
749
        finally:
 
750
            child_pb.finished()
 
751
        self._tree.apply_inventory_delta(inventory_delta)
 
752
        self.__done = True
 
753
        self.finalize()
 
754
        return _TransformResults(modified_paths)
813
755
 
814
756
    def _limbo_name(self, trans_id):
815
757
        """Generate the limbo name of a file"""
816
 
        limbo_name = self._limbo_files.get(trans_id)
817
 
        if limbo_name is not None:
818
 
            return limbo_name
819
 
        parent = self._new_parent.get(trans_id)
820
 
        # if the parent directory is already in limbo (e.g. when building a
821
 
        # tree), choose a limbo name inside the parent, to reduce further
822
 
        # renames.
823
 
        use_direct_path = False
824
 
        if self._new_contents.get(parent) == 'directory':
825
 
            filename = self._new_name.get(trans_id)
826
 
            if filename is not None:
827
 
                if parent not in self._limbo_children:
828
 
                    self._limbo_children[parent] = set()
829
 
                    self._limbo_children_names[parent] = {}
830
 
                    use_direct_path = True
831
 
                # the direct path can only be used if no other file has
832
 
                # already taken this pathname, i.e. if the name is unused, or
833
 
                # if it is already associated with this trans_id.
834
 
                elif self._case_sensitive_target:
835
 
                    if (self._limbo_children_names[parent].get(filename)
836
 
                        in (trans_id, None)):
837
 
                        use_direct_path = True
 
758
        return pathjoin(self._limbodir, trans_id)
 
759
 
 
760
    def _apply_removals(self, inv, inventory_delta):
 
761
        """Perform tree operations that remove directory/inventory names.
 
762
        
 
763
        That is, delete files that are to be deleted, and put any files that
 
764
        need renaming into limbo.  This must be done in strict child-to-parent
 
765
        order.
 
766
        """
 
767
        tree_paths = list(self._tree_path_ids.iteritems())
 
768
        tree_paths.sort(reverse=True)
 
769
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
770
        try:
 
771
            for num, data in enumerate(tree_paths):
 
772
                path, trans_id = data
 
773
                child_pb.update('removing file', num, len(tree_paths))
 
774
                full_path = self._tree.abspath(path)
 
775
                if trans_id in self._removed_contents:
 
776
                    delete_any(full_path)
 
777
                elif trans_id in self._new_name or trans_id in \
 
778
                    self._new_parent:
 
779
                    try:
 
780
                        os.rename(full_path, self._limbo_name(trans_id))
 
781
                    except OSError, e:
 
782
                        if e.errno != errno.ENOENT:
 
783
                            raise
 
784
                if trans_id in self._removed_id:
 
785
                    if trans_id == self._new_root:
 
786
                        file_id = self._tree.inventory.root.file_id
 
787
                    else:
 
788
                        file_id = self.tree_file_id(trans_id)
 
789
                    assert file_id is not None
 
790
                    inventory_delta.append((path, None, file_id, None))
 
791
        finally:
 
792
            child_pb.finished()
 
793
 
 
794
    def _apply_insertions(self, inv, inventory_delta):
 
795
        """Perform tree operations that insert directory/inventory names.
 
796
        
 
797
        That is, create any files that need to be created, and restore from
 
798
        limbo any files that needed renaming.  This must be done in strict
 
799
        parent-to-child order.
 
800
        """
 
801
        new_paths = self.new_paths()
 
802
        modified_paths = []
 
803
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
804
        try:
 
805
            for num, (path, trans_id) in enumerate(new_paths):
 
806
                new_entry = None
 
807
                child_pb.update('adding file', num, len(new_paths))
 
808
                try:
 
809
                    kind = self._new_contents[trans_id]
 
810
                except KeyError:
 
811
                    kind = contents = None
 
812
                if trans_id in self._new_contents or \
 
813
                    self.path_changed(trans_id):
 
814
                    full_path = self._tree.abspath(path)
 
815
                    try:
 
816
                        os.rename(self._limbo_name(trans_id), full_path)
 
817
                    except OSError, e:
 
818
                        # We may be renaming a dangling inventory id
 
819
                        if e.errno != errno.ENOENT:
 
820
                            raise
 
821
                    if trans_id in self._new_contents:
 
822
                        modified_paths.append(full_path)
 
823
                        del self._new_contents[trans_id]
 
824
 
 
825
                if trans_id in self._new_id:
 
826
                    if kind is None:
 
827
                        kind = file_kind(self._tree.abspath(path))
 
828
                    if trans_id in self._new_reference_revision:
 
829
                        new_entry = inventory.TreeReference(
 
830
                            self._new_id[trans_id],
 
831
                            self._new_name[trans_id], 
 
832
                            self.final_file_id(self._new_parent[trans_id]),
 
833
                            None, self._new_reference_revision[trans_id])
 
834
                    else:
 
835
                        new_entry = inventory.make_entry(kind,
 
836
                            self.final_name(trans_id),
 
837
                            self.final_file_id(self.final_parent(trans_id)),
 
838
                            self._new_id[trans_id])
838
839
                else:
839
 
                    for l_filename, l_trans_id in\
840
 
                        self._limbo_children_names[parent].iteritems():
841
 
                        if l_trans_id == trans_id:
842
 
                            continue
843
 
                        if l_filename.lower() == filename.lower():
844
 
                            break
 
840
                    if trans_id in self._new_name or trans_id in\
 
841
                        self._new_parent or\
 
842
                        trans_id in self._new_executability:
 
843
                        file_id = self.final_file_id(trans_id)
 
844
                        if file_id is not None:
 
845
                            entry = inv[file_id]
 
846
                            new_entry = entry.copy()
 
847
 
 
848
                    if trans_id in self._new_name or trans_id in\
 
849
                        self._new_parent:
 
850
                            if new_entry is not None:
 
851
                                new_entry.name = self.final_name(trans_id)
 
852
                                parent = self.final_parent(trans_id)
 
853
                                parent_id = self.final_file_id(parent)
 
854
                                new_entry.parent_id = parent_id
 
855
 
 
856
                if trans_id in self._new_executability:
 
857
                    self._set_executability(path, new_entry, trans_id)
 
858
                if new_entry is not None:
 
859
                    if new_entry.file_id in inv:
 
860
                        old_path = inv.id2path(new_entry.file_id)
845
861
                    else:
846
 
                        use_direct_path = True
847
 
 
848
 
        if use_direct_path:
849
 
            limbo_name = pathjoin(self._limbo_files[parent], filename)
850
 
            self._limbo_children[parent].add(trans_id)
851
 
            self._limbo_children_names[parent][filename] = trans_id
852
 
        else:
853
 
            limbo_name = pathjoin(self._limbodir, trans_id)
854
 
            self._needs_rename.add(trans_id)
855
 
        self._limbo_files[trans_id] = limbo_name
856
 
        return limbo_name
 
862
                        old_path = None
 
863
                    inventory_delta.append((old_path, path,
 
864
                                            new_entry.file_id,
 
865
                                            new_entry))
 
866
        finally:
 
867
            child_pb.finished()
 
868
        return modified_paths
857
869
 
858
870
    def _set_executability(self, path, entry, trans_id):
859
871
        """Set the executability of versioned files """
1002
1014
            to_executable = False
1003
1015
        return to_name, to_parent, to_kind, to_executable
1004
1016
 
1005
 
    def iter_changes(self):
1006
 
        """Produce output in the same format as Tree.iter_changes.
 
1017
    def _iter_changes(self):
 
1018
        """Produce output in the same format as Tree._iter_changes.
1007
1019
 
1008
1020
        Will produce nonsensical results if invoked while inventory/filesystem
1009
1021
        conflicts (as reported by TreeTransform.find_conflicts()) are present.
1064
1076
                   (from_executable, to_executable)))
1065
1077
        return iter(sorted(results, key=lambda x:x[1]))
1066
1078
 
1067
 
    def get_preview_tree(self):
1068
 
        """Return a tree representing the result of the transform.
1069
 
 
1070
 
        This tree only supports the subset of Tree functionality required
1071
 
        by show_diff_trees.  It must only be compared to tt._tree.
1072
 
        """
1073
 
        return _PreviewTree(self)
1074
 
 
1075
 
 
1076
 
class TreeTransform(TreeTransformBase):
1077
 
    """Represent a tree transformation.
1078
 
 
1079
 
    This object is designed to support incremental generation of the transform,
1080
 
    in any order.
1081
 
 
1082
 
    However, it gives optimum performance when parent directories are created
1083
 
    before their contents.  The transform is then able to put child files
1084
 
    directly in their parent directory, avoiding later renames.
1085
 
 
1086
 
    It is easy to produce malformed transforms, but they are generally
1087
 
    harmless.  Attempting to apply a malformed transform will cause an
1088
 
    exception to be raised before any modifications are made to the tree.
1089
 
 
1090
 
    Many kinds of malformed transforms can be corrected with the
1091
 
    resolve_conflicts function.  The remaining ones indicate programming error,
1092
 
    such as trying to create a file with no path.
1093
 
 
1094
 
    Two sets of file creation methods are supplied.  Convenience methods are:
1095
 
     * new_file
1096
 
     * new_directory
1097
 
     * new_symlink
1098
 
 
1099
 
    These are composed of the low-level methods:
1100
 
     * create_path
1101
 
     * create_file or create_directory or create_symlink
1102
 
     * version_file
1103
 
     * set_executability
1104
 
 
1105
 
    Transform/Transaction ids
1106
 
    -------------------------
1107
 
    trans_ids are temporary ids assigned to all files involved in a transform.
1108
 
    It's possible, even common, that not all files in the Tree have trans_ids.
1109
 
 
1110
 
    trans_ids are used because filenames and file_ids are not good enough
1111
 
    identifiers; filenames change, and not all files have file_ids.  File-ids
1112
 
    are also associated with trans-ids, so that moving a file moves its
1113
 
    file-id.
1114
 
 
1115
 
    trans_ids are only valid for the TreeTransform that generated them.
1116
 
 
1117
 
    Limbo
1118
 
    -----
1119
 
    Limbo is a temporary directory use to hold new versions of files.
1120
 
    Files are added to limbo by create_file, create_directory, create_symlink,
1121
 
    and their convenience variants (new_*).  Files may be removed from limbo
1122
 
    using cancel_creation.  Files are renamed from limbo into their final
1123
 
    location as part of TreeTransform.apply
1124
 
 
1125
 
    Limbo must be cleaned up, by either calling TreeTransform.apply or
1126
 
    calling TreeTransform.finalize.
1127
 
 
1128
 
    Files are placed into limbo inside their parent directories, where
1129
 
    possible.  This reduces subsequent renames, and makes operations involving
1130
 
    lots of files faster.  This optimization is only possible if the parent
1131
 
    directory is created *before* creating any of its children, so avoid
1132
 
    creating children before parents, where possible.
1133
 
 
1134
 
    Pending-deletion
1135
 
    ----------------
1136
 
    This temporary directory is used by _FileMover for storing files that are
1137
 
    about to be deleted.  In case of rollback, the files will be restored.
1138
 
    FileMover does not delete files until it is sure that a rollback will not
1139
 
    happen.
1140
 
    """
1141
 
    def __init__(self, tree, pb=DummyProgress()):
1142
 
        """Note: a tree_write lock is taken on the tree.
1143
 
 
1144
 
        Use TreeTransform.finalize() to release the lock (can be omitted if
1145
 
        TreeTransform.apply() called).
1146
 
        """
1147
 
        tree.lock_tree_write()
1148
 
 
1149
 
        try:
1150
 
            control_files = tree._control_files
1151
 
            limbodir = urlutils.local_path_from_url(
1152
 
                control_files.controlfilename('limbo'))
1153
 
            try:
1154
 
                os.mkdir(limbodir)
1155
 
            except OSError, e:
1156
 
                if e.errno == errno.EEXIST:
1157
 
                    raise ExistingLimbo(limbodir)
1158
 
            deletiondir = urlutils.local_path_from_url(
1159
 
                control_files.controlfilename('pending-deletion'))
1160
 
            try:
1161
 
                os.mkdir(deletiondir)
1162
 
            except OSError, e:
1163
 
                if e.errno == errno.EEXIST:
1164
 
                    raise errors.ExistingPendingDeletion(deletiondir)
1165
 
        except:
1166
 
            tree.unlock()
1167
 
            raise
1168
 
 
1169
 
        TreeTransformBase.__init__(self, tree, limbodir, pb,
1170
 
                                   tree.case_sensitive)
1171
 
        self._deletiondir = deletiondir
1172
 
 
1173
 
    def apply(self, no_conflicts=False, _mover=None):
1174
 
        """Apply all changes to the inventory and filesystem.
1175
 
 
1176
 
        If filesystem or inventory conflicts are present, MalformedTransform
1177
 
        will be thrown.
1178
 
 
1179
 
        If apply succeeds, finalize is not necessary.
1180
 
 
1181
 
        :param no_conflicts: if True, the caller guarantees there are no
1182
 
            conflicts, so no check is made.
1183
 
        :param _mover: Supply an alternate FileMover, for testing
1184
 
        """
1185
 
        if not no_conflicts:
1186
 
            conflicts = self.find_conflicts()
1187
 
            if len(conflicts) != 0:
1188
 
                raise MalformedTransform(conflicts=conflicts)
1189
 
        inventory_delta = []
1190
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1191
 
        try:
1192
 
            if _mover is None:
1193
 
                mover = _FileMover()
1194
 
            else:
1195
 
                mover = _mover
1196
 
            try:
1197
 
                child_pb.update('Apply phase', 0, 2)
1198
 
                self._apply_removals(inventory_delta, mover)
1199
 
                child_pb.update('Apply phase', 1, 2)
1200
 
                modified_paths = self._apply_insertions(inventory_delta, mover)
1201
 
            except:
1202
 
                mover.rollback()
1203
 
                raise
1204
 
            else:
1205
 
                mover.apply_deletions()
1206
 
        finally:
1207
 
            child_pb.finished()
1208
 
        self._tree.apply_inventory_delta(inventory_delta)
1209
 
        self._done = True
1210
 
        self.finalize()
1211
 
        return _TransformResults(modified_paths, self.rename_count)
1212
 
 
1213
 
    def _apply_removals(self, inventory_delta, mover):
1214
 
        """Perform tree operations that remove directory/inventory names.
1215
 
 
1216
 
        That is, delete files that are to be deleted, and put any files that
1217
 
        need renaming into limbo.  This must be done in strict child-to-parent
1218
 
        order.
1219
 
        """
1220
 
        tree_paths = list(self._tree_path_ids.iteritems())
1221
 
        tree_paths.sort(reverse=True)
1222
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1223
 
        try:
1224
 
            for num, data in enumerate(tree_paths):
1225
 
                path, trans_id = data
1226
 
                child_pb.update('removing file', num, len(tree_paths))
1227
 
                full_path = self._tree.abspath(path)
1228
 
                if trans_id in self._removed_contents:
1229
 
                    mover.pre_delete(full_path, os.path.join(self._deletiondir,
1230
 
                                     trans_id))
1231
 
                elif trans_id in self._new_name or trans_id in \
1232
 
                    self._new_parent:
1233
 
                    try:
1234
 
                        mover.rename(full_path, self._limbo_name(trans_id))
1235
 
                    except OSError, e:
1236
 
                        if e.errno != errno.ENOENT:
1237
 
                            raise
1238
 
                    else:
1239
 
                        self.rename_count += 1
1240
 
                if trans_id in self._removed_id:
1241
 
                    if trans_id == self._new_root:
1242
 
                        file_id = self._tree.get_root_id()
1243
 
                    else:
1244
 
                        file_id = self.tree_file_id(trans_id)
1245
 
                    assert file_id is not None
1246
 
                    # File-id isn't really being deleted, just moved
1247
 
                    if file_id in self._r_new_id:
1248
 
                        continue
1249
 
                    inventory_delta.append((path, None, file_id, None))
1250
 
        finally:
1251
 
            child_pb.finished()
1252
 
 
1253
 
    def _apply_insertions(self, inventory_delta, mover):
1254
 
        """Perform tree operations that insert directory/inventory names.
1255
 
 
1256
 
        That is, create any files that need to be created, and restore from
1257
 
        limbo any files that needed renaming.  This must be done in strict
1258
 
        parent-to-child order.
1259
 
        """
1260
 
        new_paths = self.new_paths()
1261
 
        modified_paths = []
1262
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1263
 
        completed_new = []
1264
 
        try:
1265
 
            for num, (path, trans_id) in enumerate(new_paths):
1266
 
                new_entry = None
1267
 
                child_pb.update('adding file', num, len(new_paths))
1268
 
                if trans_id in self._new_contents or \
1269
 
                    self.path_changed(trans_id):
1270
 
                    full_path = self._tree.abspath(path)
1271
 
                    if trans_id in self._needs_rename:
1272
 
                        try:
1273
 
                            mover.rename(self._limbo_name(trans_id), full_path)
1274
 
                        except OSError, e:
1275
 
                            # We may be renaming a dangling inventory id
1276
 
                            if e.errno != errno.ENOENT:
1277
 
                                raise
1278
 
                        else:
1279
 
                            self.rename_count += 1
1280
 
                    if trans_id in self._new_contents:
1281
 
                        modified_paths.append(full_path)
1282
 
                        completed_new.append(trans_id)
1283
 
                file_id = self.final_file_id(trans_id)
1284
 
                if file_id is not None and (trans_id in self._new_id or
1285
 
                    trans_id in self._new_name or trans_id in self._new_parent
1286
 
                    or trans_id in self._new_executability):
1287
 
                    try:
1288
 
                        kind = self.final_kind(trans_id)
1289
 
                    except NoSuchFile:
1290
 
                        kind = self._tree.stored_kind(file_id)
1291
 
                    if trans_id in self._new_reference_revision:
1292
 
                        new_entry = inventory.TreeReference(
1293
 
                            self.final_file_id(trans_id),
1294
 
                            self._new_name[trans_id],
1295
 
                            self.final_file_id(self._new_parent[trans_id]),
1296
 
                            None, self._new_reference_revision[trans_id])
1297
 
                    else:
1298
 
                        new_entry = inventory.make_entry(kind,
1299
 
                            self.final_name(trans_id),
1300
 
                            self.final_file_id(self.final_parent(trans_id)),
1301
 
                            self.final_file_id(trans_id))
1302
 
                    try:
1303
 
                        old_path = self._tree.id2path(new_entry.file_id)
1304
 
                    except errors.NoSuchId:
1305
 
                        old_path = None
1306
 
                    inventory_delta.append((old_path, path, new_entry.file_id,
1307
 
                                            new_entry))
1308
 
 
1309
 
                if trans_id in self._new_executability:
1310
 
                    self._set_executability(path, new_entry, trans_id)
1311
 
        finally:
1312
 
            child_pb.finished()
1313
 
        for trans_id in completed_new:
1314
 
            del self._new_contents[trans_id]
1315
 
        return modified_paths
1316
 
 
1317
 
 
1318
 
class TransformPreview(TreeTransformBase):
1319
 
    """A TreeTransform for generating preview trees.
1320
 
 
1321
 
    Unlike TreeTransform, this version works when the input tree is a
1322
 
    RevisionTree, rather than a WorkingTree.  As a result, it tends to ignore
1323
 
    unversioned files in the input tree.
1324
 
    """
1325
 
 
1326
 
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1327
 
        tree.lock_read()
1328
 
        limbodir = tempfile.mkdtemp(prefix='bzr-limbo-')
1329
 
        TreeTransformBase.__init__(self, tree, limbodir, pb, case_sensitive)
1330
 
 
1331
 
    def canonical_path(self, path):
1332
 
        return path
1333
 
 
1334
 
    def tree_kind(self, trans_id):
1335
 
        path = self._tree_id_paths.get(trans_id)
1336
 
        if path is None:
1337
 
            raise NoSuchFile(None)
1338
 
        file_id = self._tree.path2id(path)
1339
 
        return self._tree.kind(file_id)
1340
 
 
1341
 
    def _set_mode(self, trans_id, mode_id, typefunc):
1342
 
        """Set the mode of new file contents.
1343
 
        The mode_id is the existing file to get the mode from (often the same
1344
 
        as trans_id).  The operation is only performed if there's a mode match
1345
 
        according to typefunc.
1346
 
        """
1347
 
        # is it ok to ignore this?  probably
1348
 
        pass
1349
 
 
1350
 
    def iter_tree_children(self, parent_id):
1351
 
        """Iterate through the entry's tree children, if any"""
1352
 
        try:
1353
 
            path = self._tree_id_paths[parent_id]
1354
 
        except KeyError:
1355
 
            return
1356
 
        file_id = self.tree_file_id(parent_id)
1357
 
        for child in self._tree.inventory[file_id].children.iterkeys():
1358
 
            childpath = joinpath(path, child)
1359
 
            yield self.trans_id_tree_path(childpath)
1360
 
 
1361
 
 
1362
 
class _PreviewTree(object):
1363
 
    """Partial implementation of Tree to support show_diff_trees"""
1364
 
 
1365
 
    def __init__(self, transform):
1366
 
        self._transform = transform
1367
 
 
1368
 
    def lock_read(self):
1369
 
        # Perhaps in theory, this should lock the TreeTransform?
1370
 
        pass
1371
 
 
1372
 
    def unlock(self):
1373
 
        pass
1374
 
 
1375
 
    def iter_changes(self, from_tree, include_unchanged=False,
1376
 
                      specific_files=None, pb=None, extra_trees=None,
1377
 
                      require_versioned=True, want_unversioned=False):
1378
 
        """See InterTree.iter_changes.
1379
 
 
1380
 
        This implementation does not support include_unchanged, specific_files,
1381
 
        or want_unversioned.  extra_trees, require_versioned, and pb are
1382
 
        ignored.
1383
 
        """
1384
 
        if from_tree is not self._transform._tree:
1385
 
            raise ValueError('from_tree must be transform source tree.')
1386
 
        if include_unchanged:
1387
 
            raise ValueError('include_unchanged is not supported')
1388
 
        if specific_files is not None:
1389
 
            raise ValueError('specific_files is not supported')
1390
 
        if want_unversioned:
1391
 
            raise ValueError('want_unversioned is not supported')
1392
 
        return self._transform.iter_changes()
1393
 
 
1394
 
    def kind(self, file_id):
1395
 
        trans_id = self._transform.trans_id_file_id(file_id)
1396
 
        return self._transform.final_kind(trans_id)
1397
 
 
1398
 
    def get_file_mtime(self, file_id, path=None):
1399
 
        """See Tree.get_file_mtime"""
1400
 
        trans_id = self._transform.trans_id_file_id(file_id)
1401
 
        name = self._transform._limbo_name(trans_id)
1402
 
        return os.stat(name).st_mtime
1403
 
 
1404
 
    def get_file(self, file_id):
1405
 
        """See Tree.get_file"""
1406
 
        trans_id = self._transform.trans_id_file_id(file_id)
1407
 
        name = self._transform._limbo_name(trans_id)
1408
 
        return open(name, 'rb')
1409
 
 
1410
 
    def get_symlink_target(self, file_id):
1411
 
        """See Tree.get_symlink_target"""
1412
 
        trans_id = self._transform.trans_id_file_id(file_id)
1413
 
        name = self._transform._limbo_name(trans_id)
1414
 
        return os.readlink(name)
1415
 
 
1416
 
    def paths2ids(self, specific_files, trees=None, require_versioned=False):
1417
 
        """See Tree.paths2ids"""
1418
 
        return 'not_empty'
1419
 
 
1420
1079
 
1421
1080
def joinpath(parent, child):
1422
1081
    """Join tree-relative paths, handling the tree root specially"""
1453
1112
            self._known_paths[trans_id] = self._determine_path(trans_id)
1454
1113
        return self._known_paths[trans_id]
1455
1114
 
1456
 
 
1457
1115
def topology_sorted_ids(tree):
1458
1116
    """Determine the topological order of the ids in a tree"""
1459
1117
    file_ids = list(tree)
1461
1119
    return file_ids
1462
1120
 
1463
1121
 
1464
 
def build_tree(tree, wt, accelerator_tree=None, hardlink=False):
 
1122
def build_tree(tree, wt):
1465
1123
    """Create working tree for a branch, using a TreeTransform.
1466
1124
    
1467
1125
    This function should be used on empty trees, having a tree root at most.
1474
1132
    - Otherwise, if the content on disk matches the content we are building,
1475
1133
      it is silently replaced.
1476
1134
    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
1477
 
 
1478
 
    :param tree: The tree to convert wt into a copy of
1479
 
    :param wt: The working tree that files will be placed into
1480
 
    :param accelerator_tree: A tree which can be used for retrieving file
1481
 
        contents more quickly than tree itself, i.e. a workingtree.  tree
1482
 
        will be used for cases where accelerator_tree's content is different.
1483
 
    :param hardlink: If true, hard-link files to accelerator_tree, where
1484
 
        possible.  accelerator_tree must implement abspath, i.e. be a
1485
 
        working tree.
1486
1135
    """
1487
1136
    wt.lock_tree_write()
1488
1137
    try:
1489
1138
        tree.lock_read()
1490
1139
        try:
1491
 
            if accelerator_tree is not None:
1492
 
                accelerator_tree.lock_read()
1493
 
            try:
1494
 
                return _build_tree(tree, wt, accelerator_tree, hardlink)
1495
 
            finally:
1496
 
                if accelerator_tree is not None:
1497
 
                    accelerator_tree.unlock()
 
1140
            return _build_tree(tree, wt)
1498
1141
        finally:
1499
1142
            tree.unlock()
1500
1143
    finally:
1501
1144
        wt.unlock()
1502
1145
 
1503
 
 
1504
 
def _build_tree(tree, wt, accelerator_tree, hardlink):
 
1146
def _build_tree(tree, wt):
1505
1147
    """See build_tree."""
1506
 
    for num, _unused in enumerate(wt.all_file_ids()):
1507
 
        if num > 0:  # more than just a root
1508
 
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
1148
    if len(wt.inventory) > 1:  # more than just a root
 
1149
        raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
1509
1150
    file_trans_id = {}
1510
1151
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1511
1152
    pp = ProgressPhase("Build phase", 2, top_pb)
1512
1153
    if tree.inventory.root is not None:
1513
 
        # This is kind of a hack: we should be altering the root
1514
 
        # as part of the regular tree shape diff logic.
1515
 
        # The conditional test here is to avoid doing an
 
1154
        # this is kindof a hack: we should be altering the root 
 
1155
        # as partof the regular tree shape diff logic.
 
1156
        # the conditional test hereis to avoid doing an
1516
1157
        # expensive operation (flush) every time the root id
1517
1158
        # is set within the tree, nor setting the root and thus
1518
1159
        # marking the tree as dirty, because we use two different
1519
1160
        # idioms here: tree interfaces and inventory interfaces.
1520
 
        if wt.get_root_id() != tree.get_root_id():
1521
 
            wt.set_root_id(tree.get_root_id())
 
1161
        if wt.path2id('') != tree.inventory.root.file_id:
 
1162
            wt.set_root_id(tree.inventory.root.file_id)
1522
1163
            wt.flush()
1523
1164
    tt = TreeTransform(wt)
1524
1165
    divert = set()
1528
1169
            tt.trans_id_tree_file_id(wt.get_root_id())
1529
1170
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
1530
1171
        try:
1531
 
            deferred_contents = []
1532
 
            num = 0
1533
1172
            for num, (tree_path, entry) in \
1534
1173
                enumerate(tree.inventory.iter_entries_by_dir()):
1535
 
                pb.update("Building tree", num - len(deferred_contents),
1536
 
                          len(tree.inventory))
 
1174
                pb.update("Building tree", num, len(tree.inventory))
1537
1175
                if entry.parent_id is None:
1538
1176
                    continue
1539
1177
                reparent = False
1562
1200
                        'entry %s parent id %r is not in file_trans_id %r'
1563
1201
                        % (entry, entry.parent_id, file_trans_id))
1564
1202
                parent_id = file_trans_id[entry.parent_id]
1565
 
                if entry.kind == 'file':
1566
 
                    # We *almost* replicate new_by_entry, so that we can defer
1567
 
                    # getting the file text, and get them all at once.
1568
 
                    trans_id = tt.create_path(entry.name, parent_id)
1569
 
                    file_trans_id[file_id] = trans_id
1570
 
                    tt.version_file(entry.file_id, trans_id)
1571
 
                    executable = tree.is_executable(entry.file_id, tree_path)
1572
 
                    if executable is not None:
1573
 
                        tt.set_executability(executable, trans_id)
1574
 
                    deferred_contents.append((entry.file_id, trans_id))
1575
 
                else:
1576
 
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1577
 
                                                          tree)
 
1203
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
 
1204
                                                      tree)
1578
1205
                if reparent:
1579
1206
                    new_trans_id = file_trans_id[file_id]
1580
1207
                    old_parent = tt.trans_id_tree_path(tree_path)
1581
1208
                    _reparent_children(tt, old_parent, new_trans_id)
1582
 
            offset = num + 1 - len(deferred_contents)
1583
 
            _create_files(tt, tree, deferred_contents, pb, offset,
1584
 
                          accelerator_tree, hardlink)
1585
1209
        finally:
1586
1210
            pb.finished()
1587
1211
        pp.next_phase()
1595
1219
            wt.add_conflicts(conflicts)
1596
1220
        except errors.UnsupportedOperation:
1597
1221
            pass
1598
 
        result = tt.apply(no_conflicts=True)
 
1222
        tt.apply()
1599
1223
    finally:
1600
1224
        tt.finalize()
1601
1225
        top_pb.finished()
1602
 
    return result
1603
 
 
1604
 
 
1605
 
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
1606
 
                  hardlink):
1607
 
    total = len(desired_files) + offset
1608
 
    if accelerator_tree is None:
1609
 
        new_desired_files = desired_files
1610
 
    else:
1611
 
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
1612
 
        unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
1613
 
                         in iter if not (c or e[0] != e[1]))
1614
 
        new_desired_files = []
1615
 
        count = 0
1616
 
        for file_id, trans_id in desired_files:
1617
 
            accelerator_path = unchanged.get(file_id)
1618
 
            if accelerator_path is None:
1619
 
                new_desired_files.append((file_id, trans_id))
1620
 
                continue
1621
 
            pb.update('Adding file contents', count + offset, total)
1622
 
            if hardlink:
1623
 
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
1624
 
                                   trans_id)
1625
 
            else:
1626
 
                contents = accelerator_tree.get_file(file_id, accelerator_path)
1627
 
                try:
1628
 
                    tt.create_file(contents, trans_id)
1629
 
                finally:
1630
 
                    contents.close()
1631
 
            count += 1
1632
 
        offset += count
1633
 
    for count, (trans_id, contents) in enumerate(tree.iter_files_bytes(
1634
 
                                                 new_desired_files)):
1635
 
        tt.create_file(contents, trans_id)
1636
 
        pb.update('Adding file contents', count + offset, total)
1637
1226
 
1638
1227
 
1639
1228
def _reparent_children(tt, old_parent, new_parent):
1640
1229
    for child in tt.iter_tree_children(old_parent):
1641
1230
        tt.adjust_path(tt.final_name(child), new_parent, child)
1642
1231
 
1643
 
def _reparent_transform_children(tt, old_parent, new_parent):
1644
 
    by_parent = tt.by_parent()
1645
 
    for child in by_parent[old_parent]:
1646
 
        tt.adjust_path(tt.final_name(child), new_parent, child)
1647
 
    return by_parent[old_parent]
1648
1232
 
1649
1233
def _content_match(tree, entry, file_id, kind, target_path):
1650
1234
    if entry.kind != kind:
1709
1293
    else:
1710
1294
        raise errors.BadFileKindError(name, kind)
1711
1295
 
1712
 
 
1713
1296
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1714
1297
    """Create new file contents according to an inventory entry."""
1715
1298
    if entry.kind == "file":
1721
1304
    elif entry.kind == "directory":
1722
1305
        tt.create_directory(trans_id)
1723
1306
 
1724
 
 
1725
1307
def create_entry_executability(tt, entry, trans_id):
1726
1308
    """Set the executability of a trans_id according to an inventory entry"""
1727
1309
    if entry.kind == "file":
1745
1327
        working_tree.unlock()
1746
1328
 
1747
1329
 
1748
 
@deprecated_function(zero_ninety)
1749
1330
def change_entry(tt, file_id, working_tree, target_tree, 
1750
1331
                 trans_id_file_id, backups, trans_id, by_parent):
1751
1332
    """Replace a file_id's contents with those from a target tree."""
1752
 
    if file_id is None and target_tree is None:
1753
 
        # skip the logic altogether in the deprecation test
1754
 
        return
1755
1333
    e_trans_id = trans_id_file_id(file_id)
1756
1334
    entry = target_tree.inventory[file_id]
1757
1335
    has_contents, contents_mod, meta_mod, = _entry_changes(file_id, entry, 
1842
1420
        pp.next_phase()
1843
1421
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1844
1422
        try:
1845
 
            merge_modified = _alter_files(working_tree, target_tree, tt,
1846
 
                                          child_pb, filenames, backups)
 
1423
            _alter_files(working_tree, target_tree, tt, child_pb,
 
1424
                         filenames, backups)
1847
1425
        finally:
1848
1426
            child_pb.finished()
1849
1427
        pp.next_phase()
1850
1428
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1851
1429
        try:
1852
 
            raw_conflicts = resolve_conflicts(tt, child_pb,
1853
 
                lambda t, c: conflict_pass(t, c, target_tree))
 
1430
            raw_conflicts = resolve_conflicts(tt, child_pb)
1854
1431
        finally:
1855
1432
            child_pb.finished()
1856
1433
        conflicts = cook_conflicts(raw_conflicts, tt)
1857
1434
        if change_reporter:
1858
1435
            change_reporter = delta._ChangeReporter(
1859
1436
                unversioned_filter=working_tree.is_ignored)
1860
 
            delta.report_changes(tt.iter_changes(), change_reporter)
 
1437
            delta.report_changes(tt._iter_changes(), change_reporter)
1861
1438
        for conflict in conflicts:
1862
1439
            warning(conflict)
1863
1440
        pp.next_phase()
1864
1441
        tt.apply()
1865
 
        working_tree.set_merge_modified(merge_modified)
 
1442
        working_tree.set_merge_modified({})
1866
1443
    finally:
1867
1444
        target_tree.unlock()
1868
1445
        tt.finalize()
1873
1450
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1874
1451
                 backups):
1875
1452
    merge_modified = working_tree.merge_modified()
1876
 
    change_list = target_tree.iter_changes(working_tree,
 
1453
    change_list = target_tree._iter_changes(working_tree,
1877
1454
        specific_files=specific_files, pb=pb)
1878
1455
    if target_tree.inventory.root is None:
1879
1456
        skip_root = True
1881
1458
        skip_root = False
1882
1459
    basis_tree = None
1883
1460
    try:
1884
 
        deferred_files = []
1885
1461
        for id_num, (file_id, path, changed_content, versioned, parent, name,
1886
1462
                kind, executable) in enumerate(change_list):
1887
1463
            if skip_root and file_id[0] is not None and parent[0] is None:
1893
1469
                if kind[0] == 'file' and (backups or kind[1] is None):
1894
1470
                    wt_sha1 = working_tree.get_file_sha1(file_id)
1895
1471
                    if merge_modified.get(file_id) != wt_sha1:
1896
 
                        # acquire the basis tree lazily to prevent the
1897
 
                        # expense of accessing it when it's not needed ?
1898
 
                        # (Guessing, RBC, 200702)
 
1472
                        # acquire the basis tree lazyily to prevent the expense
 
1473
                        # of accessing it when its not needed ? (Guessing, RBC,
 
1474
                        # 200702)
1899
1475
                        if basis_tree is None:
1900
1476
                            basis_tree = working_tree.basis_tree()
1901
1477
                            basis_tree.lock_read()
1927
1503
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
1928
1504
                                      trans_id)
1929
1505
                elif kind[1] == 'file':
1930
 
                    deferred_files.append((file_id, (trans_id, mode_id)))
1931
 
                    if basis_tree is None:
1932
 
                        basis_tree = working_tree.basis_tree()
1933
 
                        basis_tree.lock_read()
1934
 
                    new_sha1 = target_tree.get_file_sha1(file_id)
1935
 
                    if (file_id in basis_tree and new_sha1 ==
1936
 
                        basis_tree.get_file_sha1(file_id)):
1937
 
                        if file_id in merge_modified:
1938
 
                            del merge_modified[file_id]
1939
 
                    else:
1940
 
                        merge_modified[file_id] = new_sha1
1941
 
 
 
1506
                    tt.create_file(target_tree.get_file_lines(file_id),
 
1507
                                   trans_id, mode_id)
1942
1508
                    # preserve the execute bit when backing up
1943
1509
                    if keep_content and executable[0] == executable[1]:
1944
1510
                        tt.set_executability(executable[1], trans_id)
1954
1520
                    name[1], tt.trans_id_file_id(parent[1]), trans_id)
1955
1521
            if executable[0] != executable[1] and kind[1] == "file":
1956
1522
                tt.set_executability(executable[1], trans_id)
1957
 
        for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
1958
 
            deferred_files):
1959
 
            tt.create_file(bytes, trans_id, mode_id)
1960
1523
    finally:
1961
1524
        if basis_tree is not None:
1962
1525
            basis_tree.unlock()
1963
 
    return merge_modified
1964
1526
 
1965
1527
 
1966
1528
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
1980
1542
        pb.clear()
1981
1543
 
1982
1544
 
1983
 
def conflict_pass(tt, conflicts, path_tree=None):
1984
 
    """Resolve some classes of conflicts.
1985
 
 
1986
 
    :param tt: The transform to resolve conflicts in
1987
 
    :param conflicts: The conflicts to resolve
1988
 
    :param path_tree: A Tree to get supplemental paths from
1989
 
    """
 
1545
def conflict_pass(tt, conflicts):
 
1546
    """Resolve some classes of conflicts."""
1990
1547
    new_conflicts = set()
1991
1548
    for c_type, conflict in ((c[0], c) for c in conflicts):
1992
1549
        if c_type == 'duplicate id':
1995
1552
                               conflict[1], conflict[2], ))
1996
1553
        elif c_type == 'duplicate':
1997
1554
            # files that were renamed take precedence
 
1555
            new_name = tt.final_name(conflict[1])+'.moved'
1998
1556
            final_parent = tt.final_parent(conflict[1])
1999
1557
            if tt.path_changed(conflict[1]):
2000
 
                existing_file, new_file = conflict[2], conflict[1]
 
1558
                tt.adjust_path(new_name, final_parent, conflict[2])
 
1559
                new_conflicts.add((c_type, 'Moved existing file to', 
 
1560
                                   conflict[2], conflict[1]))
2001
1561
            else:
2002
 
                existing_file, new_file = conflict[1], conflict[2]
2003
 
            new_name = tt.final_name(existing_file)+'.moved'
2004
 
            tt.adjust_path(new_name, final_parent, existing_file)
2005
 
            new_conflicts.add((c_type, 'Moved existing file to', 
2006
 
                               existing_file, new_file))
 
1562
                tt.adjust_path(new_name, final_parent, conflict[1])
 
1563
                new_conflicts.add((c_type, 'Moved existing file to', 
 
1564
                                  conflict[1], conflict[2]))
2007
1565
        elif c_type == 'parent loop':
2008
1566
            # break the loop by undoing one of the ops that caused the loop
2009
1567
            cur = conflict[1]
2020
1578
                new_conflicts.add(('deleting parent', 'Not deleting', 
2021
1579
                                   trans_id))
2022
1580
            except KeyError:
2023
 
                create = True
2024
 
                try:
2025
 
                    tt.final_name(trans_id)
2026
 
                except NoFinalPath:
2027
 
                    if path_tree is not None:
2028
 
                        file_id = tt.final_file_id(trans_id)
2029
 
                        if file_id is None:
2030
 
                            file_id = tt.inactive_file_id(trans_id)
2031
 
                        entry = path_tree.inventory[file_id]
2032
 
                        # special-case the other tree root (move its
2033
 
                        # children to current root)
2034
 
                        if entry.parent_id is None:
2035
 
                            create=False
2036
 
                            moved = _reparent_transform_children(
2037
 
                                tt, trans_id, tt.root)
2038
 
                            for child in moved:
2039
 
                                new_conflicts.add((c_type, 'Moved to root',
2040
 
                                                   child))
2041
 
                        else:
2042
 
                            parent_trans_id = tt.trans_id_file_id(
2043
 
                                entry.parent_id)
2044
 
                            tt.adjust_path(entry.name, parent_trans_id,
2045
 
                                           trans_id)
2046
 
                if create:
2047
 
                    tt.create_directory(trans_id)
2048
 
                    new_conflicts.add((c_type, 'Created directory', trans_id))
 
1581
                tt.create_directory(trans_id)
 
1582
                new_conflicts.add((c_type, 'Created directory', trans_id))
2049
1583
        elif c_type == 'unversioned parent':
2050
 
            file_id = tt.inactive_file_id(conflict[1])
2051
 
            # special-case the other tree root (move its children instead)
2052
 
            if path_tree and file_id in path_tree:
2053
 
                if path_tree.inventory[file_id].parent_id is None:
2054
 
                    continue
2055
 
            tt.version_file(file_id, conflict[1])
 
1584
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
2056
1585
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2057
 
        elif c_type == 'non-directory parent':
2058
 
            parent_id = conflict[1]
2059
 
            parent_parent = tt.final_parent(parent_id)
2060
 
            parent_name = tt.final_name(parent_id)
2061
 
            parent_file_id = tt.final_file_id(parent_id)
2062
 
            new_parent_id = tt.new_directory(parent_name + '.new',
2063
 
                parent_parent, parent_file_id)
2064
 
            _reparent_transform_children(tt, parent_id, new_parent_id)
2065
 
            if parent_file_id is not None:
2066
 
                tt.unversion_file(parent_id)
2067
 
            new_conflicts.add((c_type, 'Created directory', new_parent_id))
2068
1586
    return new_conflicts
2069
1587
 
2070
1588
 
2094
1612
                                   file_id=modified_id, 
2095
1613
                                   conflict_path=conflicting_path,
2096
1614
                                   conflict_file_id=conflicting_id)
2097
 
 
2098
 
 
2099
 
class _FileMover(object):
2100
 
    """Moves and deletes files for TreeTransform, tracking operations"""
2101
 
 
2102
 
    def __init__(self):
2103
 
        self.past_renames = []
2104
 
        self.pending_deletions = []
2105
 
 
2106
 
    def rename(self, from_, to):
2107
 
        """Rename a file from one path to another.  Functions like os.rename"""
2108
 
        try:
2109
 
            os.rename(from_, to)
2110
 
        except OSError, e:
2111
 
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2112
 
                raise errors.FileExists(to, str(e))
2113
 
            raise
2114
 
        self.past_renames.append((from_, to))
2115
 
 
2116
 
    def pre_delete(self, from_, to):
2117
 
        """Rename a file out of the way and mark it for deletion.
2118
 
 
2119
 
        Unlike os.unlink, this works equally well for files and directories.
2120
 
        :param from_: The current file path
2121
 
        :param to: A temporary path for the file
2122
 
        """
2123
 
        self.rename(from_, to)
2124
 
        self.pending_deletions.append(to)
2125
 
 
2126
 
    def rollback(self):
2127
 
        """Reverse all renames that have been performed"""
2128
 
        for from_, to in reversed(self.past_renames):
2129
 
            os.rename(to, from_)
2130
 
        # after rollback, don't reuse _FileMover
2131
 
        past_renames = None
2132
 
        pending_deletions = None
2133
 
 
2134
 
    def apply_deletions(self):
2135
 
        """Apply all marked deletions"""
2136
 
        for path in self.pending_deletions:
2137
 
            delete_any(path)
2138
 
        # after apply_deletions, don't reuse _FileMover
2139
 
        past_renames = None
2140
 
        pending_deletions = None