/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: Ian Clatworthy
  • Date: 2009-10-19 04:55:02 UTC
  • mto: (4634.82.1 integration-2.0)
  • mto: This revision was merged to the branch mainline in revision 4770.
  • Revision ID: ian.clatworthy@canonical.com-20091019045502-4te14y7nkbpj10bt
remove out of date format information in filtered views doc

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)
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
 
1097
            os.rename(old_path, new_path)
1197
1098
 
1198
1099
    def create_file(self, contents, trans_id, mode_id=None):
1199
1100
        """Schedule creation of a new file.
1221
1122
            f.writelines(contents)
1222
1123
        finally:
1223
1124
            f.close()
1224
 
        self._set_mtime(name)
1225
1125
        self._set_mode(trans_id, mode_id, S_ISREG)
1226
1126
 
1227
1127
    def _read_file_chunks(self, trans_id):
1234
1134
    def _read_symlink_target(self, trans_id):
1235
1135
        return os.readlink(self._limbo_name(trans_id))
1236
1136
 
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
1137
    def create_hardlink(self, path, trans_id):
1247
1138
        """Schedule creation of a hard link"""
1248
1139
        name = self._limbo_name(trans_id)
1362
1253
    FileMover does not delete files until it is sure that a rollback will not
1363
1254
    happen.
1364
1255
    """
1365
 
    def __init__(self, tree, pb=None):
 
1256
    def __init__(self, tree, pb=DummyProgress()):
1366
1257
        """Note: a tree_write lock is taken on the tree.
1367
1258
 
1368
1259
        Use TreeTransform.finalize() to release the lock (can be omitted if
1651
1542
                child_pb.update('removing file', num, len(tree_paths))
1652
1543
                full_path = self._tree.abspath(path)
1653
1544
                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):
 
1545
                    mover.pre_delete(full_path, os.path.join(self._deletiondir,
 
1546
                                     trans_id))
 
1547
                elif trans_id in self._new_name or trans_id in \
 
1548
                    self._new_parent:
1658
1549
                    try:
1659
1550
                        mover.rename(full_path, self._limbo_name(trans_id))
1660
 
                    except errors.TransformRenameFailed, e:
 
1551
                    except OSError, e:
1661
1552
                        if e.errno != errno.ENOENT:
1662
1553
                            raise
1663
1554
                    else:
1688
1579
                if trans_id in self._needs_rename:
1689
1580
                    try:
1690
1581
                        mover.rename(self._limbo_name(trans_id), full_path)
1691
 
                    except errors.TransformRenameFailed, e:
 
1582
                    except OSError, e:
1692
1583
                        # We may be renaming a dangling inventory id
1693
1584
                        if e.errno != errno.ENOENT:
1694
1585
                            raise
1714
1605
    unversioned files in the input tree.
1715
1606
    """
1716
1607
 
1717
 
    def __init__(self, tree, pb=None, case_sensitive=True):
 
1608
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1718
1609
        tree.lock_read()
1719
1610
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
1720
1611
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
1792
1683
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1793
1684
                       self._iter_parent_trees()]
1794
1685
        vf.add_lines((file_id, tree_revision), parent_keys,
1795
 
                     self.get_file_lines(file_id))
 
1686
                     self.get_file(file_id).readlines())
1796
1687
        repo = self._get_repository()
1797
1688
        base_vf = repo.texts
1798
1689
        if base_vf not in vf.fallback_versionedfiles:
1820
1711
            executable = self.is_executable(file_id, path)
1821
1712
        return kind, executable, None
1822
1713
 
1823
 
    def is_locked(self):
1824
 
        return False
1825
 
 
1826
1714
    def lock_read(self):
1827
1715
        # Perhaps in theory, this should lock the TreeTransform?
1828
 
        return self
 
1716
        pass
1829
1717
 
1830
1718
    def unlock(self):
1831
1719
        pass
2014
1902
    def get_file_mtime(self, file_id, path=None):
2015
1903
        """See Tree.get_file_mtime"""
2016
1904
        if not self._content_change(file_id):
2017
 
            return self._transform._tree.get_file_mtime(file_id)
 
1905
            return self._transform._tree.get_file_mtime(file_id, path)
2018
1906
        return self._stat_limbo_file(file_id).st_mtime
