/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:
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-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
46
46
    )
47
47
""")
48
48
 
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
49
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
50
from bzrlib.hooks import HookPoint, Hooks
51
51
from bzrlib.inter import InterObject
 
52
from bzrlib.lock import _RelockDebugMixin
52
53
from bzrlib import registry
53
54
from bzrlib.symbol_versioning import (
54
55
    deprecated_in,
62
63
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
63
64
 
64
65
 
65
 
# TODO: Maybe include checks for common corruption of newlines, etc?
66
 
 
67
 
# TODO: Some operations like log might retrieve the same revisions
68
 
# repeatedly to calculate deltas.  We could perhaps have a weakref
69
 
# cache in memory to make this faster.  In general anything can be
70
 
# cached in memory between lock and unlock operations. .. nb thats
71
 
# what the transaction identity map provides
72
 
 
73
 
 
74
 
######################################################################
75
 
# branch objects
76
 
 
77
 
class Branch(object):
 
66
class Branch(bzrdir.ControlComponent):
78
67
    """Branch holding a history of revisions.
79
68
 
80
 
    base
81
 
        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.
82
72
 
83
73
    hooks: An instance of BranchHooks.
84
74
    """
86
76
    # - RBC 20060112
87
77
    base = None
88
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
 
89
87
    def __init__(self, *ignored, **ignored_too):
90
88
        self.tags = self._format.make_tags(self)
91
89
        self._revision_history_cache = None
92
90
        self._revision_id_to_revno_cache = None
93
91
        self._partial_revision_id_to_revno_cache = {}
 
92
        self._partial_revision_history_cache = []
94
93
        self._last_revision_info_cache = None
95
94
        self._merge_sorted_revisions_cache = None
96
95
        self._open_hook()
101
100
    def _open_hook(self):
102
101
        """Called by init to allow simpler extension of the base class."""
103
102
 
104
 
    def _activate_fallback_location(self, url, lock_style):
 
103
    def _activate_fallback_location(self, url):
105
104
        """Activate the branch/repository from url as a fallback repository."""
106
105
        repo = self._get_fallback_repository(url)
107
 
        if lock_style == 'write':
108
 
            repo.lock_write()
109
 
        elif lock_style == 'read':
110
 
            repo.lock_read()
 
106
        if repo.has_same_location(self.repository):
 
107
            raise errors.UnstackableLocationError(self.user_url, url)
111
108
        self.repository.add_fallback_repository(repo)
112
109
 
113
110
    def break_lock(self):
129
126
            raise errors.UnstackableRepositoryFormat(self.repository._format,
130
127
                self.repository.base)
131
128
 
 
129
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
 
130
        """Extend the partial history to include a given index
 
131
 
 
132
        If a stop_index is supplied, stop when that index has been reached.
 
133
        If a stop_revision is supplied, stop when that revision is
 
134
        encountered.  Otherwise, stop when the beginning of history is
 
135
        reached.
 
136
 
 
137
        :param stop_index: The index which should be present.  When it is
 
138
            present, history extension will stop.
 
139
        :param stop_revision: The revision id which should be present.  When
 
140
            it is encountered, history extension will stop.
 
141
        """
 
142
        if len(self._partial_revision_history_cache) == 0:
 
143
            self._partial_revision_history_cache = [self.last_revision()]
 
144
        repository._iter_for_revno(
 
145
            self.repository, self._partial_revision_history_cache,
 
146
            stop_index=stop_index, stop_revision=stop_revision)
 
147
        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
 
148
            self._partial_revision_history_cache.pop()
 
149
 
 
150
    def _get_check_refs(self):
 
151
        """Get the references needed for check().
 
152
 
 
153
        See bzrlib.check.
 
154
        """
 
155
        revid = self.last_revision()
 
156
        return [('revision-existence', revid), ('lefthand-distance', revid)]
 
157
 
132
158
    @staticmethod
133
159
    def open(base, _unsupported=False, possible_transports=None):
134
160
        """Open the branch rooted at base.
138
164
        """
139
165
        control = bzrdir.BzrDir.open(base, _unsupported,
140
166
                                     possible_transports=possible_transports)
141
 
        return control.open_branch(_unsupported)
 
167
        return control.open_branch(unsupported=_unsupported)
142
168
 
143
169
    @staticmethod
144
 
    def open_from_transport(transport, _unsupported=False):
 
170
    def open_from_transport(transport, name=None, _unsupported=False):
145
171
        """Open the branch rooted at transport"""
146
172
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
147
 
        return control.open_branch(_unsupported)
 
173
        return control.open_branch(name=name, unsupported=_unsupported)
148
174
 
149
175
    @staticmethod
150
176
    def open_containing(url, possible_transports=None):
188
214
    def _get_fallback_repository(self, url):
189
215
        """Get the repository we fallback to at url."""
190
216
        url = urlutils.join(self.base, url)
191
 
        a_bzrdir = bzrdir.BzrDir.open(url,
 
217
        a_branch = Branch.open(url,
192
218
            possible_transports=[self.bzrdir.root_transport])
193
 
        return a_bzrdir.open_branch().repository
 
219
        return a_branch.repository
194
220
 
195
221
    def _get_tags_bytes(self):
196
222
        """Get the bytes of a serialised tags dict.
391
417
            * 'include' - the stop revision is the last item in the result
392
418
            * 'with-merges' - include the stop revision and all of its
393
419
              merged revisions in the result
 
420
            * 'with-merges-without-common-ancestry' - filter out revisions 
 
421
              that are in both ancestries
394
422
        :param direction: either 'reverse' or 'forward':
395
423
            * reverse means return the start_revision_id first, i.e.
396
424
              start at the most recent revision and go backwards in history
418
446
        # start_revision_id.
419
447
        if self._merge_sorted_revisions_cache is None:
420
448
            last_revision = self.last_revision()
421
 
            graph = self.repository.get_graph()
422
 
            parent_map = dict(((key, value) for key, value in
423
 
                     graph.iter_ancestry([last_revision]) if value is not None))
424
 
            revision_graph = repository._strip_NULL_ghosts(parent_map)
425
 
            revs = tsort.merge_sort(revision_graph, last_revision, None,
426
 
                generate_revno=True)
427
 
            # Drop the sequence # before caching
428
 
            self._merge_sorted_revisions_cache = [r[1:] for r in revs]
429
 
 
 
449
            known_graph = self.repository.get_known_graph_ancestry(
 
450
                [last_revision])
 
451
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
 
452
                last_revision)
