/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
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
19
19
from stat import S_ISREG, S_IEXEC
20
20
import time
21
21
 
22
 
import bzrlib
23
 
from bzrlib import (
24
 
    errors,
25
 
    lazy_import,
26
 
    registry,
27
 
    tree,
28
 
    )
29
 
lazy_import.lazy_import(globals(), """
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
30
24
from bzrlib import (
31
25
    annotate,
32
26
    bencode,
33
27
    bzrdir,
34
 
    commit,
35
28
    delta,
36
29
    errors,
37
30
    inventory,
38
31
    multiparent,
39
32
    osutils,
40
33
    revision as _mod_revision,
41
 
    trace,
42
34
    ui,
43
 
    urlutils,
44
35
    )
45
36
""")
46
37
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
53
44
    delete_any,
54
45
    file_kind,
55
46
    has_symlinks,
 
47
    lexists,
56
48
    pathjoin,
57
49
    sha_file,
58
50
    splitpath,
59
51
    supports_executable,
60
 
    )
 
52
)
61
53
from bzrlib.progress import ProgressPhase
62
54
from bzrlib.symbol_versioning import (
63
 
    deprecated_function,
64
 
    deprecated_in,
65
 
    deprecated_method,
66
 
    )
67
 
from bzrlib.trace import warning
 
55
        deprecated_function,
 
56
        deprecated_in,
 
57
        )
 
58
from bzrlib.trace import mutter, warning
 
59
from bzrlib import tree
 
60
import bzrlib.ui
 
61
import bzrlib.urlutils as urlutils
68
62
 
69
63
 
70
64
ROOT_PARENT = "root-parent"
71
65
 
 
66
 
72
67
def unique_add(map, key, value):
73
68
    if key in map:
74
69
        raise DuplicateKey(key=key)
75
70
    map[key] = value
76
71
 
77
72
 
78
 
 
79
73
class _TransformResults(object):
80
74
    def __init__(self, modified_paths, rename_count):
81
75
        object.__init__(self)
129
123
            self._new_root = self.trans_id_tree_file_id(root_id)
130
124
        else:
131
125
            self._new_root = None
132
 
        # Indicator of whether the transform has been applied
 
126
        # Indictor of whether the transform has been applied
133
127
        self._done = False
134
128
        # A progress bar
135
129
        self._pb = pb
320
314
 
321
315
    def delete_contents(self, trans_id):
322
316
        """Schedule the contents of a path entry for deletion"""
323
 
        kind = self.tree_kind(trans_id)
324
 
        if kind is not None:
325
 
            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)
326
321
 
327
322
    def cancel_deletion(self, trans_id):
328
323
        """Cancel a scheduled deletion"""
393
388
        changed_kind = set(self._removed_contents)
394
389
        changed_kind.intersection_update(self._new_contents)
395
390
        changed_kind.difference_update(new_ids)
396
 
        changed_kind = (t for t in changed_kind
397
 
                        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))
398
393
        new_ids.update(changed_kind)
399
394
        return sorted(FinalPaths(self).get_paths(new_ids))
400
395
 
401
396
    def final_kind(self, trans_id):
402
397
        """Determine the final file kind, after any changes applied.
403
398
 
404
 
        :return: None if the file does not exist/has no contents.  (It is
405
 
            conceivable that a path would be created without the corresponding
406
 
            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)
407
402
        """
408
403
        if trans_id in self._new_contents:
409
404
            return self._new_contents[trans_id]
410
405
        elif trans_id in self._removed_contents:
411
 
            return None
 
406
            raise NoSuchFile(None)
412
407
        else:
413
408
            return self.tree_kind(trans_id)
414
409
 
527
522
        for trans_id in self._removed_id:
528
523
            file_id = self.tree_file_id(trans_id)
529
524
            if file_id is not None:
530
 
                # XXX: This seems like something that should go via a different
531
 
                #      indirection.
532
525
                if self._tree.inventory[file_id].kind == 'directory':
533
526
                    parents.append(trans_id)
534
527
            elif self.tree_kind(trans_id) == 'directory':
538
531
            # ensure that all children are registered with the transaction
539
532
            list(self.iter_tree_children(parent_id))
540
533
 
