/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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 import (
23
 
    errors,
24
 
    lazy_import,
25
 
    registry,
26
 
    )
27
 
lazy_import.lazy_import(globals(), """
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
28
24
from bzrlib import (
29
25
    annotate,
30
26
    bencode,
31
27
    bzrdir,
32
 
    commit,
33
28
    delta,
34
29
    errors,
35
30
    inventory,
36
31
    multiparent,
37
32
    osutils,
38
33
    revision as _mod_revision,
39
 
    trace,
40
34
    ui,
41
35
    )
42
36
""")
60
54
from bzrlib.symbol_versioning import (
61
55
        deprecated_function,
62
56
        deprecated_in,
63
 
        deprecated_method,
64
57
        )
65
58
from bzrlib.trace import mutter, warning
66
59
from bzrlib import tree
70
63
 
71
64
ROOT_PARENT = "root-parent"
72
65
 
 
66
 
73
67
def unique_add(map, key, value):
74
68
    if key in map:
75
69
        raise DuplicateKey(key=key)
76
70
    map[key] = value
77
71
 
78
72
 
79
 
 
80
73
class _TransformResults(object):
81
74
    def __init__(self, modified_paths, rename_count):
82
75
        object.__init__(self)
321
314
 
322
315
    def delete_contents(self, trans_id):
323
316
        """Schedule the contents of a path entry for deletion"""
324
 
        kind = self.tree_kind(trans_id)
325
 
        if kind is not None:
326
 
            self._removed_contents.add(trans_id)
 
317
        # Ensure that the object exists in the WorkingTree, this will raise an
 
318
        # exception if there is a problem
 
319
        self.tree_kind(trans_id)
 
320
        self._removed_contents.add(trans_id)
327
321
 
328
322
    def cancel_deletion(self, trans_id):
329
323
        """Cancel a scheduled deletion"""
394
388
        changed_kind = set(self._removed_contents)
395
389
        changed_kind.intersection_update(self._new_contents)
396
390
        changed_kind.difference_update(new_ids)
397
 
        changed_kind = (t for t in changed_kind
398
 
                        if self.tree_kind(t) != self.final_kind(t))
 
391
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
 
392
                        self.final_kind(t))
399
393
        new_ids.update(changed_kind)
400
394
        return sorted(FinalPaths(self).get_paths(new_ids))
401
395
 
402
396
    def final_kind(self, trans_id):
403
397
        """Determine the final file kind, after any changes applied.
404
398
 
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)
 
399
        Raises NoSuchFile if the file does not exist/has no contents.
 
400
        (It is conceivable that a path would be created without the
 
401
        corresponding contents insertion command)
408
402
        """
409
403
        if trans_id in self._new_contents:
410
404
            return self._new_contents[trans_id]
411
405
        elif trans_id in self._removed_contents:
412
 
            return None
 
406
            raise NoSuchFile(None)
413
407
        else:
414
408
            return self.tree_kind(trans_id)
415
409
 
537
531
            # ensure that all children are registered with the transaction
538
532
            list(self.iter_tree_children(parent_id))
539
533
 
540
 
    @deprecated_method(deprecated_in((2, 3, 0)))
541
534
    def has_named_child(self, by_parent, parent_id, name):
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:
 
535
        try:
 
536
            children = by_parent[parent_id]
 
537
        except KeyError:
 
538
            children = []
 
539
        for child in children:
559
540
            if self.final_name(child) == name:
560
541
                return True
561
 
        parent_path = self._tree_id_paths.get(parent_id, None)
562
 
        if parent_path is None:
563
 
            # No parent... no children
 
542
        try:
 
543
            path = self._tree_id_paths[parent_id]
 
544
        except KeyError:
564
545
            return False
565
 
        child_path = joinpath(parent_path, name)
566
 
        child_id = self._tree_path_ids.get(child_path, None)
 
546
        childpath = joinpath(path, name)
 
