/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/branch.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/branch.py
63
63
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
64
64
 
65
65
 
66
 
# TODO: Maybe include checks for common corruption of newlines, etc?
67
 
 
68
 
# TODO: Some operations like log might retrieve the same revisions
69
 
# repeatedly to calculate deltas.  We could perhaps have a weakref
70
 
# cache in memory to make this faster.  In general anything can be
71
 
# cached in memory between lock and unlock operations. .. nb thats
72
 
# what the transaction identity map provides
73
 
 
74
 
 
75
 
######################################################################
76
 
# branch objects
77
 
 
78
 
class Branch(object):
 
66
class Branch(bzrdir.ControlComponent):
79
67
    """Branch holding a history of revisions.
80
68
 
81
 
    base
82
 
        Base directory/url of the branch.
 
69
    :ivar base:
 
70
        Base directory/url of the branch; using control_url and
 
71
        control_transport is more standardized.
83
72
 
84
73
    hooks: An instance of BranchHooks.
85
74
    """
87
76
    # - RBC 20060112
88
77
    base = None
89
78
 
 
79
    @property
 
80
    def control_transport(self):
 
81
        return self._transport
 
82
 
 
83
    @property
 
84
    def user_transport(self):
 
85
        return self.bzrdir.user_transport
 
86
 
90
87
    def __init__(self, *ignored, **ignored_too):
91
88
        self.tags = self._format.make_tags(self)
92
89
        self._revision_history_cache = None
107
104
        """Activate the branch/repository from url as a fallback repository."""
108
105
        repo = self._get_fallback_repository(url)
109
106
        if repo.has_same_location(self.repository):
110
 
            raise errors.UnstackableLocationError(self.base, url)
 
107
            raise errors.UnstackableLocationError(self.user_url, url)
111
108
        self.repository.add_fallback_repository(repo)
112
109
 
113
110
    def break_lock(self):
420
417
            * 'include' - the stop revision is the last item in the result
421
418
            * 'with-merges' - include the stop revision and all of its
422
419
              merged revisions in the result
 
420
            * 'with-merges-without-common-ancestry' - filter out revisions 
 
421
              that are in both ancestries
423
422
        :param direction: either 'reverse' or 'forward':
424
423
            * reverse means return the start_revision_id first, i.e.
425
424
              start at the most recent revision and go backwards in history
447
446
        # start_revision_id.
448
447
        if self._merge_sorted_revisions_cache is None:
449
448
            last_revision = self.last_revision()
450
 
            last_key = (last_revision,)
451
 
            known_graph = self.repository.revisions.get_known_graph_ancestry(
452
 
                [last_key])
 
449
            known_graph = self.repository.get_known_graph_ancestry(
 
450
                [last_revision])
453
451
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
454
 
                last_key)
 
452
                last_revision)
455
453
        filtered = self._filter_merge_sorted_revisions(
456
454
            self._merge_sorted_revisions_cache, start_revision_id,
457
455
            stop_revision_id, stop_rule)
 
456
        # Make sure we don't return revisions that are not part of the
 
457
        # start_revision_id ancestry.
 
458
        filtered = self._filter_start_non_ancestors(filtered)
458
459
        if direction == 'reverse':
459
460
            return filtered
460
461
        if direction == 'forward':
497
498
                       node.end_of_merge)
498
499
                if rev_id == stop_revision_id:
499
500
                    return
 
501
        elif stop_rule == 'with-merges-without-common-ancestry':
 
502
            # We want to exclude all revisions that are already part of the
 
503
            # stop_revision_id ancestry.
 
504
            graph = self.repository.get_graph()
 
505
            ancestors = graph.find_unique_ancestors(start_revision_id,
 
506
                                                    [stop_revision_id])
 
507
            for node in rev_iter:
 
508
                rev_id = node.key[-1]
 
509
                if rev_id not in ancestors:
 
510
                    continue
 
511
                yield (rev_id, node.merge_depth, node.revno,
 
512
                       node.end_of_merge)
500
513
        elif stop_rule == 'with-merges':
501
514
            stop_rev = self.repository.get_revision(stop_revision_id)
502
515
            if stop_rev.parent_ids:
525
538
        else:
526
539
            raise ValueError('invalid stop_rule %r' % stop_rule)
527
540
 
 
541
    def _filter_start_non_ancestors(self, rev_iter):
 
542
        # If we started from a dotted revno, we want to consider it as a tip
 
543
        # and don't want to yield revisions that are not part of its
 
544
        # ancestry. Given the order guaranteed by the merge sort, we will see
 
