← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Jelmer Vernooij
  • Date: 2010-12-20 11:57:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5577.
  • Revision ID: jelmer@samba.org-20101220115714-2ru3hfappjweeg7q
Don't use no-plugins.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
19
19
from stat import S_ISREG, S_IEXEC
20
20
import time
21
21
 
22
 
from bzrlib.lazy_import import lazy_import
23
 
lazy_import(globals(), """
 
22
from bzrlib import (
 
23
    errors,
 
24
    lazy_import,
 
25
    registry,
 
26
    )
 
27
lazy_import.lazy_import(globals(), """
24
28
from bzrlib import (
25
29
    annotate,
26
30
    bencode,
32
36
    multiparent,
33
37
    osutils,
34
38
    revision as _mod_revision,
 
39
    trace,
35
40
    ui,
36
41
    )
37
42
""")
55
60
from bzrlib.symbol_versioning import (
56
61
        deprecated_function,
57
62
        deprecated_in,
 
63
        deprecated_method,
58
64
        )
59
65
from bzrlib.trace import mutter, warning
60
66
from bzrlib import tree
64
70
 
65
71
ROOT_PARENT = "root-parent"
66
72
 
67
 
 
68
73
def unique_add(map, key, value):
69
74
    if key in map:
70
75
        raise DuplicateKey(key=key)
71
76
    map[key] = value
72
77
 
73
78
 
 
79
 
74
80
class _TransformResults(object):
75
81
    def __init__(self, modified_paths, rename_count):
76
82
        object.__init__(self)
124
130
            self._new_root = self.trans_id_tree_file_id(root_id)
125
131
        else:
126
132
            self._new_root = None
127
 
        # Indictor of whether the transform has been applied
 
133
        # Indicator of whether the transform has been applied
128
134
        self._done = False
129
135
        # A progress bar
130
136
        self._pb = pb
315
321
 
316
322
    def delete_contents(self, trans_id):
317
323
        """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
 
        self.tree_kind(trans_id)
321
 
        self._removed_contents.add(trans_id)
 
324
        kind = self.tree_kind(trans_id)
 
325
        if kind is not None:
 
326
            self._removed_contents.add(trans_id)
322
327
 
323
328
    def cancel_deletion(self, trans_id):
324
329
        """Cancel a scheduled deletion"""
389
394
        changed_kind = set(self._removed_contents)
390
395
        changed_kind.intersection_update(self._new_contents)
391
396
        changed_kind.difference_update(new_ids)
392
 
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
393
 
                        self.final_kind(t))
 
397
        changed_kind = (t for t in changed_kind
 
398
                        if self.tree_kind(t) != self.final_kind(t))
394
399
        new_ids.update(changed_kind)
395
400
        return sorted(FinalPaths(self).get_paths(new_ids))
396
401
 
397
402
    def final_kind(self, trans_id):
398
403
        """Determine the final file kind, after any changes applied.
399
404
 
400
 
        Raises NoSuchFile if the file does not exist/has no contents.
401
 
        (It is conceivable that a path would be created without the
402
 
        corresponding contents insertion command)
 
405
        :return: None if the file does not exist/has no contents.  (It is
 
406
            conceivable that a path would be created without the corresponding
 
407
            contents insertion command)
403
408
        """
404
409
        if trans_id in self._new_contents:
405
410
            return self._new_contents[trans_id]
406
411
        elif trans_id in self._removed_contents:
407
 
            raise NoSuchFile(None)
 
412
            return None
408
413
        else:
409
414
            return self.tree_kind(trans_id)
410
415
 
532
537
            # ensure that all children are registered with the transaction
533
538
            list(self.iter_tree_children(parent_id))
534
539
 
 
540
    @deprecated_method(deprecated_in((2, 3, 0)))
535
541
    def has_named_child(self, by_parent, parent_id, name):
536
 
        try:
537
 
            children = by_parent[parent_id]
538
 
        except KeyError:
539
 
            children = []
540
 
        for child in children:
 
542
        return self._has_named_child(
 
543
            name, parent_id, known_children=by_parent.get(parent_id, []))
 