541
 
    @deprecated_method(deprecated_in((2, 3, 0)))
542
534
    def has_named_child(self, by_parent, parent_id, name):
543
 
        return self._has_named_child(
544
 
            name, parent_id, known_children=by_parent.get(parent_id, []))
545
 
 
546
 
    def _has_named_child(self, name, parent_id, known_children):
547
 
        """Does a parent already have a name child.
548
 
 
549
 
        :param name: The searched for name.
550
 
 
551
 
        :param parent_id: The parent for which the check is made.
552
 
 
553
 
        :param known_children: The already known children. This should have
554
 
            been recently obtained from `self.by_parent.get(parent_id)`
555
 
            (or will be if None is passed).
556
 
        """
557
 
        if known_children is None:
558
 
            known_children = self.by_parent().get(parent_id, [])
559
 
        for child in known_children:
 
535
        try:
 
536
            children = by_parent[parent_id]
 
537
        except KeyError:
 
538
            children = []
 
539
        for child in children:
560
540
            if self.final_name(child) == name:
561
541
                return True
562
 
        parent_path = self._tree_id_paths.get(parent_id, None)
563
 
        if parent_path is None:
564
 
            # No parent... no children
 
542
        try:
 
543
            path = self._tree_id_paths[parent_id]
 
544
        except KeyError:
565
545
            return False
566
 
        child_path = joinpath(parent_path, name)
567
 
        child_id = self._tree_path_ids.get(child_path, None)
 
546
        childpath = joinpath(path, name)
 
547
        child_id = self._tree_path_ids.get(childpath)
568
548
        if child_id is None:
569
 
            # Not known by the tree transform yet, check the filesystem
570
 
            return osutils.lexists(self._tree.abspath(child_path))
 
549
            return lexists(self._tree.abspath(childpath))
571
550
        else:
572
 
            raise AssertionError('child_id is missing: %s, %s, %s'
573
 
                                 % (name, parent_id, child_id))
574
 
 
575
 
    def _available_backup_name(self, name, target_id):
576
 
        """Find an available backup name.
577
 
 
578
 
        :param name: The basename of the file.
579
 
 
580
 
        :param target_id: The directory trans_id where the backup should 
581
 
            be placed.
582
 
        """
583
 
        known_children = self.by_parent().get(target_id, [])