547
        child_id = self._tree_path_ids.get(childpath)
567
548
        if child_id is None:
568
 
            # Not known by the tree transform yet, check the filesystem
569
 
            return osutils.lexists(self._tree.abspath(child_path))
 
549
            return lexists(self._tree.abspath(childpath))
570
550
        else:
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))
 
551
            if self.final_parent(child_id) != parent_id:
 
552
                return False
 
553
            if child_id in self._removed_contents:
 
554
                # XXX What about dangling file-ids?
 
555
                return False
 
556
            else:
 
557
                return True
587
558
 
588
559
    def _parent_loops(self):
589
560
        """No entry should be its own ancestor"""
624
595
        """
625
596
        conflicts = []
626
597
        for trans_id in self._new_id.iterkeys():
627
 
            kind = self.final_kind(trans_id)
628
 
            if kind is None:
 
598
            try:
 
599
                kind = self.final_kind(trans_id)
 
600
            except NoSuchFile:
629
601
                conflicts.append(('versioning no contents', trans_id))
630
602
                continue
631
603
            if not InventoryEntry.versionable_kind(kind):
645
617
            if self.final_file_id(trans_id) is None:
646
618
                conflicts.append(('unversioned executability', trans_id))
647
619
            else:
648
 
                if self.final_kind(trans_id) != "file":
 
620
                try:
 
621
                    non_file = self.final_kind(trans_id) != "file"
 
622
                except NoSuchFile:
 
623
                    non_file = True
 
624
                if non_file is True:
649
625
                    conflicts.append(('non-file executability', trans_id))
650
626
        return conflicts
651
627
 
653
629
        """Check for overwrites (not permitted on Win32)"""
654
630
        conflicts = []
655
631
        for trans_id in self._new_contents:
656
 
            if self.tree_kind(trans_id) is None:
 
632
            try:
 
633
                self.tree_kind(trans_id)
 
634
            except NoSuchFile:
657
635
                continue
658
636
            if trans_id not in self._removed_contents:
659
637
                conflicts.append(('overwrite', trans_id,
666
644
        if (self._new_name, self._new_parent) == ({}, {}):
667
645
            return conflicts
668
646
        for children in by_parent.itervalues():
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))
 
647
            name_ids = [(self.final_name(t), t) for t in children]
 
648
            if not self._case_sensitive_target:
 
649
                name_ids = [(n.lower(), t) for n, t in name_ids]
677
650
            name_ids.sort()
678
651
            last_name = None
679
652
            last_trans_id = None
680
653
            for name, trans_id in name_ids:
681
 
                kind = self.final_kind(trans_id)
 
654
                try:
 
655
                    kind = self.final_kind(trans_id)
 
656
                except NoSuchFile:
 
657
                    kind = None
682
658
                file_id = self.final_file_id(trans_id)
683
659
                if kind is None and file_id is None:
684
660
                    continue
703
679
        return conflicts
704
680
 
705
681
    def _parent_type_conflicts(self, by_parent):
706
 
        """Children must have a directory parent"""
 
682
        """parents must have directory 'contents'."""
707
683
        conflicts = []
708
684
        for parent_id, children in by_parent.iteritems():
709
685
            if parent_id is ROOT_PARENT:
710
686
                continue
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:
 
687
            if not self._any_contents(children):
717
688
                continue
718
 
            # There is at least a child, so we need an existing directory to
719
 
            # contain it.
720
 
            kind = self.final_kind(parent_id)
 
689
            for child in children:
 
690
                try:
 
691
                    self.final_kind(child)
 
692
                except NoSuchFile:
 
693
                    continue
 
694
            try:
 
695
                kind = self.final_kind(parent_id)
 
696
            except NoSuchFile:
 
697
                kind = None
721
698
            if kind is None:
722
 
                # The directory will be deleted
723
699
                conflicts.append(('missing parent', parent_id))
724
700
            elif kind != "directory":
725
 
                # Meh, we need a *directory* to put something in it
726
701
                conflicts.append(('non-directory parent', parent_id))
727
702
        return conflicts
728
703
 
 
704
    def _any_contents(self, trans_ids):
 
705
        """Return true if any of the trans_ids, will have contents."""
 
706
        for trans_id in trans_ids:
 
707
            try:
 
708
                kind = self.final_kind(trans_id)
 
709
            except NoSuchFile:
 
710
                continue
 
711
            return True
 
712
        return False
 
713
 
729
714
    def _set_executability(self, path, trans_id):
730
715
        """Set the executability of versioned files """
731
716
        if supports_executable():
795
780
        self.create_symlink(target, trans_id)
796
781
        return trans_id
797
782
 
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
 
 
840
783
    def _affected_ids(self):
841
784
        """Return the set of transform ids affected by the transform"""
842
785
        trans_ids = set(self._removed_id)
901
844
        Return a (name, parent, kind, executable) tuple
902
845
        """
