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