584
 
        return osutils.available_backup_name(
585
 
            name,
586
 
            lambda base: self._has_named_child(
587
 
                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
588
558
 
589
559
    def _parent_loops(self):
590
560
        """No entry should be its own ancestor"""
625
595
        """
626
596
        conflicts = []
627
597
        for trans_id in self._new_id.iterkeys():
628
 
            kind = self.final_kind(trans_id)
629
 
            if kind is None:
 
598
            try:
 
599
                kind = self.final_kind(trans_id)
 
600
            except NoSuchFile:
630
601
                conflicts.append(('versioning no contents', trans_id))
631
602
                continue
632
603
            if not InventoryEntry.versionable_kind(kind):
646
617
            if self.final_file_id(trans_id) is None:
647
618
                conflicts.append(('unversioned executability', trans_id))
648
619
            else:
649
 
                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:
650
625
                    conflicts.append(('non-file executability', trans_id))
651
626
        return conflicts
652
627
 
654
629
        """Check for overwrites (not permitted on Win32)"""
655
630
        conflicts = []
656
631
        for trans_id in self._new_contents:
657
 
            if self.tree_kind(trans_id) is None:
 
632
            try:
 
633
                self.tree_kind(trans_id)
 
634
            except NoSuchFile:
658
635
                continue
659
636
            if trans_id not in self._removed_contents:
660
637
                conflicts.append(('overwrite', trans_id,
667
644
        if (self._new_name, self._new_parent) == ({}, {}):
668
645
            return conflicts
669
646
        for children in by_parent.itervalues():
670
 
            name_ids = []
671
 
            for child_tid in children:
672
 
                name = self.final_name(child_tid)
673
 
                if name is not None:
674
 
                    # Keep children only if they still exist in the end
675
 
                    if not self._case_sensitive_target:
676
 
                        name = name.lower()
677
 
                    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]
678
650
            name_ids.sort()
679
651
            last_name = None
680
652
            last_trans_id = None
681
653
            for name, trans_id in name_ids:
682
 
                kind = self.final_kind(trans_id)
 
654
                try:
 
655
                    kind = self.final_kind(trans_id)
 
656
                except NoSuchFile:
 
657
                    kind = None
683
658
                file_id = self.final_file_id(trans_id)
684
659
                if kind is None and file_id is None:
685
660
                    continue
704
679
        return conflicts
705
680
 
706
681
    def _parent_type_conflicts(self, by_parent):
707
 
        """Children must have a directory parent"""
 
682
        """parents must have directory 'contents'."""
708
683
        conflicts = []
709
684
        for parent_id, children in by_parent.iteritems():
710
685
            if parent_id is ROOT_PARENT:
711
686
                continue
712
 
            no_children = True
713
 
            for child_id in children:
714
 
                if self.final_kind(child_id) is not None:
715
 
                    no_children = False
716
 
                    break
717
 
            if no_children:
 
687
            if not self._any_contents(children):
718
688
                continue
719
 
            # There is at least a child, so we need an existing directory to
720
 
            # contain it.
721
 
            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
722
698
            if kind is None:
723
 
                # The directory will be deleted
724
699
                conflicts.append(('missing parent', parent_id))
725
700
            elif kind != "directory":
726
 
                # Meh, we need a *directory* to put something in it
727
701
                conflicts.append(('non-directory parent', parent_id))
728
702
        return conflicts
729
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
 
730
714
    def _set_executability(self, path, trans_id):
731
715
        """Set the executability of versioned files """
732
716
        if supports_executable():
796
780
        self.create_symlink(target, trans_id)
797
781
        return trans_id
798
782
 
799
 
    def new_orphan(self, trans_id, parent_id):
800
 
        """Schedule an item to be orphaned.
801
 
 
802
 
        When a directory is about to be removed, its children, if they are not
803
 
        versioned are moved out of the way: they don't have a parent anymore.
804
 
 
805
 
        :param trans_id: The trans_id of the existing item.
806
 
        :param parent_id: The parent trans_id of the item.
807
 
        """
808
 
        raise NotImplementedError(self.new_orphan)
809
 
 
810
 
    def _get_potential_orphans(self, dir_id):
811
 
        """Find the potential orphans in a directory.
812
 
 
813
 
        A directory can't be safely deleted if there are versioned files in it.
814
 
        If all the contained files are unversioned then they can be orphaned.
815
 
 
816
 
        The 'None' return value means that the directory contains at least one
817
 
        versioned file and should not be deleted.
818
 
 
819
 
        :param dir_id: The directory trans id.
820
 
 
821
 
        :return: A list of the orphan trans ids or None if at least one
822
 
             versioned file is present.
823
 
        """
824
 
        orphans = []
825
 
        # Find the potential orphans, stop if one item should be kept
826
 
        for child_tid in self.by_parent()[dir_id]:
827
 
            if child_tid in self._removed_contents:
828
 
                # The child is removed as part of the transform. Since it was
829
 
                # versioned before, it's not an orphan
830
 
                continue
831
 
            elif self.final_file_id(child_tid) is None:
832
 
                # The child is not versioned
833
 
                orphans.append(child_tid)
834
 
            else:
835
 
                # We have a versioned file here, searching for orphans is
836
 
                # meaningless.
837
 
                orphans = None
838
 
                break
839
 
        return orphans
840
 
 
841
783
    def _affected_ids(self):
842
784
        """Return the set of transform ids affected by the transform"""
843
785
        trans_ids = set(self._removed_id)
902
844
        Return a (name, parent, kind, executable) tuple
903
845
        """
904
846
        to_name = self.final_name(to_trans_id)
905
 
        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
906
851
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
907
852
        if to_trans_id in self._new_executability:
908
853
            to_executable = self._new_executability[to_trans_id]
982
927
        """
983
928
        return _PreviewTree(self)
984
929
 
985
 
    def commit(self, branch, message, merge_parents=None, strict=False,
986
 
               timestamp=None, timezone=None, committer=None, authors=None,
987
 
               revprops=None, revision_id=None):
 
930
    def commit(self, branch, message, merge_parents=None, strict=False):
988
931
        """Commit the result of this TreeTransform to a branch.
989
932
 
990
933
        :param branch: The branch to commit to.
991
934
        :param message: The message to attach to the commit.
992
 
        :param merge_parents: Additional parent revision-ids specified by
993
 
            pending merges.
994
 
        :param strict: If True, abort the commit if there are unversioned
995
 
            files.
996
 
        :param timestamp: if not None, seconds-since-epoch for the time and
997
 
            date.  (May be a float.)
998
 
        :param timezone: Optional timezone for timestamp, as an offset in
999
 
            seconds.
1000
 
        :param committer: Optional committer in email-id format.
1001
 
            (e.g. "J Random Hacker <jrandom@example.com>")
1002
 
        :param authors: Optional list of authors in email-id format.
1003
 
        :param revprops: Optional dictionary of revision properties.
1004
 
        :param revision_id: Optional revision id.  (Specifying a revision-id
1005
 
            may reduce performance for some non-native formats.)
 
935
        :param merge_parents: Additional parents specified by pending merges.
1006
936
        :return: The revision_id of the revision committed.
1007
937
        """
1008
938
        self._check_malformed()
1025
955
        if self._tree.get_revision_id() != last_rev_id:
1026
956
            raise ValueError('TreeTransform not based on branch basis: %s' %
1027
957
                             self._tree.get_revision_id())
1028
 
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
1029
 
        builder = branch.get_commit_builder(parent_ids,
1030
 
                                            timestamp=timestamp,
1031
 
                                            timezone=timezone,
1032
 
                                            committer=committer,
1033
 
                                            revprops=revprops,
1034
 
                                            revision_id=revision_id)
 
958
        builder = branch.get_commit_builder(parent_ids)
1035
959
        preview = self.get_preview_tree()
1036
960
        list(builder.record_iter_changes(preview, last_rev_id,
1037
961
                                         self.iter_changes()))
1236
1160
            if trans_id not in self._new_contents:
1237
1161
                continue
1238
1162
            new_path = self._limbo_name(trans_id)
1239
 
            os.rename(old_path, new_path)
 
1163
            osutils.rename(old_path, new_path)
1240
1164
            for descendant in self._limbo_descendants(trans_id):
1241
1165
                desc_path = self._limbo_files[descendant]
1242
1166
                desc_path = new_path + desc_path[len(old_path):]
1350
1274
            del self._limbo_children_names[trans_id]
1351
1275
        delete_any(self._limbo_name(trans_id))
1352
1276
 
1353
 
    def new_orphan(self, trans_id, parent_id):
1354
 
        # FIXME: There is no tree config, so we use the branch one (it's weird
1355
 
        # to define it this way as orphaning can only occur in a working tree,
1356
 
        # but that's all we have (for now). It will find the option in
1357
 
        # locations.conf or bazaar.conf though) -- vila 20100916
1358
 
        conf = self._tree.branch.get_config()
1359
 
        conf_var_name = 'bzr.transform.orphan_policy'
1360
 
        orphan_policy = conf.get_user_option(conf_var_name)
1361
 
        default_policy = orphaning_registry.default_key
1362
 
        if orphan_policy is None:
1363
 
            orphan_policy = default_policy
1364
 
        if orphan_policy not in orphaning_registry:
1365
 
            trace.warning('%s (from %s) is not a known policy, defaulting to %s'
1366
 
                          % (orphan_policy, conf_var_name, default_policy))
1367
 
            orphan_policy = default_policy
1368
 
        handle_orphan = orphaning_registry.get(orphan_policy)
1369
 
        handle_orphan(self, trans_id, parent_id)
1370
 
 
1371
 
 
1372
 
class OrphaningError(errors.BzrError):
1373
 
 
1374
 
    # Only bugs could lead to such exception being seen by the user
1375
 
    internal_error = True
1376
 
    _fmt = "Error while orphaning %s in %s directory"
1377
 
 
1378
 
    def __init__(self, orphan, parent):
1379
 
        errors.BzrError.__init__(self)
1380
 
        self.orphan = orphan
1381
 
        self.parent = parent
1382
 
 
1383
 
 
1384
 
class OrphaningForbidden(OrphaningError):
1385
 
 
1386
 
    _fmt = "Policy: %s doesn't allow creating orphans."
1387
 
 
1388
 
    def __init__(self, policy):
1389
 
        errors.BzrError.__init__(self)
1390
 
        self.policy = policy
1391
 
 
1392
 
 
1393
 
def move_orphan(tt, orphan_id, parent_id):
1394
 
    """See TreeTransformBase.new_orphan.
1395
 
 
1396
 
    This creates a new orphan in the `bzr-orphans` dir at the root of the
1397
 
    `TreeTransform`.
1398
 
 
1399
 
    :param tt: The TreeTransform orphaning `trans_id`.
1400
 
 
1401
 
    :param orphan_id: The trans id that should be orphaned.
1402
 
 
1403
 
    :param parent_id: The orphan parent trans id.
1404
 
    """
1405
 
    # Add the orphan dir if it doesn't exist
1406
 
    orphan_dir_basename = 'bzr-orphans'
1407
 
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
1408
 
    if tt.final_kind(od_id) is None:
1409
 
        tt.create_directory(od_id)
1410
 
    parent_path = tt._tree_id_paths[parent_id]
1411
 
    # Find a name that doesn't exist yet in the orphan dir
1412
 
    actual_name = tt.final_name(orphan_id)
1413
 
    new_name = tt._available_backup_name(actual_name, od_id)
1414
 
    tt.adjust_path(new_name, od_id, orphan_id)
1415
 
    trace.warning('%s has been orphaned in %s'
1416
 
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
1417
 
 
1418
 
 
1419
 
def refuse_orphan(tt, orphan_id, parent_id):
1420
 
    """See TreeTransformBase.new_orphan.
1421
 
 
1422
 
    This refuses to create orphan, letting the caller handle the conflict.
1423
 
    """
1424
 
    raise OrphaningForbidden('never')
1425
 
 
1426
 
 
1427
 
orphaning_registry = registry.Registry()
1428
 
orphaning_registry.register(
1429
 
    'conflict', refuse_orphan,
1430
 
    'Leave orphans in place and create a conflict on the directory.')
1431
 
orphaning_registry.register(
1432
 
    'move', move_orphan,
1433
 
    'Move orphans into the bzr-orphans directory.')
1434
 
orphaning_registry._set_default_key('conflict')
1435
 
 
1436
1277
 
1437
1278
class TreeTransform(DiskTreeTransform):
1438
1279
    """Represent a tree transformation.
1556
1397
    def tree_kind(self, trans_id):
1557
1398
        """Determine the file kind in the working tree.
1558
1399
 
1559
 
        :returns: The file kind or None if the file does not exist
 
1400
        Raises NoSuchFile if the file does not exist
1560
1401
        """
1561
1402
        path = self._tree_id_paths.get(trans_id)
1562
1403
        if path is None:
1563
 
            return None
 
1404
            raise NoSuchFile(None)
1564
1405
        try:
1565
1406
            return file_kind(self._tree.abspath(path))
1566
 
        except errors.NoSuchFile:
1567
 
            return None
 
1407
        except OSError, e:
 
1408
            if e.errno != errno.ENOENT:
 
1409
                raise
 
1410
            else:
 
1411
                raise NoSuchFile(path)
1568
1412
 
1569
1413
    def _set_mode(self, trans_id, mode_id, typefunc):
1570
1414
        """Set the mode of new file contents.
1676
1520
        """
1677
1521
        if not no_conflicts:
1678
1522
            self._check_malformed()
1679
 
        child_pb = ui.ui_factory.nested_progress_bar()
 
1523
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1680
1524
        try:
1681
1525
            if precomputed_delta is None:
1682
1526
                child_pb.update('Apply phase', 0, 2)
1709
1553
    def _generate_inventory_delta(self):
1710
1554
        """Generate an inventory delta for the current transform."""
1711
1555
        inventory_delta = []
1712
 
        child_pb = ui.ui_factory.nested_progress_bar()
 
1556
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1713
1557
        new_paths = self._inventory_altered()
1714
1558
        total_entries = len(new_paths) + len(self._removed_id)
1715
1559
        try:
1739
1583
                if file_id is None:
1740
1584
                    continue
1741
1585
                needs_entry = False
1742
 
                kind = self.final_kind(trans_id)
1743
 
                if kind is None:
 
1586
                try:
 
1587
                    kind = self.final_kind(trans_id)
 
1588
                except NoSuchFile:
1744
1589
                    kind = self._tree.stored_kind(file_id)
1745
1590
                parent_trans_id = self.final_parent(trans_id)
1746
1591
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1777
1622
        """
1778
1623
        tree_paths = list(self._tree_path_ids.iteritems())
1779
1624
        tree_paths.sort(reverse=True)
1780
 
        child_pb = ui.ui_factory.nested_progress_bar()
 
1625
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1781
1626
        try:
1782
1627
            for num, data in enumerate(tree_paths):
1783
1628
                path, trans_id = data
1790
1635
                      or trans_id in self._new_parent):
1791
1636
                    try:
1792
1637
                        mover.rename(full_path, self._limbo_name(trans_id))
1793
 
                    except errors.TransformRenameFailed, e:
 
1638
                    except OSError, e:
1794
1639
                        if e.errno != errno.ENOENT:
1795
1640
                            raise
1796
1641
                    else:
1812
1657
        modified_paths = []
1813
1658
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1814
1659
                                 new_paths)
1815
 
        child_pb = ui.ui_factory.nested_progress_bar()
 
1660
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1816
1661
        try:
1817
1662
            for num, (path, trans_id) in enumerate(new_paths):
1818
1663
                if (num % 10) == 0:
1821
1666
                if trans_id in self._needs_rename:
1822
1667
                    try:
1823
1668
                        mover.rename(self._limbo_name(trans_id), full_path)
1824
 
                    except errors.TransformRenameFailed, e:
 
1669
                    except OSError, e:
1825
1670
                        # We may be renaming a dangling inventory id
1826
1671
                        if e.errno != errno.ENOENT:
1827
1672
                            raise
1858
1703
    def tree_kind(self, trans_id):
1859
1704
        path = self._tree_id_paths.get(trans_id)
1860
1705
        if path is None:
1861
 
            return None
 
1706
            raise NoSuchFile(None)
1862
1707
        file_id = self._tree.path2id(path)
1863
 
        try:
1864
 
            return self._tree.kind(file_id)
1865
 
        except errors.NoSuchFile:
1866
 
            return None
 
1708
        return self._tree.kind(file_id)
1867
1709
 
1868
1710
    def _set_mode(self, trans_id, mode_id, typefunc):
1869
1711
        """Set the mode of new file contents.
1889
1731
            childpath = joinpath(path, child)
1890
1732
            yield self.trans_id_tree_path(childpath)
1891
1733
 
1892
 
    def new_orphan(self, trans_id, parent_id):
1893
 
        raise NotImplementedError(self.new_orphan)
1894
 
 
1895
1734
 
1896
1735
class _PreviewTree(tree.Tree):
1897
1736
    """Partial implementation of Tree to support show_diff_trees"""
1931
1770
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1932
1771
                       self._iter_parent_trees()]
1933
1772
        vf.add_lines((file_id, tree_revision), parent_keys,
1934
 
                     self.get_file_lines(file_id))
 
1773
                     self.get_file(file_id).readlines())