545
        # uninteresting descendants of the first parent of our tip before the
 
546
        # tip itself.
 
547
        first = rev_iter.next()
 
548
        (rev_id, merge_depth, revno, end_of_merge) = first
 
549
        yield first
 
550
        if not merge_depth:
 
551
            # We start at a mainline revision so by definition, all others
 
552
            # revisions in rev_iter are ancestors
 
553
            for node in rev_iter:
 
554
                yield node
 
555
 
 
556
        clean = False
 
557
        whitelist = set()
 
558
        pmap = self.repository.get_parent_map([rev_id])
 
559
        parents = pmap.get(rev_id, [])
 
560
        if parents:
 
561
            whitelist.update(parents)
 
562
        else:
 
563
            # If there is no parents, there is nothing of interest left
 
564
 
 
565
            # FIXME: It's hard to test this scenario here as this code is never
 
566
            # called in that case. -- vila 20100322
 
567
            return
 
568
 
 
569
        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
 
570
            if not clean:
 
571
                if rev_id in whitelist:
 
572
                    pmap = self.repository.get_parent_map([rev_id])
 
573
                    parents = pmap.get(rev_id, [])
 
574
                    whitelist.remove(rev_id)
 
575
                    whitelist.update(parents)
 
576
                    if merge_depth == 0:
 
577
                        # We've reached the mainline, there is nothing left to
 
578
                        # filter
 
579
                        clean = True
 
580
                else:
 
581
                    # A revision that is not part of the ancestry of our
 
582
                    # starting revision.
 
583
                    continue
 
584
            yield (rev_id, merge_depth, revno, end_of_merge)
 
585
 
528
586
    def leave_lock_in_place(self):
529
587
        """Tell this branch object not to release the physical lock when this
530
588
        object is unlocked.
547
605
        :param other: The branch to bind to
548
606
        :type other: Branch
549
607
        """
550
 
        raise errors.UpgradeRequired(self.base)
 
608
        raise errors.UpgradeRequired(self.user_url)
551
609
 
552
610
    def set_append_revisions_only(self, enabled):
553
611
        if not self._format.supports_set_append_revisions_only():
554
 
            raise errors.UpgradeRequired(self.base)
 
612
            raise errors.UpgradeRequired(self.user_url)
555
613
        if enabled:
556
614
            value = 'True'
557
615
        else:
605
663
    def get_old_bound_location(self):
606
664
        """Return the URL of the branch we used to be bound to
607
665
        """
608
 
        raise errors.UpgradeRequired(self.base)
 
666
        raise errors.UpgradeRequired(self.user_url)
609
667
 
610
668
    def get_commit_builder(self, parents, config=None, timestamp=None,
611
669
                           timezone=None, committer=None, revprops=None,
689
747
            stacking.
690
748
        """
691
749
        if not self._format.supports_stacking():
692
 
            raise errors.UnstackableBranchFormat(self._format, self.base)
 
750
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
693
751
        # XXX: Changing from one fallback repository to another does not check
694
752
        # that all the data you need is present in the new fallback.
695
753
        # Possibly it should.
846
904
 
847
905
    def unbind(self):
848
906
        """Older format branches cannot bind or unbind."""
849
 
        raise errors.UpgradeRequired(self.base)
 
907
        raise errors.UpgradeRequired(self.user_url)
850
908
 
851
909
    def last_revision(self):
852
910
        """Return last revision id, or NULL_REVISION."""
1012
1070
        try:
1013
1071
            return urlutils.join(self.base[:-1], parent)
1014
1072
        except errors.InvalidURLJoin, e:
1015
 
            raise errors.InaccessibleParent(parent, self.base)
 
1073
            raise errors.InaccessibleParent(parent, self.user_url)
1016
1074
 
1017
1075
    def _get_parent_location(self):
1018
1076
        raise NotImplementedError(self._get_parent_location)
1496
1554
        """Return the short format description for this format."""
1497
1555
        raise NotImplementedError(self.get_format_description)
1498
1556
 
 
1557
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
 
1558
        hooks = Branch.hooks['post_branch_init']
 
1559
        if not hooks:
 
1560
            return
 
1561
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
 
1562
        for hook in hooks:
 
1563
            hook(params)
 
1564
 
1499
1565
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1500
1566
                           lock_type='metadir', set_format=True):
1501
1567
        """Initialize a branch in a bzrdir, with specified files
1509
1575
            elsewhere)
1510
1576
        :return: a branch in this format