544
 
 
545
    def _has_named_child(self, name, parent_id, known_children):
 
546
        """Does a parent already have a name child.
 
547
 
 
548
        :param name: The searched for name.
 
549
 
 
550
        :param parent_id: The parent for which the check is made.
 
551
 
 
552
        :param known_children: The already known children. This should have
 
553
            been recently obtained from `self.by_parent.get(parent_id)`
 
554
            (or will be if None is passed).
 
555
        """
 
556
        if known_children is None:
 
557
            known_children = self.by_parent().get(parent_id, [])
 
558
        for child in known_children:
541
559
            if self.final_name(child) == name:
542
560
                return True
543
 
        try:
544
 
            path = self._tree_id_paths[parent_id]
545
 
        except KeyError:
 
561
        parent_path = self._tree_id_paths.get(parent_id, None)
 
562
        if parent_path is None:
 
563
            # No parent... no children
546
564
            return False
547
 
        childpath = joinpath(path, name)
548
 
        child_id = self._tree_path_ids.get(childpath)
 
565
        child_path = joinpath(parent_path, name)
 
566
        child_id = self._tree_path_ids.get(child_path, None)
549
567
        if child_id is None:
550
 
            return lexists(self._tree.abspath(childpath))
 
568
            # Not known by the tree transform yet, check the filesystem
 
569
            return osutils.lexists(self._tree.abspath(child_path))
551
570
        else:
552
 
            if self.final_parent(child_id) != parent_id:
553
 
                return False
554
 
            if child_id in self._removed_contents:
555
 
                # XXX What about dangling file-ids?
556
 
                return False
557
 
            else:
558
 
                return True
 
571
            raise AssertionError('child_id is missing: %s, %s, %s'
 
572
                                 % (name, parent_id, child_id))
 
573
 
 
574
    def _available_backup_name(self, name, target_id):
 
575
        """Find an available backup name.
 
576
 
 
577
        :param name: The basename of the file.
 
578
 
 
579
        :param target_id: The directory trans_id where the backup should 
 
580
            be placed.
 
581
        """
 
582
        known_children = self.by_parent().get(target_id, [])
 
583
        return osutils.available_backup_name(
 
584
            name,
 
585
            lambda base: self._has_named_child(
 
586
                base, target_id, known_children))
559
587
 
560
588
    def _parent_loops(self):
561
589
        """No entry should be its own ancestor"""