903
846
        to_name = self.final_name(to_trans_id)
904
 
        to_kind = self.final_kind(to_trans_id)
 
847
        try:
 
848
            to_kind = self.final_kind(to_trans_id)
 
849
        except NoSuchFile:
 
850
            to_kind = None
905
851
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
906
852
        if to_trans_id in self._new_executability:
907
853
            to_executable = self._new_executability[to_trans_id]
981
927
        """
982
928
        return _PreviewTree(self)
983
929
 
984
 
    def commit(self, branch, message, merge_parents=None, strict=False,
985
 
               timestamp=None, timezone=None, committer=None, authors=None,
986
 
               revprops=None, revision_id=None):
 
930
    def commit(self, branch, message, merge_parents=None, strict=False):
987
931
        """Commit the result of this TreeTransform to a branch.
988
932
 
989
933
        :param branch: The branch to commit to.
990
934
        :param message: The message to attach to the commit.
991
 
        :param merge_parents: Additional parent revision-ids specified by
992
 
            pending merges.
993
 
        :param strict: If True, abort the commit if there are unversioned
994
 
            files.
995
 
        :param timestamp: if not None, seconds-since-epoch for the time and
996
 
            date.  (May be a float.)
997
 
        :param timezone: Optional timezone for timestamp, as an offset in
998
 
            seconds.
999
 
        :param committer: Optional committer in email-id format.
1000
 
            (e.g. "J Random Hacker <jrandom@example.com>")
1001
 
        :param authors: Optional list of authors in email-id format.
1002
 
        :param revprops: Optional dictionary of revision properties.
1003
 
        :param revision_id: Optional revision id.  (Specifying a revision-id
1004
 
            may reduce performance for some non-native formats.)
 
935
        :param merge_parents: Additional parents specified by pending merges.
1005
936
        :return: The revision_id of the revision committed.
1006
937
        """
1007
938
        self._check_malformed()
1024
955
        if self._tree.get_revision_id() != last_rev_id:
1025
956
            raise ValueError('TreeTransform not based on branch basis: %s' %
1026
957
                             self._tree.get_revision_id())
1027
 
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
1028
 
        builder = branch.get_commit_builder(parent_ids,
1029
 
                                            timestamp=timestamp,
1030
 
                                            timezone=timezone,
1031
 
                                            committer=committer,
1032
 
                                            revprops=revprops,
1033
 
                                            revision_id=revision_id)
 
958
        builder = branch.get_commit_builder(parent_ids)
1034
959
        preview = self.get_preview_tree()
1035
960
        list(builder.record_iter_changes(preview, last_rev_id,
1036
961
                                         self.iter_changes()))
1235
1160
            if trans_id not in self._new_contents:
1236
1161
                continue
1237
1162
            new_path = self._limbo_name(trans_id)
1238
 
            os.rename(old_path, new_path)
 
1163
            osutils.rename(old_path, new_path)
1239
1164
            for descendant in self._limbo_descendants(trans_id):
1240
1165
                desc_path = self._limbo_files[descendant]
1241
1166
                desc_path = new_path + desc_path[len(old_path):]
1349
1274
            del self._limbo_children_names[trans_id]
1350
1275
        delete_any(self._limbo_name(trans_id))
1351
1276
 
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
 
 
1435
1277
 
1436
1278
class TreeTransform(DiskTreeTransform):
1437
1279
    """Represent a tree transformation.