430
453
        filtered = self._filter_merge_sorted_revisions(
431
454
            self._merge_sorted_revisions_cache, start_revision_id,
432
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)
433
459
        if direction == 'reverse':
434
460
            return filtered
435
461
        if direction == 'forward':
442
468
        """Iterate over an inclusive range of sorted revisions."""
443
469
        rev_iter = iter(merge_sorted_revisions)
444
470
        if start_revision_id is not None:
445
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
471
            for node in rev_iter:
 
472
                rev_id = node.key[-1]
446
473
                if rev_id != start_revision_id:
447
474
                    continue
448
475
                else:
449
476
                    # The decision to include the start or not
450
477
                    # depends on the stop_rule if a stop is provided
451
 
                    rev_iter = chain(
452
 
                        iter([(rev_id, depth, revno, end_of_merge)]),
453
 
                        rev_iter)
 
478
                    # so pop this node back into the iterator
 
479
                    rev_iter = chain(iter([node]), rev_iter)
454
480
                    break
455
481
        if stop_revision_id is None:
456
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
457
 
                yield rev_id, depth, revno, end_of_merge
 
482
            # Yield everything
 
483
            for node in rev_iter:
 
484
                rev_id = node.key[-1]
 
485
                yield (rev_id, node.merge_depth, node.revno,
 
486
                       node.end_of_merge)
458
487
        elif stop_rule == 'exclude':
459
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
488
            for node in rev_iter:
 
489
                rev_id = node.key[-1]
460
490
                if rev_id == stop_revision_id:
461
491
                    return
462
 
                yield rev_id, depth, revno, end_of_merge
 
492
                yield (rev_id, node.merge_depth, node.revno,
 
493
                       node.end_of_merge)
463
494
        elif stop_rule == 'include':
464
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
465
 
                yield rev_id, depth, revno, end_of_merge
 
495
            for node in rev_iter:
 
496
                rev_id = node.key[-1]
 
497
                yield (rev_id, node.merge_depth, node.revno,
 
498
                       node.end_of_merge)
466
499
                if rev_id == stop_revision_id:
467
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)
468
513
        elif stop_rule == 'with-merges':
469
514
            stop_rev = self.repository.get_revision(stop_revision_id)
470
515
            if stop_rev.parent_ids:
471
516
                left_parent = stop_rev.parent_ids[0]
472
517
            else:
473
518
                left_parent = _mod_revision.NULL_REVISION
474
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
519
            # left_parent is the actual revision we want to stop logging at,
 
520
            # since we want to show the merged revisions after the stop_rev too
 
521
            reached_stop_revision_id = False
 
522
            revision_id_whitelist = []
 
523
            for node in rev_iter:
 
524
                rev_id = node.key[-1]
475
525
                if rev_id == left_parent:
 
526
                    # reached the left parent after the stop_revision
476
527
                    return
477
 
                yield rev_id, depth, revno, end_of_merge
 
528
                if (not reached_stop_revision_id or
 
529
                        rev_id in revision_id_whitelist):
 
530
                    yield (rev_id, node.merge_depth, node.revno,
 
531
                       node.end_of_merge)
 
532
                    if reached_stop_revision_id or rev_id == stop_revision_id:
 
533
                        # only do the merged revs of rev_id from now on
 
534
                        rev = self.repository.get_revision(rev_id)
 
535
                        if rev.parent_ids:
 
536
                            reached_stop_revision_id = True
 
537
                            revision_id_whitelist.extend(rev.parent_ids)
478
538
        else:
479
539
            raise ValueError('invalid stop_rule %r' % stop_rule)
480
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
 
481
586
    def leave_lock_in_place(self):
482
587
        """Tell this branch object not to release the physical lock when this
483
588
        object is unlocked.
500
605
        :param other: The branch to bind to
501
606
        :type other: Branch
502
607
        """
503
 
        raise errors.UpgradeRequired(self.base)
 
608
        raise errors.UpgradeRequired(self.user_url)
 
609
 
 
610
    def set_append_revisions_only(self, enabled):
 
611
        if not self._format.supports_set_append_revisions_only():
 
612
            raise errors.UpgradeRequired(self.user_url)
 
613
        if enabled:
 
614
            value = 'True'
 
615
        else:
 
616
            value = 'False'
 
617
        self.get_config().set_user_option('append_revisions_only', value,
 
618
            warn_masked=True)
504
619
 
505
620
    def set_reference_info(self, file_id, tree_path, branch_location):
506
621
        """Set the branch location to use for a tree reference."""
548
663
    def get_old_bound_location(self):
549
664
        """Return the URL of the branch we used to be bound to
550
665
        """
551
 
        raise errors.UpgradeRequired(self.base)
 
666
        raise errors.UpgradeRequired(self.user_url)
552
667
 