596
624
        """
597
625
        conflicts = []
598
626
        for trans_id in self._new_id.iterkeys():
599
 
            try:
600
 
                kind = self.final_kind(trans_id)
601
 
            except NoSuchFile:
 
627
            kind = self.final_kind(trans_id)
 
628
            if kind is None:
602
629
                conflicts.append(('versioning no contents', trans_id))
603
630
                continue
604
631
            if not InventoryEntry.versionable_kind(kind):
618
645
            if self.final_file_id(trans_id) is None:
619
646
                conflicts.append(('unversioned executability', trans_id))
620
647
            else:
621
 
                try:
622
 
                    non_file = self.final_kind(trans_id) != "file"
623
 
                except NoSuchFile:
624
 
                    non_file = True
625
 
                if non_file is True:
 
648
                if self.final_kind(trans_id) != "file":
626
649
                    conflicts.append(('non-file executability', trans_id))
627
650
        return conflicts
628
651
 
630
653
        """Check for overwrites (not permitted on Win32)"""
631
654
        conflicts = []
632
655
        for trans_id in self._new_contents:
633
 
            try:
634
 
                self.tree_kind(trans_id)
635
 
            except NoSuchFile:
 
656
            if self.tree_kind(trans_id) is None:
636
657
                continue
637
658
            if trans_id not in self._removed_contents:
638
659
                conflicts.append(('overwrite', trans_id,
645
666
        if (self._new_name, self._new_parent) == ({}, {}):
646
667
            return conflicts
647
668
        for children in by_parent.itervalues():
648
 
            name_ids = [(self.final_name(t), t) for t in children]
649
 
            if not self._case_sensitive_target:
650
 
                name_ids = [(n.lower(), t) for n, t in name_ids]
 
669
            name_ids = []
 
670
            for child_tid in children:
 
671
                name = self.final_name(child_tid)
 
672
                if name is not None:
 
673
                    # Keep children only if they still exist in the end
 
674
                    if not self._case_sensitive_target:
 
675
                        name = name.lower()
 
676
                    name_ids.append((name, child_tid))
651
677
            name_ids.sort()
652
678
            last_name = None
653
679
            last_trans_id = None
654
680
            for name, trans_id in name_ids:
655
 
                try:
656
 
                    kind = self.final_kind(trans_id)
657
 
                except NoSuchFile:
658
 
                    kind = None
 
681
                kind = self.final_kind(trans_id)
659
682
                file_id = self.final_file_id(trans_id)
660
683
                if kind is None and file_id is None:
661
684
                    continue
680
703
        return conflicts
681
704
 
682
705
    def _parent_type_conflicts(self, by_parent):
683
 
        """parents must have directory 'contents'."""
 
706
        """Children must have a directory parent"""
684
707
        conflicts = []
685
708
        for parent_id, children in by_parent.iteritems():
686
709
            if parent_id is ROOT_PARENT:
687
710
                continue
688
 
            if not self._any_contents(children):
 
711
            no_children = True
 
712
            for child_id in children:
 
713
                if self.final_kind(child_id) is not None:
 
714
                    no_children = False
 
715
                    break
 
716
            if no_children:
689
717
                continue
690
 
            for child in children:
691
 
                try:
692
 
                    self.final_kind(child)
693
 
                except NoSuchFile:
694
 
                    continue
695
 
            try:
696
 
                kind = self.final_kind(parent_id)
697
 
            except NoSuchFile:
698
 
                kind = None
 
718
            # There is at least a child, so we need an existing directory to
 
719
            # contain it.
 
720
            kind = self.final_kind(parent_id)
699
721
            if kind is None:
 
722
                # The directory will be deleted
700
723
                conflicts.append(('missing parent', parent_id))
701
724
            elif kind != "directory":
 
725
                # Meh, we need a *directory* to put something in it
702
726
                conflicts.append(('non-directory parent', parent_id))
703
727
        return conflicts
704
728
 
705
 
    def _any_contents(self, trans_ids):
706
 
        """Return true if any of the trans_ids, will have contents."""
707
 
        for trans_id in trans_ids:
708
 
            try:
709
 
                kind = self.final_kind(trans_id)
710
 
            except NoSuchFile:
711
 
                continue
712
 
            return True
713
 
        return False
714
 
 
715
729
    def _set_executability(self, path, trans_id):
716
730
        """Set the executability of versioned files """
717
731
        if supports_executable():
781
795
        self.create_symlink(target, trans_id)
782
796
        return trans_id
783
797
 
 
798
    def new_orphan(self, trans_id, parent_id):
 
799
        """Schedule an item to be orphaned.
 
800
 
 
801
        When a directory is about to be removed, its children, if they are not
 
802
        versioned are moved out of the way: they don't have a parent anymore.
 
803
 
 
804
        :param trans_id: The trans_id of the existing item.
 
805
        :param parent_id: The parent trans_id of the item.
 
806
        """
 
807
        raise NotImplementedError(self.new_orphan)
 
808
 
 
809
    def _get_potential_orphans(self, dir_id):
 
810
        """Find the potential orphans in a directory.
 
811
 
 
812
        A directory can't be safely deleted if there are versioned files in it.
 
813
        If all the contained files are unversioned then they can be orphaned.
 
814
 
 
815
        The 'None' return value means that the directory contains at least one
 
816
        versioned file and should not be deleted.
 
817
 
 
818
        :param dir_id: The directory trans id.
 
819
 
 
820
        :return: A list of the orphan trans ids or None if at least one
 
821
             versioned file is present.
 
