/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Neil Martinsen-Burrell
  • Date: 2009-11-25 16:04:57 UTC
  • mto: This revision was merged to the branch mainline in revision 4843.
  • Revision ID: nmb@wartburg.edu-20091125160457-56y1yl8iw4y9q4x8
Add discussion of conflicts

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
 
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.
1161
1075
        if (trans_id in self._limbo_files and
1162
1076
            trans_id not in self._needs_rename):
1163
1077
            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]
 
1078
            self._limbo_children[previous_parent].remove(trans_id)
 
1079
            del self._limbo_children_names[previous_parent][previous_name]
1168
1080
 
1169
1081
    def _rename_in_limbo(self, trans_ids):
1170
1082
        """Fix limbo names so that the right final path is produced.
1182
1094
            if trans_id not in self._new_contents:
1183
1095
                continue
1184
1096
            new_path = self._limbo_name(trans_id)
1185
 
            osutils.rename(old_path, new_path)
 
1097
            os.rename(old_path, new_path)
1186
1098
            for descendant in self._limbo_descendants(trans_id):
1187
1099
                desc_path = self._limbo_files[descendant]
1188
1100
                desc_path = new_path + desc_path[len(old_path):]
1221
1133
            f.writelines(contents)
1222
1134
        finally:
1223
1135
            f.close()
1224
 
        self._set_mtime(name)
1225
1136
        self._set_mode(trans_id, mode_id, S_ISREG)
1226
1137
 
1227
1138
    def _read_file_chunks(self, trans_id):
1234
1145
    def _read_symlink_target(self, trans_id):
1235
1146
        return os.readlink(self._limbo_name(trans_id))
1236
1147
 
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
1148
    def create_hardlink(self, path, trans_id):
1247
1149
        """Schedule creation of a hard link"""
1248
1150
        name = self._limbo_name(trans_id)
1362
1264
    FileMover does not delete files until it is sure that a rollback will not
1363
1265
    happen.
1364
1266
    """
1365
 
    def __init__(self, tree, pb=None):
 
1267
    def __init__(self, tree, pb=DummyProgress()):
1366
1268
        """Note: a tree_write lock is taken on the tree.
1367
1269
 
1368
1270
        Use TreeTransform.finalize() to release the lock (can be omitted if
1651
1553
                child_pb.update('removing file', num, len(tree_paths))
1652
1554
                full_path = self._tree.abspath(path)
1653
1555
                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):
 
1556
                    mover.pre_delete(full_path, os.path.join(self._deletiondir,
 
1557
                                     trans_id))
 
1558
                elif trans_id in self._new_name or trans_id in \
 
1559
                    self._new_parent:
1658
1560
                    try:
1659
1561
                        mover.rename(full_path, self._limbo_name(trans_id))
1660
1562
                    except OSError, e:
1714
1616
    unversioned files in the input tree.
1715
1617
    """
1716
1618
 
1717
 
    def __init__(self, tree, pb=None, case_sensitive=True):
 
1619
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1718
1620
        tree.lock_read()
1719
1621
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
1720
1622
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
1820
1722
            executable = self.is_executable(file_id, path)
1821
1723
        return kind, executable, None
1822
1724
 
1823
 
    def is_locked(self):
1824
 
        return False
1825
 
 
1826
1725
    def lock_read(self):
1827
1726
        # Perhaps in theory, this should lock the TreeTransform?
1828
 
        return self
 
1727
        pass
1829
1728
 
1830
1729
    def unlock(self):
1831
1730
        pass
2074
1973
                statval = os.lstat(limbo_name)
2075
1974
                size = statval.st_size
2076
1975
                if not supports_executable():
2077
 
                    executable = False
 
1976
                    executable = None
2078
1977
                else:
2079
1978
                    executable = statval.st_mode & S_IEXEC
2080
1979
            else:
2082
1981
                executable = None
2083
1982
            if kind == 'symlink':
2084
1983
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
2085
 
        executable = tt._new_executability.get(trans_id, executable)
 
1984
        if supports_executable():
 
1985
            executable = tt._new_executability.get(trans_id, executable)
2086
1986
        return kind, size, executable, link_or_sha1
2087
1987
 
2088
1988
    def iter_changes(self, from_tree, include_unchanged=False,
2401
2301
        new_desired_files = desired_files
2402
2302
    else:
2403
2303
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2404
 
        unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2405
 
                     in iter if not (c or e[0] != e[1])]
2406
 
        if accelerator_tree.supports_content_filtering():
2407
 
            unchanged = [(f, p) for (f, p) in unchanged
2408
 
                         if not accelerator_tree.iter_search_rules([p]).next()]
2409
 
        unchanged = dict(unchanged)
 
2304
        unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
 
2305
                         in iter if not (c or e[0] != e[1]))
2410
2306
        new_desired_files = []
2411
2307
        count = 0
2412
2308
        for file_id, (trans_id, tree_path) in desired_files:
2535
2431
        tt.create_directory(trans_id)
2536
2432
 
2537
2433
 
2538
 
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2539
 
    filter_tree_path=None):
2540
 
    """Create new file contents according to tree contents.
2541
 
    
2542
 
    :param filter_tree_path: the tree path to use to lookup
2543
 
      content filters to apply to the bytes output in the working tree.
2544
 
      This only applies if the working tree supports content filtering.
2545
 
    """
 
