← Back to branch summary

~vila/bzr/doc-new-config

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-10-15 16:41:48 UTC
  • mfrom: (5502.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20101015164148-k10lo687r72nzbtl
(vila) Provides a ``bzr.transform.orphan_policy`` option to control
        orphan handling when merging directory deletion (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
19
19
from stat import S_ISREG, S_IEXEC
20
20
import time
21
21
 
22
 
from bzrlib.lazy_import import lazy_import
23
 
lazy_import(globals(), """
 
22
from bzrlib import (
 
23
    errors,
 
24
    lazy_import,
 
25
    registry,
 
26
    )
 
27
lazy_import.lazy_import(globals(), """
24
28
from bzrlib import (
25
29
    annotate,
26
30
    bencode,
32
36
    multiparent,
33
37
    osutils,
34
38
    revision as _mod_revision,
 
39
    trace,
35
40
    ui,
36
41
    )
37
42
""")
55
60
from bzrlib.symbol_versioning import (
56
61
        deprecated_function,
57
62
        deprecated_in,
 
63
        deprecated_method,
58
64
        )
59
65
from bzrlib.trace import mutter, warning
60
66
from bzrlib import tree
64
70
 
65
71
ROOT_PARENT = "root-parent"
66
72
 
67
 
 
68
73
def unique_add(map, key, value):
69
74
    if key in map:
70
75
        raise DuplicateKey(key=key)
71
76
    map[key] = value
72
77
 
73
78
 
 
79
 
74
80
class _TransformResults(object):
75
81
    def __init__(self, modified_paths, rename_count):
76
82
        object.__init__(self)
531
537
            # ensure that all children are registered with the transaction
532
538
            list(self.iter_tree_children(parent_id))
533
539
 
 
540
    @deprecated_method(deprecated_in((2, 3, 0)))
534
541
    def has_named_child(self, by_parent, parent_id, name):
535
 
        try:
536
 
            children = by_parent[parent_id]
537
 
        except KeyError:
538
 
            children = []
539
 
        for child in children:
 
542
        return self._has_named_child(
 
543
            name, parent_id, known_children=by_parent.get(parent_id, []))
 
544
 
 
545
    def _has_named_child(self, name, parent_id, known_children):
 
546
        """Does a parent already have a name child.
 
547
 
 
548
        :param name: The searched for name.
 
549
 
 
550
        :param parent_id: The parent for which the check is made.
 
551
 
 
552
        :param known_children: The already known children. This should have
 
553
            been recently obtained from `self.by_parent.get(parent_id)`
 
554
            (or will be if None is passed).
 
555
        """
 
556
        if known_children is None:
 
557
            known_children = self.by_parent().get(parent_id, [])
 
558
        for child in known_children:
540
559
            if self.final_name(child) == name:
541
560
                return True
542
 
        try:
543
 
            path = self._tree_id_paths[parent_id]
544
 
        except KeyError:
 
561
        parent_path = self._tree_id_paths.get(parent_id, None)
 
562
        if parent_path is None:
 
563
            # No parent... no children
545
564
            return False
546
 
        childpath = joinpath(path, name)
547
 
        child_id = self._tree_path_ids.get(childpath)
 
565
        child_path = joinpath(parent_path, name)
 
566
        child_id = self._tree_path_ids.get(child_path, None)
548
567
        if child_id is None:
549
 
            return lexists(self._tree.abspath(childpath))
 
568
            # Not known by the tree transform yet, check the filesystem
 
569
            return osutils.lexists(self._tree.abspath(child_path))
550
570
        else:
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
 
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))
558
587
 
559
588
    def _parent_loops(self):
560
589
        """No entry should be its own ancestor"""
759
788
        self.create_symlink(target, trans_id)
760
789
        return trans_id
761
790
 
 
791
    def new_orphan(self, trans_id, parent_id):
 
792
        """Schedule an item to be orphaned.
 
793
 
 
794
        When a directory is about to be removed, its children, if they are not
 
795
        versioned are moved out of the way: they don't have a parent anymore.
 
796
 
 
797
        :param trans_id: The trans_id of the existing item.
 
798
        :param parent_id: The parent trans_id of the item.
 
799
        """
 
800
        raise NotImplementedError(self.new_orphan)
 
801
 
 
802
    def _get_potential_orphans(self, dir_id):
 
803
        """Find the potential orphans in a directory.
 
804
 
 
805
        A directory can't be safely deleted if there are versioned files in it.
 
806
        If all the contained files are unversioned then they can be orphaned.
 
807
 
 
808
        The 'None' return value means that the directory contains at least one
 
809
        versioned file and should not be deleted.
 
810
 
 
811
        :param dir_id: The directory trans id.
 
812
 
 
813
        :return: A list of the orphan trans ids or None if at least one
 
814
             versioned file is present.
 
815
        """
 
816
        orphans = []
 
817
        # Find the potential orphans, stop if one item should be kept
 
818
        for c in self.by_parent()[dir_id]:
 
819
            if self.final_file_id(c) is None:
 
820
                orphans.append(c)
 
821
            else:
 
822
                # We have a versioned file here, searching for orphans is
 
823
                # meaningless.
 
824
                orphans = None
 
825
                break
 
826
        return orphans
 
827
 
762
828
    def _affected_ids(self):
763
829
        """Return the set of transform ids affected by the transform"""
764
830
        trans_ids = set(self._removed_id)
1271
1337
            del self._limbo_children_names[trans_id]
1272
1338
        delete_any(self._limbo_name(trans_id))
1273
1339
 
 
1340
    def new_orphan(self, trans_id, parent_id):
 
1341
        # FIXME: There is no tree config, so we use the branch one (it's weird
 
1342
        # to define it this way as orphaning can only occur in a working tree,
 
1343
        # but that's all we have (for now). It will find the option in
 
1344
        # locations.conf or bazaar.conf though) -- vila 20100916
 
1345
        conf = self._tree.branch.get_config()
 
1346
        conf_var_name = 'bzr.transform.orphan_policy'
 
1347
        orphan_policy = conf.get_user_option(conf_var_name)
 
1348
        default_policy = orphaning_registry.default_key
 
1349
        if orphan_policy is None:
 
1350
            orphan_policy = default_policy
 
1351
        if orphan_policy not in orphaning_registry:
 
1352
            trace.warning('%s (from %s) is not a known policy, defaulting to %s'
 
1353
                          % (orphan_policy, conf_var_name, default_policy))
 
1354
            orphan_policy = default_policy
 
1355
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1356
        handle_orphan(self, trans_id, parent_id)
 
1357
 
 
1358
 
 
1359
class OrphaningError(errors.BzrError):
 
1360
 
 
1361
    # Only bugs could lead to such exception being seen by the user
 
1362
    internal_error = True
 
1363
    _fmt = "Error while orphaning %s in %s directory"
 
1364
 
 
1365
    def __init__(self, orphan, parent):
 
1366
        errors.BzrError.__init__(self)
 
1367
        self.orphan = orphan
 
1368
        self.parent = parent
 
1369
 
 
1370
 
 
1371
class OrphaningForbidden(OrphaningError):
 
1372
 
 
1373
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1374
 
 
1375
    def __init__(self, policy):
 
1376
        errors.BzrError.__init__(self)
 
1377
        self.policy = policy
 
1378
 
 
1379
 
 
1380
def move_orphan(tt, orphan_id, parent_id):
 
1381
    """See TreeTransformBase.new_orphan.
 
1382
 
 
1383
    This creates a new orphan in the `bzr-orphans` dir at the root of the
 
1384
    `TreeTransform`.
 
1385
 
 
1386
    :param tt: The TreeTransform orphaning `trans_id`.
 
1387
 
 
1388
    :param orphan_id: The trans id that should be orphaned.
 
1389
 
 
1390
    :param parent_id: The orphan parent trans id.
 
1391
    """
 
1392
    # Add the orphan dir if it doesn't exist
 
1393
    orphan_dir_basename = 'bzr-orphans'
 
1394
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1395
    if tt.final_kind(od_id) is None:
 
1396
        tt.create_directory(od_id)
 
1397
    parent_path = tt._tree_id_paths[parent_id]
 
1398
    # Find a name that doesn't exist yet in the orphan dir
 
1399
    actual_name = tt.final_name(orphan_id)
 
1400
    new_name = tt._available_backup_name(actual_name, od_id)
 
1401
    tt.adjust_path(new_name, od_id, orphan_id)
 
1402
    trace.warning('%s has been orphaned in %s'
 
1403
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1404
 
 
1405
 
 
1406
def refuse_orphan(tt, orphan_id, parent_id):
 
1407
    """See TreeTransformBase.new_orphan.
 
1408
 
 
1409
    This refuses to create orphan, letting the caller handle the conflict.
 
1410
    """
 
1411
    raise OrphaningForbidden('never')
 
1412
 
 
1413
 
 
1414
orphaning_registry = registry.Registry()
 
1415
orphaning_registry.register(
 
1416
    'conflict', refuse_orphan,
 
1417
    'Leave orphans in place and create a conflict on the directory.')
 
1418
orphaning_registry.register(
 
1419
    'move', move_orphan,
 
1420
    'Move orphans into the bzr-orphans directory.')
 
1421
orphaning_registry._set_default_key('conflict')
 
1422
 
1274
1423
 
1275
1424
class TreeTransform(DiskTreeTransform):
1276
1425
    """Represent a tree transformation.
1727
1876
            childpath = joinpath(path, child)
1728
1877
            yield self.trans_id_tree_path(childpath)
1729
1878
 
 
1879
    def new_orphan(self, trans_id, parent_id):
 
1880
        raise NotImplementedError(self.new_orphan)
 
1881
 
1730
1882
 
1731
1883
class _PreviewTree(tree.Tree):
1732
1884
    """Partial implementation of Tree to support show_diff_trees"""
2427
2579
    for child in tt.iter_tree_children(old_parent):
2428
2580
        tt.adjust_path(tt.final_name(child), new_parent, child)
2429
2581
 
 
2582
 
2430
2583
def _reparent_transform_children(tt, old_parent, new_parent):
2431
2584
    by_parent = tt.by_parent()
2432
2585
    for child in by_parent[old_parent]:
2433
2586
        tt.adjust_path(tt.final_name(child), new_parent, child)
2434
2587
    return by_parent[old_parent]
2435
2588
 
 
2589
 
2436
2590
def _content_match(tree, entry, file_id, kind, target_path):
2437
2591
    if entry.kind != kind:
2438
2592
        return False
2538
2692
        tt.set_executability(entry.executable, trans_id)
2539
2693
 
2540
2694
 
 
2695
@deprecated_function(deprecated_in((2, 3, 0)))
2541
2696
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2542
2697
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2543
2698
 
2544
2699
 
 
2700
@deprecated_function(deprecated_in((2, 3, 0)))
2545
2701
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2546
2702
    """Produce a backup-style name that appears to be available"""
2547
2703
    def name_gen():
2668
2824
                        tt.delete_contents(trans_id)
2669
2825
                    elif kind[1] is not None:
2670
2826
                        parent_trans_id = tt.trans_id_file_id(parent[0])
2671
 
                        by_parent = tt.by_parent()
2672
 
                        backup_name = _get_backup_name(name[0], by_parent,
2673
 
                                                       parent_trans_id, tt)
 
2827
                        backup_name = tt._available_backup_name(
 
2828
                            name[0], parent_trans_id)
2674
2829
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2675
2830
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2676
2831
                        if versioned == (True, True):
2799
2954
 
2800
2955
        elif c_type == 'missing parent':
2801
2956
            trans_id = conflict[1]
2802
 
            try:
2803
 
                tt.cancel_deletion(trans_id)
2804
 
                new_conflicts.add(('deleting parent', 'Not deleting',
2805
 
                                   trans_id))
2806
 
            except KeyError:
 
2957
            if trans_id in tt._removed_contents:
 
2958
                cancel_deletion = True
 
2959
                orphans = tt._get_potential_orphans(trans_id)
 
2960
                if orphans:
 
2961
                    cancel_deletion = False
 
2962
                    # All children are orphans
 
2963
                    for o in orphans:
 
2964
                        try:
 
2965
                            tt.new_orphan(o, trans_id)
 
2966
                        except OrphaningError:
 
2967
                            # Something bad happened so we cancel the directory
 
2968
                            # deletion which will leave it in place with a
 
2969
                            # conflict. The user can deal with it from there.
 
2970
                            # Note that this also catch the case where we don't
 
2971
                            # want to create orphans and leave the directory in
 
2972
                            # place.
 
2973
                            cancel_deletion = True
 
2974
                            break
 
2975
                if cancel_deletion:
 
2976
                    # Cancel the directory deletion
 
2977
                    tt.cancel_deletion(trans_id)
 
2978
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
2979
                                       trans_id))
 
2980
            else:
2807
2981
                create = True
2808
2982
                try:
2809
2983
                    tt.final_name(trans_id)
2917
3091
            try:
2918
3092
                os.rename(to, from_)
2919
3093
            except OSError, e:
2920
 
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)                
 
3094
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2921
3095
        # after rollback, don't reuse _FileMover
2922
3096
        past_renames = None
2923
3097
        pending_deletions = None