822
        """
 
823
        orphans = []
 
824
        # Find the potential orphans, stop if one item should be kept
 
825
        for child_tid in self.by_parent()[dir_id]:
 
826
            if child_tid in self._removed_contents:
 
827
                # The child is removed as part of the transform. Since it was
 
828
                # versioned before, it's not an orphan
 
829
                continue
 
830
            elif self.final_file_id(child_tid) is None:
 
831
                # The child is not versioned
 
832
                orphans.append(child_tid)
 
833
            else:
 
834
                # We have a versioned file here, searching for orphans is
 
835
                # meaningless.
 
836
                orphans = None
 
837
                break
 
838
        return orphans
 
839
 
784
840
    def _affected_ids(self):
785
841
        """Return the set of transform ids affected by the transform"""
786
842
        trans_ids = set(self._removed_id)
845
901
        Return a (name, parent, kind, executable) tuple
846
902
        """
847
903
        to_name = self.final_name(to_trans_id)
848
 
        try:
849
 
            to_kind = self.final_kind(to_trans_id)
850
 
        except NoSuchFile:
851
 
            to_kind = None
 
904
        to_kind = self.final_kind(to_trans_id)
852
905
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
853
906
        if to_trans_id in self._new_executability:
854
907
            to_executable = self._new_executability[to_trans_id]
1296
1349
            del self._limbo_children_names[trans_id]
1297
1350
        delete_any(self._limbo_name(trans_id))
1298
1351
 
 
1352
    def new_orphan(self, trans_id, parent_id):
 
1353
        # FIXME: There is no tree config, so we use the branch one (it's weird
 
1354
        # to define it this way as orphaning can only occur in a working tree,
 
1355
        # but that's all we have (for now). It will find the option in
 
1356
        # locations.conf or bazaar.conf though) -- vila 20100916
 
1357
        conf = self._tree.branch.get_config()
 
1358
        conf_var_name = 'bzr.transform.orphan_policy'
 
1359
        orphan_policy = conf.get_user_option(conf_var_name)
 
1360
        default_policy = orphaning_registry.default_key
 
1361
        if orphan_policy is None:
 
1362
            orphan_policy = default_policy
 
1363
        if orphan_policy not in orphaning_registry:
 
1364
            trace.warning('%s (from %s) is not a known policy, defaulting to %s'
 
1365
                          % (orphan_policy, conf_var_name, default_policy))
 
1366
            orphan_policy = default_policy
 
1367
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1368
        handle_orphan(self, trans_id, parent_id)
 
1369
 
 
1370
 
 
1371
class OrphaningError(errors.BzrError):
 
1372
 
 
1373
    # Only bugs could lead to such exception being seen by the user
 
1374
    internal_error = True
 
1375
    _fmt = "Error while orphaning %s in %s directory"
 
1376
 
 
1377
    def __init__(self, orphan, parent):
 
1378
        errors.BzrError.__init__(self)
 
1379
        self.orphan = orphan
 
1380
        self.parent = parent
 
1381
 
 
1382
 
 
1383
class OrphaningForbidden(OrphaningError):
 
1384
 
 
1385
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1386
 
 
1387
    def __init__(self, policy):
 
1388
        errors.BzrError.__init__(self)
 
1389
        self.policy = policy
 
1390
 
 
1391
 
 
1392
def move_orphan(tt, orphan_id, parent_id):
 
1393
    """See TreeTransformBase.new_orphan.
 
1394
 
 
1395
    This creates a new orphan in the `bzr-orphans` dir at the root of the
 
1396
    `TreeTransform`.
 
1397
 
 
1398
    :param tt: The TreeTransform orphaning `trans_id`.
 
1399
 
 
1400
    :param orphan_id: The trans id that should be orphaned.
 
1401
 
 
1402
    :param parent_id: The orphan parent trans id.
 
1403
    """
 
1404
    # Add the orphan dir if it doesn't exist
 
1405
    orphan_dir_basename = 'bzr-orphans'
 
1406
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1407
    if tt.final_kind(od_id) is None:
 
1408
        tt.create_directory(od_id)
 
1409
    parent_path = tt._tree_id_paths[parent_id]
 
1410
    # Find a name that doesn't exist yet in the orphan dir
 
1411
    actual_name = tt.final_name(orphan_id)
 
1412
    new_name = tt._available_backup_name(actual_name, od_id)
 