553
668
    def get_commit_builder(self, parents, config=None, timestamp=None,
554
669
                           timezone=None, committer=None, revprops=None,
632
747
            stacking.
633
748
        """
634
749
        if not self._format.supports_stacking():
635
 
            raise errors.UnstackableBranchFormat(self._format, self.base)
 
750
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
751
        # XXX: Changing from one fallback repository to another does not check
 
752
        # that all the data you need is present in the new fallback.
 
753
        # Possibly it should.
636
754
        self._check_stackable_repo()
637
755
        if not url:
638
756
            try:
640
758
            except (errors.NotStacked, errors.UnstackableBranchFormat,
641
759
                errors.UnstackableRepositoryFormat):
642
760
                return
643
 
            url = ''
644
 
            # XXX: Lock correctness - should unlock our old repo if we were
645
 
            # locked.
646
 
            # repositories don't offer an interface to remove fallback
647
 
            # repositories today; take the conceptually simpler option and just
648
 
            # reopen it.
649
 
            self.repository = self.bzrdir.find_repository()
650
 
            self.repository.lock_write()
651
 
            # for every revision reference the branch has, ensure it is pulled
652
 
            # in.
653
 
            source_repository = self._get_fallback_repository(old_url)
654
 
            for revision_id in chain([self.last_revision()],
655
 
                self.tags.get_reverse_tag_dict()):
656
 
                self.repository.fetch(source_repository, revision_id,
657
 
                    find_ghosts=True)
 
761
            self._unstack()
658
762
        else:
659
 
            self._activate_fallback_location(url, 'write')
 
763
            self._activate_fallback_location(url)
660
764
        # write this out after the repository is stacked to avoid setting a
661
765
        # stacked config that doesn't work.
662
766
        self._set_config_location('stacked_on_location', url)
663
767
 
 
768
    def _unstack(self):
 
769
        """Change a branch to be unstacked, copying data as needed.
 
770
        
 
771
        Don't call this directly, use set_stacked_on_url(None).
 
772
        """
 
773
        pb = ui.ui_factory.nested_progress_bar()
 
774
        try:
 
775
            pb.update("Unstacking")
 
776
            # The basic approach here is to fetch the tip of the branch,
 
777
            # including all available ghosts, from the existing stacked
 
778
            # repository into a new repository object without the fallbacks. 
 
779
            #
 
780
            # XXX: See <https://launchpad.net/bugs/397286> - this may not be
 
781
            # correct for CHKMap repostiories
 
782
            old_repository = self.repository
 
783
            if len(old_repository._fallback_repositories) != 1:
 
784
                raise AssertionError("can't cope with fallback repositories "
 
785
                    "of %r" % (self.repository,))
 
786
            # unlock it, including unlocking the fallback
 
787
            old_repository.unlock()
 
788
            old_repository.lock_read()
 
789
            try:
 
790
                # Repositories don't offer an interface to remove fallback
 
791
                # repositories today; take the conceptually simpler option and just
 
792
                # reopen it.  We reopen it starting from the URL so that we
 
793
                # get a separate connection for RemoteRepositories and can
 
794
                # stream from one of them to the other.  This does mean doing
 
795
                # separate SSH connection setup, but unstacking is not a
 
796
                # common operation so it's tolerable.
 
797
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
798
                new_repository = new_bzrdir.find_repository()
 
799
                self.repository = new_repository
 
800
                if self.repository._fallback_repositories:
 
801
                    raise AssertionError("didn't expect %r to have "
 
802
                        "fallback_repositories"
 
803
                        % (self.repository,))
 
804
                # this is not paired with an unlock because it's just restoring
 
805
                # the previous state; the lock's released when set_stacked_on_url
 
806
                # returns
 
807
                self.repository.lock_write()
 
808
                # XXX: If you unstack a branch while it has a working tree
 
809
                # with a pending merge, the pending-merged revisions will no
 
810
                # longer be present.  You can (probably) revert and remerge.
 
811
                #
 
812
                # XXX: This only fetches up to the tip of the repository; it
 
813
                # doesn't bring across any tags.  That's fairly consistent
 
814
                # with how branch works, but perhaps not ideal.
 
815
                self.repository.fetch(old_repository,
 
816
                    revision_id=self.last_revision(),
 
817
                    find_ghosts=True)
 
818
            finally:
 
819
                old_repository.unlock()
 
820
        finally:
 
821
            pb.finished()
664
822
 
665
823
    def _set_tags_bytes(self, bytes):
666
824
        """Mirror method for _get_tags_bytes.
702
860
        self._revision_id_to_revno_cache = None
703
861
        self._last_revision_info_cache = None
704
862
        self._merge_sorted_revisions_cache = None
 
863
        self._partial_revision_history_cache = []
 
864
        self._partial_revision_id_to_revno_cache = {}
705
865
 
706
866
    def _gen_revision_history(self):
707
867
        """Return sequence of revision hashes on to this branch.
744
904
 
745
905
    def unbind(self):
746
906
        """Older format branches cannot bind or unbind."""
747
 
        raise errors.UpgradeRequired(self.base)
748
 
 
749
 
    def set_append_revisions_only(self, enabled):
750
 
        """Older format branches are never restricted to append-only"""
751
 
        raise errors.UpgradeRequired(self.base)
 
907
        raise errors.UpgradeRequired(self.user_url)
752
908
 
753
909
    def last_revision(self):
754
910
        """Return last revision id, or NULL_REVISION."""
835
991
        except ValueError:
836
992
            raise errors.NoSuchRevision(self, revision_id)
837
993
 
 
994
    @needs_read_lock
838
995
    def get_rev_id(self, revno, history=None):
839
996
        """Find the revision id of the specified revno."""
840
997
        if revno == 0:
841
998
            return _mod_revision.NULL_REVISION
842
 
        if history is None:
843
 
            history = self.revision_history()
844
 
        if revno <= 0 or revno > len(history):
 
999
        last_revno, last_revid = self.last_revision_info()
 
1000
        if revno == last_revno:
 
1001
            return last_revid
 
1002
        if revno <= 0 or revno > last_revno:
845
1003
            raise errors.NoSuchRevision(self, revno)
846
 
        return history[revno - 1]
 
1004
        distance_from_last = last_revno - revno
 
1005
        if len(self._partial_revision_history_cache) <= distance_from_last:
 
1006
            self._extend_partial_history(distance_from_last)
 
1007
        return self._partial_revision_history_cache[distance_from_last]
847
1008
 
848
1009
    @needs_write_lock
849
1010
    def pull(self, source, overwrite=False, stop_revision=None,
867
1028
        return InterBranch.get(self, target).push(overwrite, stop_revision,
868
1029
            *args, **kwargs)
869
1030
 
 
1031
    def lossy_push(self, target, stop_revision=None):
 
1032
        """Push deltas into another branch.
 
1033
 
 
1034
        :note: This does not, like push, retain the revision ids from 
 
1035
            the source branch and will, rather than adding bzr-specific 
 
1036
            metadata, push only those semantics of the revision that can be 
 
1037
            natively represented by this branch' VCS.
 
1038
 
 
1039
        :param target: Target branch
 
1040
        :param stop_revision: Revision to push, defaults to last revision.
 
1041
        :return: BranchPushResult with an extra member revidmap: 
 
1042
            A dictionary mapping revision ids from the target branch 
 
1043
            to new revision ids in the target branch, for each 
 
1044
            revision that was pushed.
 
1045
        """
 
1046
        inter = InterBranch.get(self, target)
 
1047
        lossy_push = getattr(inter, "lossy_push", None)
 
1048
        if lossy_push is None:
 
1049
            raise errors.LossyPushToSameVCS(self, target)
 
1050
        return lossy_push(stop_revision)
 
1051
 
870
1052
    def basis_tree(self):
871
1053
        """Return `Tree` object for last revision."""
872
1054
        return self.repository.revision_tree(self.last_revision())
888
1070
        try:
889
1071
            return urlutils.join(self.base[:-1], parent)
890
1072
        except errors.InvalidURLJoin, e:
891
 
            raise errors.InaccessibleParent(parent, self.base)
 
1073
            raise errors.InaccessibleParent(parent, self.user_url)
892
1074
 
893
1075
    def _get_parent_location(self):
894
1076
        raise NotImplementedError(self._get_parent_location)
911
1093
            location = None
912
1094
        return location
913
1095
 
 
1096
    def get_child_submit_format(self):
 
1097
        """Return the preferred format of submissions to this branch."""
 
1098
        return self.get_config().get_user_option("child_submit_format")
 
1099
 
914
1100
    def get_submit_branch(self):
915
1101
        """Return the submit location of the branch.
916
1102
 
975
1161
        params = ChangeBranchTipParams(
976
1162
            self, old_revno, new_revno, old_revid, new_revid)
977
1163
        for hook in hooks:
978
 
            try:
979
 
                hook(params)
980
 
            except errors.TipChangeRejected:
981
 
                raise
982
 
            except Exception:
983
 
                exc_info = sys.exc_info()
984
 
                hook_name = Branch.hooks.get_hook_name(hook)
985
 
                raise errors.HookFailed(
986
 
                    'pre_change_branch_tip', hook_name, exc_info)
 
1164
            hook(params)
987
1165
 
988
1166
    @needs_write_lock
989
1167
    def update(self):
1038
1216
        revision_id: if not None, the revision history in the new branch will
1039
1217
                     be truncated to end with revision_id.
1040
1218
        """
 
1219
        if (repository_policy is not None and
 
1220
            repository_policy.requires_stacking()):
 
1221
            to_bzrdir._format.require_stacking(_skip_repo=True)
1041
1222
        result = to_bzrdir.create_branch()
1042
1223
        result.lock_write()
1043
1224
        try:
1064
1245
        source_revno, source_revision_id = self.last_revision_info()
1065
1246
        if revision_id is None:
1066
1247
            revno, revision_id = source_revno, source_revision_id
1067
 
        elif source_revision_id == revision_id:
1068
 
            # we know the revno without needing to walk all of history
1069
 
            revno = source_revno
1070
1248
        else:
1071
 
            # To figure out the revno for a random revision, we need to build
1072
 
            # the revision history, and count its length.
1073
 
            # We don't care about the order, just how long it is.
1074
 
            # Alternatively, we could start at the current location, and count
1075
 
            # backwards. But there is no guarantee that we will find it since
1076
 
            # it may be a merged revision.
1077
 
            revno = len(list(self.repository.iter_reverse_revision_history(
1078
 
                                                                revision_id)))
 
1249
            graph = self.repository.get_graph()
 
1250
            try:
 
1251
                revno = graph.find_distance_to_null(revision_id, 
 
1252
                    [(source_revision_id, source_revno)])
 
1253
            except errors.GhostRevisionsHaveNoRevno:
 
1254
                # Default to 1, if we can't find anything else
 
1255
                revno = 1
1079
1256
        destination.set_last_revision_info(revno, revision_id)
1080
1257
 
1081
1258
    @needs_read_lock
1115
1292
        target._set_all_reference_info(target_reference_dict)
1116
1293
 
1117
1294
    @needs_read_lock
1118
 
    def check(self):
 
1295
    def check(self, refs):
1119
1296
        """Check consistency of the branch.
1120
1297
 
1121
1298
        In particular this checks that revisions given in the revision-history
1124
1301
 
1125
1302
        Callers will typically also want to check the repository.
1126
1303
 
 
1304
        :param refs: Calculated refs for this branch as specified by
 
1305
            branch._get_check_refs()
1127
1306
        :return: A BranchCheckResult.
1128
1307
        """
1129
 
        mainline_parent_id = None
 
1308
        result = BranchCheckResult(self)
1130
1309
        last_revno, last_revision_id = self.last_revision_info()
1131
 
        real_rev_history = list(self.repository.iter_reverse_revision_history(
1132
 
                                last_revision_id))
1133
 
        real_rev_history.reverse()
1134
 
        if len(real_rev_history) != last_revno:
1135
 
            raise errors.BzrCheckError('revno does not match len(mainline)'
1136
 
                ' %s != %s' % (last_revno, len(real_rev_history)))
1137
 
        # TODO: We should probably also check that real_rev_history actually
1138
 
        #       matches self.revision_history()
1139
 
        for revision_id in real_rev_history:
1140
 
            try:
1141
 
                revision = self.repository.get_revision(revision_id)
1142
 
            except errors.NoSuchRevision, e:
1143
 
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
1144
 
                            % revision_id)
1145
 
            # In general the first entry on the revision history has no parents.
1146
 
            # But it's not illegal for it to have parents listed; this can happen
1147
 
            # in imports from Arch when the parents weren't reachable.
1148
 
            if mainline_parent_id is not None:
1149
 
                if mainline_parent_id not in revision.parent_ids:
1150
 
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
1151
 
                                        "parents of {%s}"
1152
 
                                        % (mainline_parent_id, revision_id))
1153
 
            mainline_parent_id = revision_id
1154
 
        return BranchCheckResult(self)
 
1310
        actual_revno = refs[('lefthand-distance', last_revision_id)]
 
1311
        if actual_revno != last_revno:
 
1312
            result.errors.append(errors.BzrCheckError(
 
1313
                'revno does not match len(mainline) %s != %s' % (
 
1314
                last_revno, actual_revno)))
 
1315
        # TODO: We should probably also check that self.revision_history
 
1316
        # matches the repository for older branch formats.
 
1317
        # If looking for the code that cross-checks repository parents against
 
1318
        # the iter_reverse_revision_history output, that is now a repository
 
1319
        # specific check.
 
1320
        return result
1155
1321
 
1156
1322
    def _get_checkout_format(self):
1157
1323
        """Return the most suitable metadir for a checkout of this branch.
1182
1348
        # clone call. Or something. 20090224 RBC/spiv.
1183
1349
        if revision_id is None:
1184
1350
            revision_id = self.last_revision()
1185
 
        try:
1186
 
            dir_to = self.bzrdir.clone_on_transport(to_transport,
1187
 
                revision_id=revision_id, stacked_on=stacked_on,
1188
 
                create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1189
 
        except errors.FileExists:
1190
 
            if not use_existing_dir:
1191
 
                raise
1192
 
        except errors.NoSuchFile:
1193
 
            if not create_prefix:
1194
 
                raise
 
1351
        dir_to = self.bzrdir.clone_on_transport(to_transport,
 
1352
            revision_id=revision_id, stacked_on=stacked_on,
 
1353
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1195
1354
        return dir_to.open_branch()
1196
1355
 
1197
1356
    def create_checkout(self, to_location, revision_id=None,
1216
1375
        if lightweight:
1217
1376
            format = self._get_checkout_format()
1218
1377
            checkout = format.initialize_on_transport(t)
1219
 
            from_branch = BranchReferenceFormat().initialize(checkout, self)
 
1378
            from_branch = BranchReferenceFormat().initialize(checkout, 
 
1379
                target_branch=self)
1220
1380
        else:
1221
1381
            format = self._get_checkout_format()
1222
1382
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1264
1424
    def supports_tags(self):
1265
1425
        return self._format.supports_tags()
1266
1426
 
 
1427
    def automatic_tag_name(self, revision_id):
 
1428
        """Try to automatically find the tag name for a revision.
 
1429
 
 
1430
        :param revision_id: Revision id of the revision.
 
1431
        :return: A tag name or None if no tag name could be determined.
 
1432
        """
 
1433
        for hook in Branch.hooks['automatic_tag_name']:
 
1434
            ret = hook(self, revision_id)
 
1435
            if ret is not None:
 
1436
                return ret
 
1437
        return None
 
1438
 
1267
1439
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1268
1440
                                         other_branch):
1269
1441
        """Ensure that revision_b is a descendant of revision_a.
1324
1496
    _formats = {}
1325
1497
    """The known formats."""
1326
1498
 
 
1499
    can_set_append_revisions_only = True
 
1500
 
1327
1501
    def __eq__(self, other):
1328
1502
        return self.__class__ is other.__class__
1329
1503
 
1331
1505
        return not (self == other)
1332
1506
 
1333
1507
    @classmethod
1334
 
    def find_format(klass, a_bzrdir):
 
1508
    def find_format(klass, a_bzrdir, name=None):
1335
1509
        """Return the format for the branch object in a_bzrdir."""
1336
1510
        try:
1337
 
            transport = a_bzrdir.get_branch_transport(None)
1338
 
            format_string = transport.get("format").read()
 
1511
            transport = a_bzrdir.get_branch_transport(None, name=name)
 
1512
            format_string = transport.get_bytes("format")
1339
1513
            return klass._formats[format_string]
1340
1514
        except errors.NoSuchFile:
1341
 
            raise errors.NotBranchError(path=transport.base)
 
1515
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1342
1516
        except KeyError:
1343
1517
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1344
1518
 
1380
1554
        """Return the short format description for this format."""
1381
1555
        raise NotImplementedError(self.get_format_description)
1382
1556
 
1383
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
1384
 
                           set_format=True):
 
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
 
 
1565
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
 
1566
                           lock_type='metadir', set_format=True):
1385
1567
        """Initialize a branch in a bzrdir, with specified files
1386
1568
 
1387
1569
        :param a_bzrdir: The bzrdir to initialize the branch in
1388
1570
        :param utf8_files: The files to create as a list of
1389
1571
            (filename, content) tuples
 
1572
        :param name: Name of colocated branch to create, if any
1390
1573
        :param set_format: If True, set the format with
1391
1574
            self.get_format_string.  (BzrBranch4 has its format set
1392
1575
            elsewhere)
1393
1576
        :return: a branch in this format
1394
1577
        """
1395
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1396
 
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1578
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
 
1579
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1397
1580
        lock_map = {
1398
1581
            'metadir': ('lock', lockdir.LockDir),
1399
1582
            'branch4': ('branch-lock', lockable_files.TransportLock),
1420
1603
        finally:
1421
1604
            if lock_taken:
1422
1605
                control_files.unlock()
1423
 
        return self.open(a_bzrdir, _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
1424
1609
 
1425
 
    def initialize(self, a_bzrdir):
1426
 
        """Create a branch of this format in a_bzrdir."""
 
1610
    def initialize(self, a_bzrdir, name=None):
 
1611
        """Create a branch of this format in a_bzrdir.
 
1612
        
 
1613
        :param name: Name of the colocated branch to create.
 
1614
        """
1427
1615
        raise NotImplementedError(self.initialize)
1428
1616
 
1429
1617
    def is_supported(self):
1459
1647
        """
1460
1648
        raise NotImplementedError(self.network_name)
1461
1649
 
1462
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1650
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1463
1651
        """Return the branch object for a_bzrdir
1464
1652
 
1465
1653
        :param a_bzrdir: A BzrDir that contains a branch.
 
1654
        :param name: Name of colocated branch to open
1466
1655
        :param _found: a private parameter, do not use it. It is used to
1467
1656
            indicate if format probing has already be done.
1468
1657
        :param ignore_fallbacks: when set, no fallback branches will be opened
1482
1671
    def set_default_format(klass, format):
1483
1672
        klass._default_format = format
1484
1673
 
 
1674
    def supports_set_append_revisions_only(self):
 
1675
        """True if this format supports set_append_revisions_only."""
 
1676
        return False
 
1677
 
1485
1678
    def supports_stacking(self):
1486
1679
        """True if this format records a stacked-on branch."""
1487
1680
        return False
1572
1765
            "multiple hooks installed for transform_fallback_location, "
1573
1766
            "all are called with the url returned from the previous hook."
1574
1767
            "The order is however undefined.", (1, 9), None))
 
1768
        self.create_hook(HookPoint('automatic_tag_name',
 
1769
            "Called to determine an automatic tag name for a revision."
 
1770
            "automatic_tag_name is called with (branch, revision_id) and "
 
1771
            "should return a tag name or None if no tag name could be "
 
1772
            "determined. The first non-None tag name returned will be used.",
 
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))
 
1784
 
1575
1785
 
1576
1786
 
1577
1787
# install the default hooks into the Branch class.
1616
1826
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1617
1827
 
1618
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
 
1619
1907
class BzrBranchFormat4(BranchFormat):
1620
1908
    """Bzr branch format 4.
1621
1909
 
1628
1916
        """See BranchFormat.get_format_description()."""
1629
1917
        return "Branch format 4"
1630
1918
 
1631
 
    def initialize(self, a_bzrdir):
 
1919
    def initialize(self, a_bzrdir, name=None):
1632
1920
        """Create a branch of this format in a_bzrdir."""
1633
1921
        utf8_files = [('revision-history', ''),
1634
1922
                      ('branch-name', ''),
1635
1923
                      ]
1636
 
        return self._initialize_helper(a_bzrdir, utf8_files,
 
1924
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1637
1925
                                       lock_type='branch4', set_format=False)
1638
1926
 
1639
1927
    def __init__(self):
1644
1932
        """The network name for this format is the control dirs disk label."""
1645
1933
        return self._matchingbzrdir.get_format_string()
1646
1934
 
1647
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1935
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1648
1936
        """See BranchFormat.open()."""
1649
1937
        if not _found:
1650
1938
            # we are being called directly and must probe.
1652
1940
        return BzrBranch(_format=self,
1653
1941
                         _control_files=a_bzrdir._control_files,
1654
1942
                         a_bzrdir=a_bzrdir,
 
1943
                         name=name,
1655
1944
                         _repository=a_bzrdir.open_repository())
1656
1945
 
1657
1946
    def __str__(self):
1672
1961
        """
1673
1962
        return self.get_format_string()
1674
1963
 
1675
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1964
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1676
1965
        """See BranchFormat.open()."""
1677
1966
        if not _found:
1678
 
            format = BranchFormat.find_format(a_bzrdir)
 
1967
            format = BranchFormat.find_format(a_bzrdir, name=name)
1679
1968
            if format.__class__ != self.__class__:
1680
1969
                raise AssertionError("wrong format %r found for %r" %
1681
1970
                    (format, self))
 
1971
        transport = a_bzrdir.get_branch_transport(None, name=name)
1682
1972
        try:
1683
 
            transport = a_bzrdir.get_branch_transport(None)
1684
1973
            control_files = lockable_files.LockableFiles(transport, 'lock',
1685
1974
                                                         lockdir.LockDir)
1686
1975
            return self._branch_class()(_format=self,
1687
1976
                              _control_files=control_files,
 
1977
                              name=name,
1688
1978
                              a_bzrdir=a_bzrdir,
1689
1979
                              _repository=a_bzrdir.find_repository(),
1690
1980
                              ignore_fallbacks=ignore_fallbacks)
1691
1981
        except errors.NoSuchFile:
1692
 
            raise errors.NotBranchError(path=transport.base)
 
1982
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1693
1983
 
1694
1984
    def __init__(self):
1695
1985
        super(BranchFormatMetadir, self).__init__()
1724
2014
        """See BranchFormat.get_format_description()."""
1725
2015
        return "Branch format 5"
1726
2016
 
1727
 
    def initialize(self, a_bzrdir):
 
2017
    def initialize(self, a_bzrdir, name=None):
1728
2018
        """Create a branch of this format in a_bzrdir."""
1729
2019
        utf8_files = [('revision-history', ''),
1730
2020
                      ('branch-name', ''),
1731
2021
                      ]
1732
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2022
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1733
2023
 
1734
2024
    def supports_tags(self):
1735
2025
        return False
1757
2047
        """See BranchFormat.get_format_description()."""
1758
2048
        return "Branch format 6"
1759
2049
 
1760
 
    def initialize(self, a_bzrdir):
 
2050
    def initialize(self, a_bzrdir, name=None):
1761
2051
        """Create a branch of this format in a_bzrdir."""
1762
2052
        utf8_files = [('last-revision', '0 null:\n'),
1763
2053
                      ('branch.conf', ''),
1764
2054
                      ('tags', ''),
1765
2055
                      ]
1766
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2056
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1767
2057
 
1768
2058
    def make_tags(self, branch):
1769
2059
        """See bzrlib.branch.BranchFormat.make_tags()."""
1770
2060
        return BasicTags(branch)
1771
2061
 
 
2062
    def supports_set_append_revisions_only(self):
 
2063
        return True
1772
2064
 
1773
2065
 
1774
2066
class BzrBranchFormat8(BranchFormatMetadir):
1785
2077
        """See BranchFormat.get_format_description()."""
1786
2078
        return "Branch format 8"
1787
2079
 
1788
 
    def initialize(self, a_bzrdir):
 
2080
    def initialize(self, a_bzrdir, name=None):
1789
2081
        """Create a branch of this format in a_bzrdir."""
1790
2082
        utf8_files = [('last-revision', '0 null:\n'),
1791
2083
                      ('branch.conf', ''),
1792
2084
                      ('tags', ''),
1793
2085
                      ('references', '')
1794
2086
                      ]
1795
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2087
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1796
2088
 
1797
2089
    def __init__(self):
1798
2090
        super(BzrBranchFormat8, self).__init__()
1803
2095
        """See bzrlib.branch.BranchFormat.make_tags()."""
1804
2096
        return BasicTags(branch)
1805
2097
 
 
2098
    def supports_set_append_revisions_only(self):
 
2099
        return True
 
2100
 
1806
2101
    def supports_stacking(self):
1807
2102
        return True
1808
2103
 
1818
2113
    This format was introduced in bzr 1.6.
1819
2114
    """
1820
2115
 
1821
 
    def initialize(self, a_bzrdir):
 
2116
    def initialize(self, a_bzrdir, name=None):
1822
2117
        """Create a branch of this format in a_bzrdir."""
1823
2118
        utf8_files = [('last-revision', '0 null:\n'),
1824
2119
                      ('branch.conf', ''),
1825
2120
                      ('tags', ''),
1826
2121
                      ]
1827
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2122
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1828
2123
 
1829
2124
    def _branch_class(self):
1830
2125
        return BzrBranch7
1837
2132
        """See BranchFormat.get_format_description()."""
1838
2133
        return "Branch format 7"
1839
2134
 
 
2135
    def supports_set_append_revisions_only(self):
 
2136
        return True
 
2137
 
1840
2138
    supports_reference_locations = False
1841
2139
 
1842
2140
 
1862
2160
    def get_reference(self, a_bzrdir):
1863
2161
        """See BranchFormat.get_reference()."""
1864
2162
        transport = a_bzrdir.get_branch_transport(None)
1865
 
        return transport.get('location').read()
 
2163
        return transport.get_bytes('location')
1866
2164
 
1867
2165
    def set_reference(self, a_bzrdir, to_branch):
1868
2166
        """See BranchFormat.set_reference()."""
1869
2167
        transport = a_bzrdir.get_branch_transport(None)
1870
2168
        location = transport.put_bytes('location', to_branch.base)
1871
2169
 
1872
 
    def initialize(self, a_bzrdir, target_branch=None):
 
2170
    def initialize(self, a_bzrdir, name=None, target_branch=None):
1873
2171
        """Create a branch of this format in a_bzrdir."""
1874
2172
        if target_branch is None:
1875
2173
            # this format does not implement branch itself, thus the implicit
1876
2174
            # creation contract must see it as uninitializable
1877
2175
            raise errors.UninitializableFormat(self)
1878
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1879
 
        branch_transport = a_bzrdir.get_branch_transport(self)
 
2176
        mutter('creating branch reference in %s', a_bzrdir.user_url)
 
2177
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1880
2178
        branch_transport.put_bytes('location',
1881
 
            target_branch.bzrdir.root_transport.base)
 
2179
            target_branch.bzrdir.user_url)
1882
2180
        branch_transport.put_bytes('format', self.get_format_string())
1883
 
        return self.open(
1884
 
            a_bzrdir, _found=True,
 
2181
        branch = self.open(
 
2182
            a_bzrdir, name, _found=True,
1885
2183
            possible_transports=[target_branch.bzrdir.root_transport])
 
2184
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2185
        return branch
1886
2186
 
1887
2187
    def __init__(self):
1888
2188
        super(BranchReferenceFormat, self).__init__()
1894
2194
        def clone(to_bzrdir, revision_id=None,
1895
2195
            repository_policy=None):
1896
2196
            """See Branch.clone()."""
1897
 
            return format.initialize(to_bzrdir, a_branch)
 
2197
            return format.initialize(to_bzrdir, target_branch=a_branch)
1898
2198
            # cannot obey revision_id limits when cloning a reference ...
1899
2199
            # FIXME RBC 20060210 either nuke revision_id for clone, or
1900
2200
            # emit some sort of warning/error to the caller ?!
1901
2201
        return clone
1902
2202
 
1903
 
    def open(self, a_bzrdir, _found=False, location=None,
 
2203
    def open(self, a_bzrdir, name=None, _found=False, location=None,
1904
2204
             possible_transports=None, ignore_fallbacks=False):
1905
2205
        """Return the branch that the branch reference in a_bzrdir points at.
1906
2206
 
1907
2207
        :param a_bzrdir: A BzrDir that contains a branch.
 
2208
        :param name: Name of colocated branch to open, if any
1908
2209
        :param _found: a private parameter, do not use it. It is used to
1909
2210
            indicate if format probing has already be done.
1910
2211
        :param ignore_fallbacks: when set, no fallback branches will be opened
1915
2216
        :param possible_transports: An optional reusable transports list.
1916
2217
        """
1917
2218
        if not _found:
1918
 
            format = BranchFormat.find_format(a_bzrdir)
 
2219
            format = BranchFormat.find_format(a_bzrdir, name=name)
1919
2220
            if format.__class__ != self.__class__:
1920
2221
                raise AssertionError("wrong format %r found for %r" %
1921
2222
                    (format, self))
1923
2224
            location = self.get_reference(a_bzrdir)
1924
2225
        real_bzrdir = bzrdir.BzrDir.open(
1925
2226
            location, possible_transports=possible_transports)
1926
 
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2227
        result = real_bzrdir.open_branch(name=name, 
 
2228
            ignore_fallbacks=ignore_fallbacks)
1927
2229
        # this changes the behaviour of result.clone to create a new reference
1928
2230
        # rather than a copy of the content of the branch.
1929
2231
        # I did not use a proxy object because that needs much more extensive
1956
2258
BranchFormat.register_format(__format6)
1957
2259
BranchFormat.register_format(__format7)
1958
2260
BranchFormat.register_format(__format8)
1959
 
BranchFormat.set_default_format(__format6)
 
2261
BranchFormat.set_default_format(__format7)
1960
2262
_legacy_formats = [BzrBranchFormat4(),
1961
2263
    ]
1962
2264
network_format_registry.register(
1963
2265
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
1964
2266
 
1965
2267
 
1966
 
class BzrBranch(Branch):
 
2268
class BzrBranch(Branch, _RelockDebugMixin):
1967
2269
    """A branch stored in the actual filesystem.
1968
2270
 
1969
2271
    Note that it's "local" in the context of the filesystem; it doesn't
1975
2277
    :ivar repository: Repository for this branch.
1976
2278
    :ivar base: The url of the base directory for this branch; the one
1977
2279
        containing the .bzr directory.
 
2280
    :ivar name: Optional colocated branch name as it exists in the control
 
2281
        directory.
1978
2282
    """
1979
2283
 
1980
2284
    def __init__(self, _format=None,
1981
 
                 _control_files=None, a_bzrdir=None, _repository=None,
1982
 
                 ignore_fallbacks=False):
 
2285
                 _control_files=None, a_bzrdir=None, name=None,
 
2286
                 _repository=None, ignore_fallbacks=False):
1983
2287
        """Create new branch object at a particular location."""
1984
2288
        if a_bzrdir is None:
1985
2289
            raise ValueError('a_bzrdir must be supplied')
1986
2290
        else:
1987
2291
            self.bzrdir = a_bzrdir
1988
2292
        self._base = self.bzrdir.transport.clone('..').base
 
2293
        self.name = name
1989
2294
        # XXX: We should be able to just do
1990
2295
        #   self.base = self.bzrdir.root_transport.base
1991
2296
        # but this does not quite work yet -- mbp 20080522
1998
2303
        Branch.__init__(self)
1999
2304
 
2000
2305
    def __str__(self):
2001
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
2306
        if self.name is None:
 
2307
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
 
2308
        else:
 
2309
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
 
2310
                self.name)
2002
2311
 
2003
2312
    __repr__ = __str__
2004
2313
 
2015
2324
        return self.control_files.is_locked()
2016
2325
 
2017
2326
    def lock_write(self, token=None):
 
2327
        if not self.is_locked():
 
2328
            self._note_lock('w')
2018
2329
        # All-in-one needs to always unlock/lock.
2019
2330
        repo_control = getattr(self.repository, 'control_files', None)
2020
2331
        if self.control_files == repo_control or not self.is_locked():
 
2332
            self.repository._warn_if_deprecated(self)
2021
2333
            self.repository.lock_write()
2022
2334
            took_lock = True
2023
2335
        else:
2030
2342
            raise
2031
2343
 
2032
2344
    def lock_read(self):
 
2345
        if not self.is_locked():
 
2346
            self._note_lock('r')
2033
2347
        # All-in-one needs to always unlock/lock.
2034
2348
        repo_control = getattr(self.repository, 'control_files', None)
2035
2349
        if self.control_files == repo_control or not self.is_locked():
 
2350
            self.repository._warn_if_deprecated(self)
2036
2351
            self.repository.lock_read()
2037
2352
            took_lock = True
2038
2353
        else:
2044
2359
                self.repository.unlock()
2045
2360
            raise
2046
2361
 
 
2362
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2047
2363
    def unlock(self):
2048
2364
        try:
2049
2365
            self.control_files.unlock()
2212
2528
        return result
2213
2529
 
2214
2530
    def get_stacked_on_url(self):
2215
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2531
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2216
2532
 
2217
2533
    def set_push_location(self, location):
2218
2534
        """See Branch.set_push_location."""
2345
2661
                    raise AssertionError(
2346
2662
                        "'transform_fallback_location' hook %s returned "
2347
2663
                        "None, not a URL." % hook_name)
2348
 
            self._activate_fallback_location(url, None)
 
2664
            self._activate_fallback_location(url)
2349
2665
 
2350
2666
    def __init__(self, *args, **kwargs):
2351
2667
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2352
2668
        super(BzrBranch8, self).__init__(*args, **kwargs)
2353
2669
        self._last_revision_info_cache = None
2354
 
        self._partial_revision_history_cache = []
2355
2670
        self._reference_info = None
2356
2671
 
2357
2672
    def _clear_cached_state(self):
2358
2673
        super(BzrBranch8, self)._clear_cached_state()
2359
2674
        self._last_revision_info_cache = None
2360
 
        self._partial_revision_history_cache = []
2361
2675
        self._reference_info = None
2362
2676
 
2363
2677
    def _last_revision_info(self):
2410
2724
        if _mod_revision.is_null(last_revision):
2411
2725
            return
2412
2726
        if last_revision not in self._lefthand_history(revision_id):
2413
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2727
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
2414
2728
 
2415
2729
    def _gen_revision_history(self):
2416
2730
        """Generate the revision history from last revision
2419
2733
        self._extend_partial_history(stop_index=last_revno-1)
2420
2734
        return list(reversed(self._partial_revision_history_cache))
2421
2735
 
2422
 
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
2423
 
        """Extend the partial history to include a given index
2424
 
 
2425
 
        If a stop_index is supplied, stop when that index has been reached.
2426
 
        If a stop_revision is supplied, stop when that revision is
2427
 
        encountered.  Otherwise, stop when the beginning of history is
2428
 
        reached.
2429
 
 
2430
 
        :param stop_index: The index which should be present.  When it is
2431
 
            present, history extension will stop.
2432
 
        :param revision_id: The revision id which should be present.  When
2433
 
            it is encountered, history extension will stop.
2434
 
        """
2435
 
        repo = self.repository
2436
 
        if len(self._partial_revision_history_cache) == 0:
2437
 
            iterator = repo.iter_reverse_revision_history(self.last_revision())
2438
 
        else:
2439
 
            start_revision = self._partial_revision_history_cache[-1]
2440
 
            iterator = repo.iter_reverse_revision_history(start_revision)
2441
 
            #skip the last revision in the list
2442
 
            next_revision = iterator.next()
2443
 
        for revision_id in iterator:
2444
 
            self._partial_revision_history_cache.append(revision_id)
2445
 
            if (stop_index is not None and
2446
 
                len(self._partial_revision_history_cache) > stop_index):
2447
 
                break
2448
 
            if revision_id == stop_revision:
2449
 
                break
2450
 
 
2451
2736
    def _write_revision_history(self, history):
2452
2737
        """Factored out of set_revision_history.
2453
2738
 
2545
2830
        if branch_location is None:
2546
2831
            return Branch.reference_parent(self, file_id, path,
2547
2832
                                           possible_transports)
2548
 
        branch_location = urlutils.join(self.base, branch_location)
 
2833
        branch_location = urlutils.join(self.user_url, branch_location)
2549
2834
        return Branch.open(branch_location,
2550
2835
                           possible_transports=possible_transports)
2551
2836
 
2596
2881
            raise errors.NotStacked(self)
2597
2882
        return stacked_url
2598
2883
 
2599
 
    def set_append_revisions_only(self, enabled):
2600
 
        if enabled:
2601
 
            value = 'True'
2602
 
        else:
2603
 
            value = 'False'
2604
 
        self.get_config().set_user_option('append_revisions_only', value,
2605
 
            warn_masked=True)
2606
 
 
2607
2884
    def _get_append_revisions_only(self):
2608
 
        value = self.get_config().get_user_option('append_revisions_only')
2609
 
        return value == 'True'
 
2885
        return self.get_config(
 
2886
            ).get_user_option_as_bool('append_revisions_only')
2610
2887
 
2611
2888
    @needs_write_lock
2612
2889
    def generate_revision_history(self, revision_id, last_rev=None,
2674
2951
    """
2675
2952
 
2676
2953
    def get_stacked_on_url(self):
2677
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2954
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2678
2955
 
2679
2956
 
2680
2957
######################################################################
2759
3036
 
2760
3037
    def __init__(self, branch):
2761
3038
        self.branch = branch
 
3039
        self.errors = []
2762
3040
 
2763
3041
    def report_results(self, verbose):
2764
3042
        """Report the check results via trace.note.
2766
3044
        :param verbose: Requests more detailed display of what was checked,
2767
3045
            if any.
2768
3046
        """
2769
 
        note('checked branch %s format %s',
2770
 
             self.branch.base,
2771
 
             self.branch._format)
 
3047
        note('checked branch %s format %s', self.branch.user_url,
 
3048
            self.branch._format)
 
3049
        for error in self.errors:
 
3050
            note('found error:%s', error)
2772
3051
 
2773
3052
 
2774
3053
class Converter5to6(object):
2869
3148
    @staticmethod
2870
3149
    def _get_branch_formats_to_test():
2871
3150
        """Return a tuple with the Branch formats to use when testing."""
2872
 
        raise NotImplementedError(self._get_branch_formats_to_test)
 
3151
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
2873
3152
 
2874
3153
    def pull(self, overwrite=False, stop_revision=None,
2875
3154
             possible_transports=None, local=False):
3030
3309
                _override_hook_source_branch=_override_hook_source_branch)
3031
3310
        finally:
3032
3311
            self.source.unlock()
3033
 
        return result
3034
3312
 
3035
3313
    def _push_with_bound_branches(self, overwrite, stop_revision,
3036
3314
            _override_hook_source_branch=None):
3101
3379
        if local and not bound_location:
3102
3380
            raise errors.LocalRequiresBoundBranch()
3103
3381
        master_branch = None
3104
 
        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:
3105
3383
            # not pulling from master, so we need to update master.
3106
3384
            master_branch = self.target.get_master_branch(possible_transports)
3107
3385
            master_branch.lock_write()