2434
def create_from_tree(tt, trans_id, tree, file_id, bytes=None):
 
2435
    """Create new file contents according to tree contents."""
2546
2436
    kind = tree.kind(file_id)
2547
2437
    if kind == 'directory':
2548
2438
        tt.create_directory(trans_id)
2553
2443
                bytes = tree_file.readlines()
2554
2444
            finally:
2555
2445
                tree_file.close()
2556
 
        wt = tt._tree
2557
 
        if wt.supports_content_filtering() and filter_tree_path is not None:
2558
 
            filters = wt._content_filter_stack(filter_tree_path)
2559
 
            bytes = filtered_output_bytes(bytes, filters,
2560
 
                ContentFilterContext(filter_tree_path, tree))
2561
2446
        tt.create_file(bytes, trans_id)
2562
2447
    elif kind == "symlink":
2563
2448
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
2615
2500
 
2616
2501
 
2617
2502
def revert(working_tree, target_tree, filenames, backups=False,
2618
 
           pb=None, change_reporter=None):
 
2503
           pb=DummyProgress(), change_reporter=None):
2619
2504
    """Revert a working tree's contents to those of a target tree."""
2620
2505
    target_tree.lock_read()
2621
 
    pb = ui.ui_factory.nested_progress_bar()
2622
2506
    tt = TreeTransform(working_tree, pb)
2623
2507
    try:
2624
2508
        pp = ProgressPhase("Revert phase", 3, pb)
2643
2527
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2644
2528
                              backups, pp, basis_tree=None,
2645
2529
                              merge_modified=None):
 
2530
    pp.next_phase()
2646
2531
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2647
2532
    try:
2648
2533
        if merge_modified is None:
2652
2537
                                      merge_modified, basis_tree)
2653
2538
    finally:
2654
2539
        child_pb.finished()
 
2540
    pp.next_phase()
2655
2541
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2656
2542
    try:
2657
2543
        raw_conflicts = resolve_conflicts(tt, child_pb,
2750
2636
                    parent_trans = ROOT_PARENT
2751
2637
                else:
2752
2638
                    parent_trans = tt.trans_id_file_id(parent[1])
2753
 
                if parent[0] is None and versioned[0]:
2754
 
                    tt.adjust_root_path(name[1], parent_trans)
2755
 
                else:
2756
 
                    tt.adjust_path(name[1], parent_trans, trans_id)
 
2639
                tt.adjust_path(name[1], parent_trans, trans_id)
2757
2640
            if executable[0] != executable[1] and kind[1] == "file":
2758
2641
                tt.set_executability(executable[1], trans_id)
2759
2642
        if working_tree.supports_content_filtering():
2772
2655
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2773
2656
                deferred_files):
2774
2657
                tt.create_file(bytes, trans_id, mode_id)
2775
 
        tt.fixup_new_roots()
2776
2658
    finally:
2777
2659
        if basis_tree is not None:
2778
2660
            basis_tree.unlock()
2779
2661
    return merge_modified
2780
2662
 
2781
2663
 
2782
 
def resolve_conflicts(tt, pb=None, pass_func=None):
 
2664
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
2783
2665
    """Make many conflict-resolution attempts, but die if they fail"""
2784
2666
    if pass_func is None:
2785
2667
        pass_func = conflict_pass
2786
2668
    new_conflicts = set()
2787
 
    pb = ui.ui_factory.nested_progress_bar()
2788
2669
    try:
2789
2670
        for n in range(10):
2790
2671
            pb.update('Resolution pass', n+1, 10)
2794
2675
            new_conflicts.update(pass_func(tt, conflicts))
2795
2676
        raise MalformedTransform(conflicts=conflicts)
2796
2677
    finally:
2797
 
        pb.finished()
 
2678
        pb.clear()
2798
2679
 
2799
2680
 
2800
2681
def conflict_pass(tt, conflicts, path_tree=None):
2849
2730
                        # special-case the other tree root (move its
2850
2731
                        # children to current root)
2851
2732
                        if entry.parent_id is None:
2852
 
                            create = False
 
2733
                            create=False
2853
2734
                            moved = _reparent_transform_children(
2854
2735
                                tt, trans_id, tt.root)
2855
2736
                            for child in moved:
2923
2804
        self.pending_deletions = []
2924
2805
 
2925
2806
    def rename(self, from_, to):
2926
 
        """Rename a file from one path to another."""
 
2807
        """Rename a file from one path to another.  Functions like os.rename"""
2927
2808
        try:
2928
 
            osutils.rename(from_, to)
 
2809
            os.rename(from_, to)
2929
2810
        except OSError, e:
2930
2811
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2931
2812
                raise errors.FileExists(to, str(e))
2945
2826
    def rollback(self):
2946
2827
        """Reverse all renames that have been performed"""
2947
2828
        for from_, to in reversed(self.past_renames):
2948
 
            osutils.rename(to, from_)
 
2829
            os.rename(to, from_)
2949
2830
        # after rollback, don't reuse _FileMover
2950
2831
        past_renames = None
2951
2832
        pending_deletions = None