1511
1577
        """
1512
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
1578
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1513
1579
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1514
1580
        lock_map = {
1515
1581
            'metadir': ('lock', lockdir.LockDir),
1537
1603
        finally:
1538
1604
            if lock_taken:
1539
1605
                control_files.unlock()
1540
 
        return self.open(a_bzrdir, name, _found=True)
 
1606
        branch = self.open(a_bzrdir, name, _found=True)
 
1607
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
1608
        return branch
1541
1609
 
1542
1610
    def initialize(self, a_bzrdir, name=None):
1543
1611
        """Create a branch of this format in a_bzrdir.
1703
1771
            "should return a tag name or None if no tag name could be "
1704
1772
            "determined. The first non-None tag name returned will be used.",
1705
1773
            (2, 2), None))
 
1774
        self.create_hook(HookPoint('post_branch_init',
 
1775
            "Called after new branch initialization completes. "
 
1776
            "post_branch_init is called with a "
 
1777
            "bzrlib.branch.BranchInitHookParams. "
 
1778
            "Note that init, branch and checkout (both heavyweight and "
 
1779
            "lightweight) will all trigger this hook.", (2, 2), None))
 
1780
        self.create_hook(HookPoint('post_switch',
 
1781
            "Called after a checkout switches branch. "
 
1782
            "post_switch is called with a "
 
1783
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1706
1784
 
1707
1785
 
1708
1786
 
1748
1826
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1749
1827
 
1750
1828
 
 
1829
class BranchInitHookParams(object):
 
1830
    """Object holding parameters passed to *_branch_init hooks.
 
1831
 
 
1832
    There are 4 fields that hooks may wish to access:
 
1833
 
 
1834
    :ivar format: the branch format
 
1835
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
 
1836
    :ivar name: name of colocated branch, if any (or None)
 
1837
    :ivar branch: the branch created
 
1838
 
 
1839
    Note that for lightweight checkouts, the bzrdir and format fields refer to
 
1840
    the checkout, hence they are different from the corresponding fields in
 
1841
    branch, which refer to the original branch.
 
1842
    """
 
1843
 
 
1844
    def __init__(self, format, a_bzrdir, name, branch):
 
1845
        """Create a group of BranchInitHook parameters.
 
1846
 
 
1847
        :param format: the branch format
 
1848
        :param a_bzrdir: the BzrDir where the branch will be/has been
 
1849
            initialized
 
1850
        :param name: name of colocated branch, if any (or None)
 
1851
        :param branch: the branch created
 
1852
 
 
1853
        Note that for lightweight checkouts, the bzrdir and format fields refer
 
1854
        to the checkout, hence they are different from the corresponding fields
 
1855
        in branch, which refer to the original branch.
 
1856
        """
 
1857
        self.format = format
 
1858
        self.bzrdir = a_bzrdir
 
1859
        self.name = name
 
1860
        self.branch = branch
 
1861
 
 
1862
    def __eq__(self, other):
 
1863
        return self.__dict__ == other.__dict__
 
1864
 
 
1865
    def __repr__(self):
 
1866
        if self.branch:
 
1867
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
 
1868
        else:
 
1869
            return "<%s of format:%s bzrdir:%s>" % (
 
1870
                self.__class__.__name__, self.branch,
 
1871
                self.format, self.bzrdir)
 
1872
 
 
1873
 
 
1874
class SwitchHookParams(object):
 
1875
    """Object holding parameters passed to *_switch hooks.
 
1876
 
 
1877
    There are 4 fields that hooks may wish to access:
 
1878
 
 
1879
    :ivar control_dir: BzrDir of the checkout to change
 
1880
    :ivar to_branch: branch that the checkout is to reference
 
1881
    :ivar force: skip the check for local commits in a heavy checkout
 
1882
    :ivar revision_id: revision ID to switch to (or None)
 
1883
    """
 
1884
 
 
1885
    def __init__(self, control_dir, to_branch, force, revision_id):
 
1886
        """Create a group of SwitchHook parameters.
 
1887
 
 
1888
        :param control_dir: BzrDir of the checkout to change
 
1889
        :param to_branch: branch that the checkout is to reference
 
1890
        :param force: skip the check for local commits in a heavy checkout
 
1891
        :param revision_id: revision ID to switch to (or None)
 
1892
        """
 
1893
        self.control_dir = control_dir
 
1894
        self.to_branch = to_branch
 
1895
        self.force = force
 
1896
        self.revision_id = revision_id
 
1897
 
 
1898
    def __eq__(self, other):
 
1899
        return self.__dict__ == other.__dict__
 
1900
 
 
1901
    def __repr__(self):
 
1902
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
 
1903
            self.control_dir, self.to_branch,
 
1904
            self.revision_id)
 
1905
 
 
1906
 
1751
1907
class BzrBranchFormat4(BranchFormat):
1752
1908
    """Bzr branch format 4.
1753
1909
 
1812
1968
            if format.__class__ != self.__class__:
1813
1969
                raise AssertionError("wrong format %r found for %r" %
1814
1970
                    (format, self))
 
1971
        transport = a_bzrdir.get_branch_transport(None, name=name)
1815
1972
        try:
1816
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
1817
1973
            control_files = lockable_files.LockableFiles(transport, 'lock',
1818
1974
                                                         lockdir.LockDir)
1819
1975
            return self._branch_class()(_format=self,
2017
2173
            # this format does not implement branch itself, thus the implicit
2018
2174
            # creation contract must see it as uninitializable
2019
2175
            raise errors.UninitializableFormat(self)
2020
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
2176
        mutter('creating branch reference in %s', a_bzrdir.user_url)
2021
2177
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2022
2178
        branch_transport.put_bytes('location',
2023
 
            target_branch.bzrdir.root_transport.base)
 
2179
            target_branch.bzrdir.user_url)
2024
2180
        branch_transport.put_bytes('format', self.get_format_string())
2025
 
        return self.open(
 
2181
        branch = self.open(
2026
2182
            a_bzrdir, name, _found=True,
2027
2183
            possible_transports=[target_branch.bzrdir.root_transport])
 
2184
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2185
        return branch
2028
2186
 
2029
2187
    def __init__(self):
2030
2188
        super(BranchReferenceFormat, self).__init__()
2146
2304
 
2147
2305
    def __str__(self):
2148
2306
        if self.name is None:
2149
 
            return '%s(%r)' % (self.__class__.__name__, self.base)
 
2307
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
2150
2308
        else:
2151
 
            return '%s(%r,%r)' % (self.__class__.__name__, self.base, self.name)
 
2309
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
 
2310
                self.name)
2152
2311
 
2153
2312
    __repr__ = __str__
2154
2313
 
2369
2528
        return result
2370
2529
 
2371
2530
    def get_stacked_on_url(self):
2372
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2531
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2373
2532
 
2374
2533
    def set_push_location(self, location):
2375
2534
        """See Branch.set_push_location."""
2565
2724
        if _mod_revision.is_null(last_revision):
2566
2725
            return
2567
2726
        if last_revision not in self._lefthand_history(revision_id):
2568
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2727
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
2569
2728
 
2570
2729
    def _gen_revision_history(self):
2571
2730
        """Generate the revision history from last revision
2671
2830
        if branch_location is None:
2672
2831
            return Branch.reference_parent(self, file_id, path,
2673
2832
                                           possible_transports)
2674
 
        branch_location = urlutils.join(self.base, branch_location)
 
2833
        branch_location = urlutils.join(self.user_url, branch_location)
2675
2834
        return Branch.open(branch_location,
2676
2835
                           possible_transports=possible_transports)
2677
2836
 
2723
2882
        return stacked_url
2724
2883
 
2725
2884
    def _get_append_revisions_only(self):
2726
 
        value = self.get_config().get_user_option('append_revisions_only')
2727
 
        return value == 'True'
 
2885
        return self.get_config(
 
2886
            ).get_user_option_as_bool('append_revisions_only')
2728
2887
 
2729
2888
    @needs_write_lock
2730
2889
    def generate_revision_history(self, revision_id, last_rev=None,
2792
2951
    """
2793
2952
 
2794
2953
    def get_stacked_on_url(self):
2795
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2954
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2796
2955
 
2797
2956
 
2798
2957
######################################################################
2885
3044
        :param verbose: Requests more detailed display of what was checked,
2886
3045
            if any.
2887
3046
        """
2888
 
        note('checked branch %s format %s', self.branch.base,
 
3047
        note('checked branch %s format %s', self.branch.user_url,
2889
3048
            self.branch._format)
2890
3049
        for error in self.errors:
2891
3050
            note('found error:%s', error)
3220
3379
        if local and not bound_location:
3221
3380
            raise errors.LocalRequiresBoundBranch()
3222
3381
        master_branch = None
3223
 
        if not local and bound_location and self.source.base != bound_location:
 
3382
        if not local and bound_location and self.source.user_url != bound_location:
3224
3383
            # not pulling from master, so we need to update master.
3225
3384
            master_branch = self.target.get_master_branch(possible_transports)
3226
3385
            master_branch.lock_write()