1413
    tt.adjust_path(new_name, od_id, orphan_id)
 
1414
    trace.warning('%s has been orphaned in %s'
 
1415
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1416
 
 
1417
 
 
1418
def refuse_orphan(tt, orphan_id, parent_id):
 
1419
    """See TreeTransformBase.new_orphan.
 
1420
 
 
1421
    This refuses to create orphan, letting the caller handle the conflict.
 
1422
    """
 
1423
    raise OrphaningForbidden('never')
 
1424
 
 
1425
 
 
1426
orphaning_registry = registry.Registry()
 
1427
orphaning_registry.register(
 
1428
    'conflict', refuse_orphan,
 
1429
    'Leave orphans in place and create a conflict on the directory.')
 
1430
orphaning_registry.register(
 
1431
    'move', move_orphan,
 
1432
    'Move orphans into the bzr-orphans directory.')
 
1433
orphaning_registry._set_default_key('conflict')
 
1434
 
1299
1435
 
1300
1436
class TreeTransform(DiskTreeTransform):
1301
1437
    """Represent a tree transformation.
1419
1555
    def tree_kind(self, trans_id):
1420
1556
        """Determine the file kind in the working tree.
1421
1557
 
1422
 
        Raises NoSuchFile if the file does not exist
 
1558
        :returns: The file kind or None if the file does not exist
1423
1559
        """
1424
1560
        path = self._tree_id_paths.get(trans_id)
1425
1561
        if path is None:
1426
 
            raise NoSuchFile(None)
 
1562
            return None
1427
1563
        try:
1428
1564
            return file_kind(self._tree.abspath(path))
1429
 
        except OSError, e:
1430
 
            if e.errno != errno.ENOENT:
1431
 
                raise
1432
 
            else:
1433
 
                raise NoSuchFile(path)
 
1565
        except errors.NoSuchFile:
 
1566
            return None
1434
1567
 
1435
1568
    def _set_mode(self, trans_id, mode_id, typefunc):
1436
1569
        """Set the mode of new file contents.
1605
1738
                if file_id is None:
1606
1739
                    continue
1607
1740
                needs_entry = False
1608
 
                try:
1609
 
                    kind = self.final_kind(trans_id)
1610
 
                except NoSuchFile:
 
1741
                kind = self.final_kind(trans_id)
 
1742
                if kind is None:
1611
1743
                    kind = self._tree.stored_kind(file_id)
1612
1744
                parent_trans_id = self.final_parent(trans_id)
1613
1745
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1725
1857
    def tree_kind(self, trans_id):
1726
1858
        path = self._tree_id_paths.get(trans_id)
1727
1859
        if path is None:
1728
 
            raise NoSuchFile(None)
 
1860
            return None
1729
1861
        file_id = self._tree.path2id(path)
1730
 
        return self._tree.kind(file_id)
 
1862
        try:
 
1863
            return self._tree.kind(file_id)
 
1864
        except errors.NoSuchFile:
 
1865
            return None
1731
1866
 
1732
1867
    def _set_mode(self, trans_id, mode_id, typefunc):
1733
1868
        """Set the mode of new file contents.
1753
1888
            childpath = joinpath(path, child)
1754
1889
            yield self.trans_id_tree_path(childpath)
1755
1890
 
 
1891
    def new_orphan(self, trans_id, parent_id):
 
1892
        raise NotImplementedError(self.new_orphan)
 
1893
 
1756
1894
 
1757
1895
class _PreviewTree(tree.Tree):
1758
1896
    """Partial implementation of Tree to support show_diff_trees"""
1929
2067
            if (specific_file_ids is not None
1930
2068
                and file_id not in specific_file_ids):
1931
2069
                continue
1932
 
            try:
1933
 
                kind = self._transform.final_kind(trans_id)
1934
 
            except NoSuchFile:
 
2070
            kind = self._transform.final_kind(trans_id)
 
2071
            if kind is None:
1935
2072
                kind = self._transform._tree.stored_kind(file_id)
1936
2073
            new_entry = inventory.make_entry(
1937
2074
                kind,
2169
2306
                path_from_root = self._final_paths.get_path(child_id)
2170
2307
                basename = self._transform.final_name(child_id)
2171
2308
                file_id = self._transform.final_file_id(child_id)
2172
 
                try:
2173
 
                    kind = self._transform.final_kind(child_id)
 
2309
                kind  = self._transform.final_kind(child_id)
 
2310
                if kind is not None:
2174
2311
                    versioned_kind = kind
2175
 
                except NoSuchFile:
 
2312
                else:
2176
2313
                    kind = 'unknown'
2177
2314
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2178
2315
                if versioned_kind == 'directory':
2454
2591
    for child in tt.iter_tree_children(old_parent):
2455
2592
        tt.adjust_path(tt.final_name(child), new_parent, child)
2456
2593
 
 
2594
 
2457
2595
def _reparent_transform_children(tt, old_parent, new_parent):
2458
2596
    by_parent = tt.by_parent()
2459
2597
    for child in by_parent[old_parent]:
2460
2598
        tt.adjust_path(tt.final_name(child), new_parent, child)
2461
2599
    return by_parent[old_parent]
2462
2600
 
 
2601
 
2463
2602
def _content_match(tree, entry, file_id, kind, target_path):
2464
2603
    if entry.kind != kind:
2465
2604
        return False
2565
2704
        tt.set_executability(entry.executable, trans_id)
2566
2705
 
2567
2706
 
 
2707
@deprecated_function(deprecated_in((2, 3, 0)))
2568
2708
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2569
2709
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2570
2710
 
2571
2711
 
 
2712
@deprecated_function(deprecated_in((2, 3, 0)))
2572
2713
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2573
2714
    """Produce a backup-style name that appears to be available"""
2574
2715
    def name_gen():
2695
2836
                        tt.delete_contents(trans_id)
2696
2837
                    elif kind[1] is not None:
2697
2838
                        parent_trans_id = tt.trans_id_file_id(parent[0])
2698
 
                        by_parent = tt.by_parent()
2699
 
                        backup_name = _get_backup_name(name[0], by_parent,
2700
 
                                                       parent_trans_id, tt)
 
2839
                        backup_name = tt._available_backup_name(
 
2840
                            name[0], parent_trans_id)
2701
2841
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2702
2842
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2703
2843
                        if versioned == (True, True):
2826
2966
 
2827
2967
        elif c_type == 'missing parent':
2828
2968
            trans_id = conflict[1]
2829
 
            try:
2830
 
                tt.cancel_deletion(trans_id)
2831
 
                new_conflicts.add(('deleting parent', 'Not deleting',
2832
 
                                   trans_id))
2833
 
            except KeyError:
 
2969
            if trans_id in tt._removed_contents:
 
2970
                cancel_deletion = True
 
2971
                orphans = tt._get_potential_orphans(trans_id)
 
2972
                if orphans:
 
2973
                    cancel_deletion = False
 
2974
                    # All children are orphans
 
2975
                    for o in orphans:
 
2976
                        try:
 
2977
                            tt.new_orphan(o, trans_id)
 
2978
                        except OrphaningError:
 
2979
                            # Something bad happened so we cancel the directory
 
2980
                            # deletion which will leave it in place with a
 
2981
                            # conflict. The user can deal with it from there.
 
2982
                            # Note that this also catch the case where we don't
 
2983
                            # want to create orphans and leave the directory in
 
2984
                            # place.
 
2985
                            cancel_deletion = True
 
2986
                            break
 
2987
                if cancel_deletion:
 
2988
                    # Cancel the directory deletion
 
2989
                    tt.cancel_deletion(trans_id)
 
2990
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
2991
                                       trans_id))
 
2992
            else:
2834
2993
                create = True
2835
2994
                try:
2836
2995
                    tt.final_name(trans_id)
2944
3103
            try:
2945
3104
                os.rename(to, from_)
2946
3105
            except OSError, e:
2947
 
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)                
 
3106
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2948
3107
        # after rollback, don't reuse _FileMover
2949
3108
        past_renames = None
2950
3109
        pending_deletions = None