2019
1907
 
2020
1908
    def _file_size(self, entry, stat_value):
2074
1962
                statval = os.lstat(limbo_name)
2075
1963
                size = statval.st_size
2076
1964
                if not supports_executable():
2077
 
                    executable = False
 
1965
                    executable = None
2078
1966
                else:
2079
1967
                    executable = statval.st_mode & S_IEXEC
2080
1968
            else:
2082
1970
                executable = None
2083
1971
            if kind == 'symlink':
2084
1972
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
2085
 
        executable = tt._new_executability.get(trans_id, executable)
 
1973
        if supports_executable():
 
1974
            executable = tt._new_executability.get(trans_id, executable)
2086
1975
        return kind, size, executable, link_or_sha1
2087
1976
 
2088
1977
    def iter_changes(self, from_tree, include_unchanged=False,
2401
2290
        new_desired_files = desired_files
2402
2291
    else:
2403
2292
        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)
 
2293
        unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
 
2294
                         in iter if not (c or e[0] != e[1]))
2410
2295
        new_desired_files = []
2411
2296
        count = 0
2412
2297
        for file_id, (trans_id, tree_path) in desired_files:
2460
2345
    if entry.kind == "directory":
2461
2346
        return True
2462
2347
    if entry.kind == "file":
2463
 
        f = file(target_path, 'rb')
2464
 
        try:
2465
 
            if tree.get_file_text(file_id) == f.read():
2466
 
                return True
2467
 
        finally:
2468
 
            f.close()
 
2348
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
 
2349
            return True
2469
2350
    elif entry.kind == "symlink":
2470
2351
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2471
2352
            return True
2539
2420
        tt.create_directory(trans_id)
2540
2421
 
2541
2422
 
2542
 
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2543
 
    filter_tree_path=None):
2544
 
    """Create new file contents according to tree contents.
2545
 
    
2546
 
    :param filter_tree_path: the tree path to use to lookup
2547
 
      content filters to apply to the bytes output in the working tree.
2548
 
      This only applies if the working tree supports content filtering.
2549
 
    """
 
2423
def create_from_tree(tt, trans_id, tree, file_id, bytes=None):
 
2424
    """Create new file contents according to tree contents."""
2550
2425
    kind = tree.kind(file_id)
2551
2426
    if kind == 'directory':
2552
2427
        tt.create_directory(trans_id)
2557
2432
                bytes = tree_file.readlines()
2558
2433
            finally:
2559
2434
                tree_file.close()
2560
 
        wt = tt._tree
2561
 
        if wt.supports_content_filtering() and filter_tree_path is not None:
2562
 
            filters = wt._content_filter_stack(filter_tree_path)
2563
 
            bytes = filtered_output_bytes(bytes, filters,
2564
 
                ContentFilterContext(filter_tree_path, tree))
2565
2435
        tt.create_file(bytes, trans_id)
2566
2436
    elif kind == "symlink":
2567
2437
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
2619
2489
 
2620
2490
 
2621
2491
def revert(working_tree, target_tree, filenames, backups=False,
2622
 
           pb=None, change_reporter=None):
 
2492
           pb=DummyProgress(), change_reporter=None):
2623
2493
    """Revert a working tree's contents to those of a target tree."""
2624
2494
    target_tree.lock_read()
2625
 
    pb = ui.ui_factory.nested_progress_bar()
2626
2495
    tt = TreeTransform(working_tree, pb)
2627
2496
    try:
2628
2497
        pp = ProgressPhase("Revert phase", 3, pb)
2647
2516
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2648
2517
                              backups, pp, basis_tree=None,
2649
2518
                              merge_modified=None):
 
2519
    pp.next_phase()
2650
2520
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2651
2521
    try:
2652
2522
        if merge_modified is None:
2656
2526
                                      merge_modified, basis_tree)
2657
2527
    finally:
2658
2528
        child_pb.finished()
 
2529
    pp.next_phase()
2659
2530
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2660
2531
    try:
2661
2532
        raw_conflicts = resolve_conflicts(tt, child_pb,
2754
2625
                    parent_trans = ROOT_PARENT
2755
2626
                else:
2756
2627
                    parent_trans = tt.trans_id_file_id(parent[1])
2757
 
                if parent[0] is None and versioned[0]:
2758
 
                    tt.adjust_root_path(name[1], parent_trans)
2759
 
                else:
2760
 
                    tt.adjust_path(name[1], parent_trans, trans_id)
 
2628
                tt.adjust_path(name[1], parent_trans, trans_id)
2761
2629
            if executable[0] != executable[1] and kind[1] == "file":
2762
2630
                tt.set_executability(executable[1], trans_id)
2763
 
        if working_tree.supports_content_filtering():
2764
 
            for index, ((trans_id, mode_id), bytes) in enumerate(
2765
 
                target_tree.iter_files_bytes(deferred_files)):
2766
 
                file_id = deferred_files[index][0]
2767
 
                # We're reverting a tree to the target tree so using the
2768
 
                # target tree to find the file path seems the best choice
2769
 
                # here IMO - Ian C 27/Oct/2009
2770
 
                filter_tree_path = target_tree.id2path(file_id)
2771
 
                filters = working_tree._content_filter_stack(filter_tree_path)
2772
 
                bytes = filtered_output_bytes(bytes, filters,
2773
 
                    ContentFilterContext(filter_tree_path, working_tree))
2774
 
                tt.create_file(bytes, trans_id, mode_id)
2775
 
        else:
2776
 
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2777
 
                deferred_files):
2778
 
                tt.create_file(bytes, trans_id, mode_id)
2779
 
        tt.fixup_new_roots()
 
2631
        for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
 
2632
            deferred_files):
 
2633
            tt.create_file(bytes, trans_id, mode_id)
2780
2634
    finally:
2781
2635
        if basis_tree is not None:
2782
2636
            basis_tree.unlock()
2783
2637
    return merge_modified
2784
2638
 
2785
2639
 
2786
 
def resolve_conflicts(tt, pb=None, pass_func=None):
 
2640
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
2787
2641
    """Make many conflict-resolution attempts, but die if they fail"""
2788
2642
    if pass_func is None:
2789
2643
        pass_func = conflict_pass
2790
2644
    new_conflicts = set()
2791
 
    pb = ui.ui_factory.nested_progress_bar()
2792
2645
    try:
2793
2646
        for n in range(10):
2794
2647
            pb.update('Resolution pass', n+1, 10)
2798
2651
            new_conflicts.update(pass_func(tt, conflicts))
2799
2652
        raise MalformedTransform(conflicts=conflicts)
2800
2653
    finally:
2801
 
        pb.finished()
 
2654
        pb.clear()
2802
2655
 
2803
2656
 
2804
2657
def conflict_pass(tt, conflicts, path_tree=None):
2853
2706
                        # special-case the other tree root (move its
2854
2707
                        # children to current root)
2855
2708
                        if entry.parent_id is None:
2856
 
                            create = False
 
2709
                            create=False
2857
2710
                            moved = _reparent_transform_children(
2858
2711
                                tt, trans_id, tt.root)
2859
2712
                            for child in moved:
2927
2780
        self.pending_deletions = []
2928
2781
 
2929
2782
    def rename(self, from_, to):
2930
 
        """Rename a file from one path to another."""
 
2783
        """Rename a file from one path to another.  Functions like os.rename"""
2931
2784
        try:
2932
 
            osutils.rename(from_, to)
2933
 
        except (IOError, OSError), e:
 
2785
            os.rename(from_, to)
 
2786
        except OSError, e:
2934
2787
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2935
2788
                raise errors.FileExists(to, str(e))
2936
 
            # normal OSError doesn't include filenames so it's hard to see where
2937
 
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
2938
 
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
 
2789
            raise
2939
2790
        self.past_renames.append((from_, to))
2940
2791
 
2941
2792
    def pre_delete(self, from_, to):
2951
2802
    def rollback(self):
2952
2803
        """Reverse all renames that have been performed"""
2953
2804
        for from_, to in reversed(self.past_renames):
2954
 
            try:
2955
 
                osutils.rename(to, from_)
2956
 
            except (OSError, IOError), e:
2957
 
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)                
 
2805
            os.rename(to, from_)
2958
2806
        # after rollback, don't reuse _FileMover
2959
2807
        past_renames = None
2960
2808
        pending_deletions = None