1935
1774
        repo = self._get_repository()
1936
1775
        base_vf = repo.texts
1937
1776
        if base_vf not in vf.fallback_versionedfiles:
1959
1798
            executable = self.is_executable(file_id, path)
1960
1799
        return kind, executable, None
1961
1800
 
1962
 
    def is_locked(self):
1963
 
        return False
1964
 
 
1965
1801
    def lock_read(self):
1966
1802
        # Perhaps in theory, this should lock the TreeTransform?
1967
 
        return self
 
1803
        pass
1968
1804
 
1969
1805
    def unlock(self):
1970
1806
        pass
2068
1904
            if (specific_file_ids is not None
2069
1905
                and file_id not in specific_file_ids):
2070
1906
                continue
2071
 
            kind = self._transform.final_kind(trans_id)
2072
 
            if kind is None:
 
1907
            try:
 
1908
                kind = self._transform.final_kind(trans_id)
 
1909
            except NoSuchFile:
2073
1910
                kind = self._transform._tree.stored_kind(file_id)
2074
1911
            new_entry = inventory.make_entry(
2075
1912
                kind,
2307
2144
                path_from_root = self._final_paths.get_path(child_id)
2308
2145
                basename = self._transform.final_name(child_id)
2309
2146
                file_id = self._transform.final_file_id(child_id)
2310
 
                kind  = self._transform.final_kind(child_id)
2311
 
                if kind is not None:
 
2147
                try:
 
2148
                    kind = self._transform.final_kind(child_id)
2312
2149
                    versioned_kind = kind
2313
 
                else:
 
2150
                except NoSuchFile:
2314
2151
                    kind = 'unknown'
2315
2152
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2316
2153
                if versioned_kind == 'directory':
2429
2266
    for num, _unused in enumerate(wt.all_file_ids()):
2430
2267
        if num > 0:  # more than just a root
2431
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)
2432
2272
    file_trans_id = {}