1555
1397
    def tree_kind(self, trans_id):
1556
1398
        """Determine the file kind in the working tree.
1557
1399
 
1558
 
        :returns: The file kind or None if the file does not exist
 
1400
        Raises NoSuchFile if the file does not exist
1559
1401
        """
1560
1402
        path = self._tree_id_paths.get(trans_id)
1561
1403
        if path is None:
1562
 
            return None
 
1404
            raise NoSuchFile(None)
1563
1405
        try:
1564
1406
            return file_kind(self._tree.abspath(path))
1565
 
        except errors.NoSuchFile:
1566
 
            return None
 
1407
        except OSError, e:
 
1408
            if e.errno != errno.ENOENT:
 
1409
                raise
 
1410
            else:
 
1411
                raise NoSuchFile(path)
1567
1412
 
1568
1413
    def _set_mode(self, trans_id, mode_id, typefunc):
1569
1414
        """Set the mode of new file contents.
1738
1583
                if file_id is None:
1739
1584
                    continue
1740
1585
                needs_entry = False
1741
 
                kind = self.final_kind(trans_id)
1742
 
                if kind is None:
 
1586
                try:
 
1587
                    kind = self.final_kind(trans_id)
 
1588
                except NoSuchFile:
1743
1589
                    kind = self._tree.stored_kind(file_id)
1744
1590
                parent_trans_id = self.final_parent(trans_id)
1745
1591
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1789
1635
                      or trans_id in self._new_parent):
1790
1636
                    try:
1791
1637
                        mover.rename(full_path, self._limbo_name(trans_id))
1792
 
                    except errors.TransformRenameFailed, e:
 
1638
                    except OSError, e:
1793
1639
                        if e.errno != errno.ENOENT:
1794
1640
                            raise
1795
1641
                    else:
1820
1666
                if trans_id in self._needs_rename:
1821
1667
                    try:
1822
1668
                        mover.rename(self._limbo_name(trans_id), full_path)
1823
 
                    except errors.TransformRenameFailed, e:
 
1669
                    except OSError, e:
1824
1670
                        # We may be renaming a dangling inventory id
1825
1671
                        if e.errno != errno.ENOENT:
1826
1672
                            raise
1857
1703
    def tree_kind(self, trans_id):
1858
1704
        path = self._tree_id_paths.get(trans_id)
1859
1705
        if path is None:
1860
 
            return None
 
1706
            raise NoSuchFile(None)
1861
1707
        file_id = self._tree.path2id(path)
1862
 
        try:
1863
 
            return self._tree.kind(file_id)
1864
 
        except errors.NoSuchFile:
1865
 
            return None
 
1708
        return self._tree.kind(file_id)
1866
1709
 
1867
1710
    def _set_mode(self, trans_id, mode_id, typefunc):
1868
1711
        """Set the mode of new file contents.
1888
1731
            childpath = joinpath(path, child)
1889
1732
            yield self.trans_id_tree_path(childpath)
1890
1733
 
1891
 
    def new_orphan(self, trans_id, parent_id):
1892
 
        raise NotImplementedError(self.new_orphan)
1893
 
 
1894
1734
 
1895
1735
class _PreviewTree(tree.Tree):
1896
1736
    """Partial implementation of Tree to support show_diff_trees"""
1930
1770
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1931
1771
                       self._iter_parent_trees()]
1932
1772
        vf.add_lines((file_id, tree_revision), parent_keys,
1933
 
                     self.get_file_lines(file_id))
 
1773
                     self.get_file(file_id).readlines())
1934
1774
        repo = self._get_repository()
1935
1775
        base_vf = repo.texts
1936
1776
        if base_vf not in vf.fallback_versionedfiles:
1958
1798
            executable = self.is_executable(file_id, path)
1959
1799
        return kind, executable, None
1960
1800
 
1961
 
    def is_locked(self):
1962
 
        return False
1963
 
 
1964
1801
    def lock_read(self):
1965
1802
        # Perhaps in theory, this should lock the TreeTransform?
1966
 
        return self
 
1803
        pass
1967
1804
 
1968
1805
    def unlock(self):
1969
1806
        pass
2067
1904
            if (specific_file_ids is not None
2068
1905
                and file_id not in specific_file_ids):
2069
1906
                continue
2070
 
            kind = self._transform.final_kind(trans_id)
2071
 
            if kind is None:
 
1907
            try:
 
1908
                kind = self._transform.final_kind(trans_id)
 
1909
            except NoSuchFile:
2072
1910
                kind = self._transform._tree.stored_kind(file_id)
2073
1911
            new_entry = inventory.make_entry(
2074
1912
                kind,
2306
2144
                path_from_root = self._final_paths.get_path(child_id)
2307
2145
                basename = self._transform.final_name(child_id)
2308
2146
                file_id = self._transform.final_file_id(child_id)
2309
 
                kind  = self._transform.final_kind(child_id)
2310
 
                if kind is not None:
 
2147
                try:
 
2148
                    kind = self._transform.final_kind(child_id)
2311
2149
                    versioned_kind = kind
2312
 
                else:
 
2150
                except NoSuchFile:
2313
2151
                    kind = 'unknown'
2314
2152
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2315
2153
                if versioned_kind == 'directory':
2428
2266
    for num, _unused in enumerate(wt.all_file_ids()):
2429
2267
        if num > 0:  # more than just a root
2430
2268
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
2269
    existing_files = set()
 
2270
    for dir, files in wt.walkdirs():
 
2271
        existing_files.update(f[0] for f in files)
2431
2272
    file_trans_id = {}
2432
2273
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2433
2274
    pp = ProgressPhase("Build phase", 2, top_pb)
2457
2298
                precomputed_delta = []
2458
2299
            else:
2459
2300
                precomputed_delta = None
2460
 
            # Check if tree inventory has content. If so, we populate
2461
 
            # existing_files with the directory content. If there are no
2462
 
            # entries we skip populating existing_files as its not used.
2463
 
            # This improves performance and unncessary work on large
2464
 
            # directory trees. (#501307)
2465
 
            if total > 0:
2466
 
                existing_files = set()
2467
 
                for dir, files in wt.walkdirs():
2468
 
                    existing_files.update(f[0] for f in files)
2469
2301
            for num, (tree_path, entry) in \
2470
2302
                enumerate(tree.inventory.iter_entries_by_dir()):
2471
2303
                pb.update("Building tree", num - len(deferred_contents), total)
2591
2423
    for child in tt.iter_tree_children(old_parent):
2592
2424
        tt.adjust_path(tt.final_name(child), new_parent, child)
2593
2425
 
2594
 
 
2595
2426
def _reparent_transform_children(tt, old_parent, new_parent):
2596
2427
    by_parent = tt.by_parent()
2597
2428
    for child in by_parent[old_parent]:
2598
2429
        tt.adjust_path(tt.final_name(child), new_parent, child)
2599
2430
    return by_parent[old_parent]
2600
2431
 
2601
 
 
2602
2432
def _content_match(tree, entry, file_id, kind, target_path):
2603
2433
    if entry.kind != kind:
2604
2434
        return False
2605
2435
    if entry.kind == "directory":
2606
2436
        return True
2607
2437
    if entry.kind == "file":
2608
 
        f = file(target_path, 'rb')
2609
 
        try:
2610
 
            if tree.get_file_text(file_id) == f.read():
2611
 
                return True
2612
 
        finally:
2613
 
            f.close()
 
2438
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
 
2439
            return True
2614
2440
    elif entry.kind == "symlink":
2615
2441
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2616
2442
            return True
2668
2494
        raise errors.BadFileKindError(name, kind)
2669
2495
 
2670
2496
 
 
2497
@deprecated_function(deprecated_in((1, 9, 0)))
 
2498
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
 
2499
    """Create new file contents according to an inventory entry.
 
2500
 
 
2501
    DEPRECATED.  Use create_from_tree instead.
 
2502
    """
 
2503
    if entry.kind == "file":
 
2504
        if lines is None:
 
2505
            lines = tree.get_file(entry.file_id).readlines()
 
2506
        tt.create_file(lines, trans_id, mode_id=mode_id)
 
2507
    elif entry.kind == "symlink":
 
2508
        tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
 
2509
    elif entry.kind == "directory":
 
2510
        tt.create_directory(trans_id)
 
2511
 
 
2512
 
2671
2513
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2672
2514
    filter_tree_path=None):