2433
 
    top_pb = ui.ui_factory.nested_progress_bar()
 
2273
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2434
2274
    pp = ProgressPhase("Build phase", 2, top_pb)
2435
2275
    if tree.inventory.root is not None:
2436
2276
        # This is kind of a hack: we should be altering the root
2449
2289
        pp.next_phase()
2450
2290
        file_trans_id[wt.get_root_id()] = \
2451
2291
            tt.trans_id_tree_file_id(wt.get_root_id())
2452
 
        pb = ui.ui_factory.nested_progress_bar()
 
2292
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
2453
2293
        try:
2454
2294
            deferred_contents = []
2455
2295
            num = 0
2458
2298
                precomputed_delta = []
2459
2299
            else:
2460
2300
                precomputed_delta = None
2461
 
            # Check if tree inventory has content. If so, we populate
2462
 
            # existing_files with the directory content. If there are no
2463
 
            # entries we skip populating existing_files as its not used.
2464
 
            # This improves performance and unncessary work on large
2465
 
            # directory trees. (#501307)
2466
 
            if total > 0:
2467
 
                existing_files = set()
2468
 
                for dir, files in wt.walkdirs():
2469
 
                    existing_files.update(f[0] for f in files)
2470
2301
            for num, (tree_path, entry) in \
2471
2302
                enumerate(tree.inventory.iter_entries_by_dir()):