2673
2515
    """Create new file contents according to tree contents.
2704
2546
        tt.set_executability(entry.executable, trans_id)
2705
2547
 
2706
2548
 
2707
 
@deprecated_function(deprecated_in((2, 3, 0)))
2708
2549
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2709
2550
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2710
2551
 
2711
2552
 
2712
 
@deprecated_function(deprecated_in((2, 3, 0)))
2713
2553
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2714
2554
    """Produce a backup-style name that appears to be available"""
2715
2555
    def name_gen():
2836
2676
                        tt.delete_contents(trans_id)
2837
2677
                    elif kind[1] is not None:
2838
2678
                        parent_trans_id = tt.trans_id_file_id(parent[0])
2839
 
                        backup_name = tt._available_backup_name(
2840
 
                            name[0], parent_trans_id)
 
2679
                        by_parent = tt.by_parent()
 
2680
                        backup_name = _get_backup_name(name[0], by_parent,
 
2681
                                                       parent_trans_id, tt)
2841
2682
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2842
2683
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2843
2684
                        if versioned == (True, True):
2966
2807
 
2967
2808
        elif c_type == 'missing parent':
2968
2809
            trans_id = conflict[1]
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:
 
2810
            try:
 
2811
                tt.cancel_deletion(trans_id)
 
2812
                new_conflicts.add(('deleting parent', 'Not deleting',
 
2813
                                   trans_id))
 
2814
            except KeyError:
2993
2815
                create = True
2994
2816
                try:
2995
2817
                    tt.final_name(trans_id)
3078
2900
    def rename(self, from_, to):
3079
2901
        """Rename a file from one path to another."""
3080
2902
        try:
3081
 
            os.rename(from_, to)
 
2903
            osutils.rename(from_, to)
3082
2904
        except OSError, e:
3083
2905
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
3084
2906
                raise errors.FileExists(to, str(e))
3085
 
            # normal OSError doesn't include filenames so it's hard to see where
3086
 
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
3087
 
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
 
2907
            raise
3088
2908
        self.past_renames.append((from_, to))
3089
2909
 
3090
2910
    def pre_delete(self, from_, to):
3100
2920
    def rollback(self):
3101
2921
        """Reverse all renames that have been performed"""
3102
2922
        for from_, to in reversed(self.past_renames):
3103
 
            try:
3104
 
                os.rename(to, from_)
3105
 
            except OSError, e:
3106
 
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
 
2923
            osutils.rename(to, from_)
3107
2924
        # after rollback, don't reuse _FileMover
3108
2925
        past_renames = None
3109
2926
        pending_deletions = None