2472
2303
                pb.update("Building tree", num - len(deferred_contents), total)
2592
2423
    for child in tt.iter_tree_children(old_parent):
2593
2424
        tt.adjust_path(tt.final_name(child), new_parent, child)
2594
2425
 
2595
 
 
2596
2426
def _reparent_transform_children(tt, old_parent, new_parent):
2597
2427
    by_parent = tt.by_parent()
2598
2428
    for child in by_parent[old_parent]:
2599
2429
        tt.adjust_path(tt.final_name(child), new_parent, child)
2600
2430
    return by_parent[old_parent]
2601
2431
 
2602
 
 
2603
2432
def _content_match(tree, entry, file_id, kind, target_path):
2604
2433
    if entry.kind != kind:
2605
2434
        return False
2606
2435
    if entry.kind == "directory":
2607
2436
        return True
2608
2437
    if entry.kind == "file":
2609
 
        f = file(target_path, 'rb')
2610
 
        try:
2611
 
            if tree.get_file_text(file_id) == f.read():
2612
 
                return True
2613
 
        finally:
2614
 
            f.close()
 
2438
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
 
2439
            return True
2615
2440
    elif entry.kind == "symlink":
2616
2441
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2617
2442
            return True
2669
2494
        raise errors.BadFileKindError(name, kind)
2670
2495
 
2671
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
 
2672
2513
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2673
2514
    filter_tree_path=None):
2674
2515
    """Create new file contents according to tree contents.
2705
2546
        tt.set_executability(entry.executable, trans_id)
2706
2547
 
2707
2548
 
2708
 
@deprecated_function(deprecated_in((2, 3, 0)))
2709
2549
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2710
2550
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2711
2551
 
2712
2552
 
2713
 
@deprecated_function(deprecated_in((2, 3, 0)))
2714
2553
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2715
2554
    """Produce a backup-style name that appears to be available"""
2716
2555
    def name_gen():
2779
2618
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2780
2619
                              backups, pp, basis_tree=None,
2781
2620
                              merge_modified=None):
2782
 
    child_pb = ui.ui_factory.nested_progress_bar()
 
2621
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2783
2622
    try:
2784
2623
        if merge_modified is None:
2785
2624
            merge_modified = working_tree.merge_modified()
2788
2627
                                      merge_modified, basis_tree)
2789
2628
    finally:
2790
2629
        child_pb.finished()
2791
 
    child_pb = ui.ui_factory.nested_progress_bar()
 
2630
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2792
2631
    try:
2793
2632
        raw_conflicts = resolve_conflicts(tt, child_pb,
2794
2633
            lambda t, c: conflict_pass(t, c, target_tree))
2837
2676
                        tt.delete_contents(trans_id)
2838
2677
                    elif kind[1] is not None:
2839
2678
                        parent_trans_id = tt.trans_id_file_id(parent[0])
2840
 
                        backup_name = tt._available_backup_name(
2841
 
                            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)
2842
2682
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2843
2683
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2844
2684
                        if versioned == (True, True):
2967
2807
 
2968
2808
        elif c_type == 'missing parent':
2969
2809
            trans_id = conflict[1]
2970
 
            if trans_id in tt._removed_contents:
2971
 
                cancel_deletion = True
2972
 
                orphans = tt._get_potential_orphans(trans_id)
2973
 
                if orphans:
2974
 
                    cancel_deletion = False
2975
 
                    # All children are orphans
2976
 
                    for o in orphans:
2977
 
                        try:
2978
 
                            tt.new_orphan(o, trans_id)
2979
 
                        except OrphaningError:
2980
 
                            # Something bad happened so we cancel the directory
2981
 
                            # deletion which will leave it in place with a
2982
 
                            # conflict. The user can deal with it from there.
2983
 
                            # Note that this also catch the case where we don't
2984
 
                            # want to create orphans and leave the directory in
2985
 
                            # place.
2986
 
                            cancel_deletion = True
2987
 
                            break
2988
 
                if cancel_deletion:
2989
 
                    # Cancel the directory deletion
2990
 
                    tt.cancel_deletion(trans_id)
2991
 
                    new_conflicts.add(('deleting parent', 'Not deleting',
2992
 
                                       trans_id))
2993
 
            else:
 
2810
            try:
 
2811
                tt.cancel_deletion(trans_id)
 
2812
                new_conflicts.add(('deleting parent', 'Not deleting',
 
2813
                                   trans_id))
 
2814
            except KeyError:
2994
2815
                create = True
2995
2816
                try:
2996
2817
                    tt.final_name(trans_id)
3021
2842
            file_id = tt.inactive_file_id(conflict[1])
3022
2843
            # special-case the other tree root (move its children instead)
3023
2844
            if path_tree and file_id in path_tree:
3024
 
                if path_tree.path2id('') == file_id:
3025
 
                    # This is the root entry, skip it
 
2845
                if path_tree.inventory[file_id].parent_id is None:
3026
2846
                    continue
3027
2847
            tt.version_file(file_id, conflict[1])
3028
2848
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
3080
2900
    def rename(self, from_, to):
3081
2901
        """Rename a file from one path to another."""
3082
2902
        try:
3083
 
            os.rename(from_, to)
 
2903
            osutils.rename(from_, to)
3084
2904
        except OSError, e:
3085
2905
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
3086
2906
                raise errors.FileExists(to, str(e))
3087
 
            # normal OSError doesn't include filenames so it's hard to see where
3088
 
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
3089
 
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
 
2907
            raise
3090
2908
        self.past_renames.append((from_, to))
3091
2909
 
3092
2910
    def pre_delete(self, from_, to):
3102
2920
    def rollback(self):
3103
2921
        """Reverse all renames that have been performed"""
3104
2922
        for from_, to in reversed(self.past_renames):
3105
 
            try:
3106
 
                os.rename(to, from_)
3107
 
            except OSError, e:
3108
 
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
 
2923
            osutils.rename(to, from_)
3109
2924
        # after rollback, don't reuse _FileMover
3110
2925
        past_renames = None
3111
2926
        pending_deletions = None