← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Robert Collins
  • Date: 2010-05-06 07:48:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506074822-0bsgf2j4h8jx0xkk
Added ``bzrlib.tests.matchers`` as a place to put matchers, along with
our first in-tree matcher. See the module docstring for details.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
 
18
from cStringIO import StringIO
18
19
import sys
19
20
 
20
21
from bzrlib.lazy_import import lazy_import
30
31
        lockable_files,
31
32
        repository,
32
33
        revision as _mod_revision,
 
34
        rio,
33
35
        symbol_versioning,
34
36
        transport,
35
37
        tsort,
44
46
    )
45
47
""")
46
48
 
47
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
49
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
48
50
from bzrlib.hooks import HookPoint, Hooks
49
51
from bzrlib.inter import InterObject
 
52
from bzrlib.lock import _RelockDebugMixin
50
53
from bzrlib import registry
51
54
from bzrlib.symbol_versioning import (
52
55
    deprecated_in,
60
63
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
61
64
 
62
65
 
63
 
# TODO: Maybe include checks for common corruption of newlines, etc?
64
 
 
65
 
# TODO: Some operations like log might retrieve the same revisions
66
 
# repeatedly to calculate deltas.  We could perhaps have a weakref
67
 
# cache in memory to make this faster.  In general anything can be
68
 
# cached in memory between lock and unlock operations. .. nb thats
69
 
# what the transaction identity map provides
70
 
 
71
 
 
72
 
######################################################################
73
 
# branch objects
74
 
 
75
 
class Branch(object):
 
66
class Branch(bzrdir.ControlComponent):
76
67
    """Branch holding a history of revisions.
77
68
 
78
 
    base
79
 
        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.
80
72
 
81
73
    hooks: An instance of BranchHooks.
82
74
    """
84
76
    # - RBC 20060112
85
77
    base = None
86
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
 
87
87
    def __init__(self, *ignored, **ignored_too):
88
88
        self.tags = self._format.make_tags(self)
89
89
        self._revision_history_cache = None
90
90
        self._revision_id_to_revno_cache = None
91
91
        self._partial_revision_id_to_revno_cache = {}
 
92
        self._partial_revision_history_cache = []
92
93
        self._last_revision_info_cache = None
93
94
        self._merge_sorted_revisions_cache = None
94
95
        self._open_hook()
101
102
 
102
103
    def _activate_fallback_location(self, url):
103
104
        """Activate the branch/repository from url as a fallback repository."""
104
 
        self.repository.add_fallback_repository(
105
 
            self._get_fallback_repository(url))
 
105
        repo = self._get_fallback_repository(url)
 
106
        if repo.has_same_location(self.repository):
 
107
            raise errors.UnstackableLocationError(self.user_url, url)
 
108
        self.repository.add_fallback_repository(repo)
106
109
 
107
110
    def break_lock(self):
108
111
        """Break a lock if one is present from another instance.
123
126
            raise errors.UnstackableRepositoryFormat(self.repository._format,
124
127
                self.repository.base)
125
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
 
126
158
    @staticmethod
127
159
    def open(base, _unsupported=False, possible_transports=None):
128
160
        """Open the branch rooted at base.
132
164
        """
133
165
        control = bzrdir.BzrDir.open(base, _unsupported,
134
166
                                     possible_transports=possible_transports)
135
 
        return control.open_branch(_unsupported)
 
167
        return control.open_branch(unsupported=_unsupported)
136
168
 
137
169
    @staticmethod
138
 
    def open_from_transport(transport, _unsupported=False):
 
170
    def open_from_transport(transport, name=None, _unsupported=False):
139
171
        """Open the branch rooted at transport"""
140
172
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
141
 
        return control.open_branch(_unsupported)
 
173
        return control.open_branch(name=name, unsupported=_unsupported)
142
174
 
143
175
    @staticmethod
144
176
    def open_containing(url, possible_transports=None):
182
214
    def _get_fallback_repository(self, url):
183
215
        """Get the repository we fallback to at url."""
184
216
        url = urlutils.join(self.base, url)
185
 
        a_bzrdir = bzrdir.BzrDir.open(url,
 
217
        a_branch = Branch.open(url,
186
218
            possible_transports=[self.bzrdir.root_transport])
187
 
        return a_bzrdir.open_branch().repository
 
219
        return a_branch.repository
188
220
 
189
221
    def _get_tags_bytes(self):
190
222
        """Get the bytes of a serialised tags dict.
385
417
            * 'include' - the stop revision is the last item in the result
386
418
            * 'with-merges' - include the stop revision and all of its
387
419
              merged revisions in the result
 
420
            * 'with-merges-without-common-ancestry' - filter out revisions 
 
421
              that are in both ancestries
388
422
        :param direction: either 'reverse' or 'forward':
389
423
            * reverse means return the start_revision_id first, i.e.
390
424
              start at the most recent revision and go backwards in history
412
446
        # start_revision_id.
413
447
        if self._merge_sorted_revisions_cache is None:
414
448
            last_revision = self.last_revision()
415
 
            graph = self.repository.get_graph()
416
 
            parent_map = dict(((key, value) for key, value in
417
 
                     graph.iter_ancestry([last_revision]) if value is not None))
418
 
            revision_graph = repository._strip_NULL_ghosts(parent_map)
419
 
            revs = tsort.merge_sort(revision_graph, last_revision, None,
420
 
                generate_revno=True)
421
 
            # Drop the sequence # before caching
422
 
            self._merge_sorted_revisions_cache = [r[1:] for r in revs]
423
 
 
 
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)
424
453
        filtered = self._filter_merge_sorted_revisions(
425
454
            self._merge_sorted_revisions_cache, start_revision_id,
426
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)
427
459
        if direction == 'reverse':
428
460
            return filtered
429
461
        if direction == 'forward':
436
468
        """Iterate over an inclusive range of sorted revisions."""
437
469
        rev_iter = iter(merge_sorted_revisions)
438
470
        if start_revision_id is not None:
439
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
471
            for node in rev_iter:
 
472
                rev_id = node.key[-1]
440
473
                if rev_id != start_revision_id:
441
474
                    continue
442
475
                else:
443
476
                    # The decision to include the start or not
444
477
                    # depends on the stop_rule if a stop is provided
445
 
                    rev_iter = chain(
446
 
                        iter([(rev_id, depth, revno, end_of_merge)]),
447
 
                        rev_iter)
 
478
                    # so pop this node back into the iterator
 
479
                    rev_iter = chain(iter([node]), rev_iter)
448
480
                    break
449
481
        if stop_revision_id is None:
450
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
451
 
                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)
452
487
        elif stop_rule == 'exclude':
453
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
488
            for node in rev_iter:
 
489
                rev_id = node.key[-1]
454
490
                if rev_id == stop_revision_id:
455
491
                    return
456
 
                yield rev_id, depth, revno, end_of_merge
 
492
                yield (rev_id, node.merge_depth, node.revno,
 
493
                       node.end_of_merge)
457
494
        elif stop_rule == 'include':
458
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
459
 
                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)
460
499
                if rev_id == stop_revision_id:
461
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)
462
513
        elif stop_rule == 'with-merges':
463
514
            stop_rev = self.repository.get_revision(stop_revision_id)
464
515
            if stop_rev.parent_ids:
465
516
                left_parent = stop_rev.parent_ids[0]
466
517
            else:
467
518
                left_parent = _mod_revision.NULL_REVISION
468
 
            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]
469
525
                if rev_id == left_parent:
 
526
                    # reached the left parent after the stop_revision
470
527
                    return
471
 
                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)
472
538
        else:
473
539
            raise ValueError('invalid stop_rule %r' % stop_rule)
474
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
 
475
586
    def leave_lock_in_place(self):
476
587
        """Tell this branch object not to release the physical lock when this
477
588
        object is unlocked.
494
605
        :param other: The branch to bind to
495
606
        :type other: Branch
496
607
        """
497
 
        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)
 
619
 
 
620
    def set_reference_info(self, file_id, tree_path, branch_location):
 
621
        """Set the branch location to use for a tree reference."""
 
622
        raise errors.UnsupportedOperation(self.set_reference_info, self)
 
623
 
 
624
    def get_reference_info(self, file_id):
 
625
        """Get the tree_path and branch_location for a tree reference."""
 
626
        raise errors.UnsupportedOperation(self.get_reference_info, self)
498
627
 
499
628
    @needs_write_lock
500
629
    def fetch(self, from_branch, last_revision=None, pb=None):
534
663
    def get_old_bound_location(self):
535
664
        """Return the URL of the branch we used to be bound to
536
665
        """
537
 
        raise errors.UpgradeRequired(self.base)
 
666
        raise errors.UpgradeRequired(self.user_url)
538
667
 
539
668
    def get_commit_builder(self, parents, config=None, timestamp=None,
540
669
                           timezone=None, committer=None, revprops=None,
590
719
    def set_revision_history(self, rev_history):
591
720
        raise NotImplementedError(self.set_revision_history)
592
721
 
 
722
    @needs_write_lock
 
723
    def set_parent(self, url):
 
724
        """See Branch.set_parent."""
 
725
        # TODO: Maybe delete old location files?
 
726
        # URLs should never be unicode, even on the local fs,
 
727
        # FIXUP this and get_parent in a future branch format bump:
 
728
        # read and rewrite the file. RBC 20060125
 
729
        if url is not None:
 
730
            if isinstance(url, unicode):
 
731
                try:
 
732
                    url = url.encode('ascii')
 
733
                except UnicodeEncodeError:
 
734
                    raise errors.InvalidURL(url,
 
735
                        "Urls must be 7-bit ascii, "
 
736
                        "use bzrlib.urlutils.escape")
 
737
            url = urlutils.relative_url(self.base, url)
 
738
        self._set_parent_location(url)
 
739
 
 
740
    @needs_write_lock
593
741
    def set_stacked_on_url(self, url):
594
742
        """Set the URL this branch is stacked against.
595
743
 
599
747
            stacking.
600
748
        """
601
749
        if not self._format.supports_stacking():
602
 
            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.
603
754
        self._check_stackable_repo()
604
755
        if not url:
605
756
            try:
607
758
            except (errors.NotStacked, errors.UnstackableBranchFormat,
608
759
                errors.UnstackableRepositoryFormat):
609
760
                return
610
 
            url = ''
611
 
            # repositories don't offer an interface to remove fallback
612
 
            # repositories today; take the conceptually simpler option and just
613
 
            # reopen it.
614
 
            self.repository = self.bzrdir.find_repository()
615
 
            # for every revision reference the branch has, ensure it is pulled
616
 
            # in.
617
 
            source_repository = self._get_fallback_repository(old_url)
618
 
            for revision_id in chain([self.last_revision()],
619
 
                self.tags.get_reverse_tag_dict()):
620
 
                self.repository.fetch(source_repository, revision_id,
621
 
                    find_ghosts=True)
 
761
            self._unstack()
622
762
        else:
623
763
            self._activate_fallback_location(url)
624
764
        # write this out after the repository is stacked to avoid setting a
625
765
        # stacked config that doesn't work.
626
766
        self._set_config_location('stacked_on_location', url)
627
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()
628
822
 
629
823
    def _set_tags_bytes(self, bytes):
630
824
        """Mirror method for _get_tags_bytes.
666
860
        self._revision_id_to_revno_cache = None
667
861
        self._last_revision_info_cache = None
668
862
        self._merge_sorted_revisions_cache = None
 
863
        self._partial_revision_history_cache = []
 
864
        self._partial_revision_id_to_revno_cache = {}
669
865
 
670
866
    def _gen_revision_history(self):
671
867
        """Return sequence of revision hashes on to this branch.
708
904
 
709
905
    def unbind(self):
710
906
        """Older format branches cannot bind or unbind."""
711
 
        raise errors.UpgradeRequired(self.base)
712
 
 
713
 
    def set_append_revisions_only(self, enabled):
714
 
        """Older format branches are never restricted to append-only"""
715
 
        raise errors.UpgradeRequired(self.base)
 
907
        raise errors.UpgradeRequired(self.user_url)
716
908
 
717
909
    def last_revision(self):
718
910
        """Return last revision id, or NULL_REVISION."""
799
991
        except ValueError:
800
992
            raise errors.NoSuchRevision(self, revision_id)
801
993
 
 
994
    @needs_read_lock
802
995
    def get_rev_id(self, revno, history=None):
803
996
        """Find the revision id of the specified revno."""
804
997
        if revno == 0:
805
998
            return _mod_revision.NULL_REVISION
806
 
        if history is None:
807
 
            history = self.revision_history()
808
 
        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:
809
1003
            raise errors.NoSuchRevision(self, revno)
810
 
        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]
811
1008
 
 
1009
    @needs_write_lock
812
1010
    def pull(self, source, overwrite=False, stop_revision=None,
813
 
             possible_transports=None, _override_hook_target=None):
 
1011
             possible_transports=None, *args, **kwargs):
814
1012
        """Mirror source into this branch.
815
1013
 
816
1014
        This branch is considered to be 'local', having low latency.
817
1015
 
818
1016
        :returns: PullResult instance
819
1017
        """
820
 
        raise NotImplementedError(self.pull)
 
1018
        return InterBranch.get(source, self).pull(overwrite=overwrite,
 
1019
            stop_revision=stop_revision,
 
1020
            possible_transports=possible_transports, *args, **kwargs)
821
1021
 
822
 
    def push(self, target, overwrite=False, stop_revision=None):
 
1022
    def push(self, target, overwrite=False, stop_revision=None, *args,
 
1023
        **kwargs):
823
1024
        """Mirror this branch into target.
824
1025
 
825
1026
        This branch is considered to be 'local', having low latency.
826
1027
        """
827
 
        raise NotImplementedError(self.push)
 
1028
        return InterBranch.get(self, target).push(overwrite, stop_revision,
 
1029
            *args, **kwargs)
 
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)
828
1051
 
829
1052
    def basis_tree(self):
830
1053
        """Return `Tree` object for last revision."""
847
1070
        try:
848
1071
            return urlutils.join(self.base[:-1], parent)
849
1072
        except errors.InvalidURLJoin, e:
850
 
            raise errors.InaccessibleParent(parent, self.base)
 
1073
            raise errors.InaccessibleParent(parent, self.user_url)
851
1074
 
852
1075
    def _get_parent_location(self):
853
1076
        raise NotImplementedError(self._get_parent_location)
870
1093
            location = None
871
1094
        return location
872
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
 
873
1100
    def get_submit_branch(self):
874
1101
        """Return the submit location of the branch.
875
1102
 
934
1161
        params = ChangeBranchTipParams(
935
1162
            self, old_revno, new_revno, old_revid, new_revid)
936
1163
        for hook in hooks:
937
 
            try:
938
 
                hook(params)
939
 
            except errors.TipChangeRejected:
940
 
                raise
941
 
            except Exception:
942
 
                exc_info = sys.exc_info()
943
 
                hook_name = Branch.hooks.get_hook_name(hook)
944
 
                raise errors.HookFailed(
945
 
                    'pre_change_branch_tip', hook_name, exc_info)
946
 
 
947
 
    def set_parent(self, url):
948
 
        raise NotImplementedError(self.set_parent)
 
1164
            hook(params)
949
1165
 
950
1166
    @needs_write_lock
951
1167
    def update(self):
982
1198
                     be truncated to end with revision_id.
983
1199
        """
984
1200
        result = to_bzrdir.create_branch()
985
 
        if repository_policy is not None:
986
 
            repository_policy.configure_branch(result)
987
 
        self.copy_content_into(result, revision_id=revision_id)
988
 
        return  result
 
1201
        result.lock_write()
 
1202
        try:
 
1203
            if repository_policy is not None:
 
1204
                repository_policy.configure_branch(result)
 
1205
            self.copy_content_into(result, revision_id=revision_id)
 
1206
        finally:
 
1207
            result.unlock()
 
1208
        return result
989
1209
 
990
1210
    @needs_read_lock
991
1211
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
996
1216
        revision_id: if not None, the revision history in the new branch will
997
1217
                     be truncated to end with revision_id.
998
1218
        """
 
1219
        if (repository_policy is not None and
 
1220
            repository_policy.requires_stacking()):
 
1221
            to_bzrdir._format.require_stacking(_skip_repo=True)
999
1222
        result = to_bzrdir.create_branch()
1000
 
        if repository_policy is not None:
1001
 
            repository_policy.configure_branch(result)
1002
 
        self.copy_content_into(result, revision_id=revision_id)
1003
 
        result.set_parent(self.bzrdir.root_transport.base)
 
1223
        result.lock_write()
 
1224
        try:
 
1225
            if repository_policy is not None:
 
1226
                repository_policy.configure_branch(result)
 
1227
            self.copy_content_into(result, revision_id=revision_id)
 
1228
            result.set_parent(self.bzrdir.root_transport.base)
 
1229
        finally:
 
1230
            result.unlock()
1004
1231
        return result
1005
1232
 
1006
1233
    def _synchronize_history(self, destination, revision_id):
1018
1245
        source_revno, source_revision_id = self.last_revision_info()
1019
1246
        if revision_id is None:
1020
1247
            revno, revision_id = source_revno, source_revision_id
1021
 
        elif source_revision_id == revision_id:
1022
 
            # we know the revno without needing to walk all of history
1023
 
            revno = source_revno
1024
1248
        else:
1025
 
            # To figure out the revno for a random revision, we need to build
1026
 
            # the revision history, and count its length.
1027
 
            # We don't care about the order, just how long it is.
1028
 
            # Alternatively, we could start at the current location, and count
1029
 
            # backwards. But there is no guarantee that we will find it since
1030
 
            # it may be a merged revision.
1031
 
            revno = len(list(self.repository.iter_reverse_revision_history(
1032
 
                                                                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
1033
1256
        destination.set_last_revision_info(revno, revision_id)
1034
1257
 
1035
1258
    @needs_read_lock
1039
1262
        revision_id: if not None, the revision history in the new branch will
1040
1263
                     be truncated to end with revision_id.
1041
1264
        """
 
1265
        self.update_references(destination)
1042
1266
        self._synchronize_history(destination, revision_id)
1043
1267
        try:
1044
1268
            parent = self.get_parent()
1050
1274
        if self._push_should_merge_tags():
1051
1275
            self.tags.merge_to(destination.tags)
1052
1276
 
 
1277
    def update_references(self, target):
 
1278
        if not getattr(self._format, 'supports_reference_locations', False):
 
1279
            return
 
1280
        reference_dict = self._get_all_reference_info()
 
1281
        if len(reference_dict) == 0:
 
1282
            return
 
1283
        old_base = self.base
 
1284
        new_base = target.base
 
1285
        target_reference_dict = target._get_all_reference_info()
 
1286
        for file_id, (tree_path, branch_location) in (
 
1287
            reference_dict.items()):
 
1288
            branch_location = urlutils.rebase_url(branch_location,
 
1289
                                                  old_base, new_base)
 
1290
            target_reference_dict.setdefault(
 
1291
                file_id, (tree_path, branch_location))
 
1292
        target._set_all_reference_info(target_reference_dict)
 
1293
 
1053
1294
    @needs_read_lock
1054
 
    def check(self):
 
1295
    def check(self, refs):
1055
1296
        """Check consistency of the branch.
1056
1297
 
1057
1298
        In particular this checks that revisions given in the revision-history
1060
1301
 
1061
1302
        Callers will typically also want to check the repository.
1062
1303
 
 
1304
        :param refs: Calculated refs for this branch as specified by
 
1305
            branch._get_check_refs()
1063
1306
        :return: A BranchCheckResult.
1064
1307
        """
1065
 
        mainline_parent_id = None
 
1308
        result = BranchCheckResult(self)
1066
1309
        last_revno, last_revision_id = self.last_revision_info()
1067
 
        real_rev_history = list(self.repository.iter_reverse_revision_history(
1068
 
                                last_revision_id))
1069
 
        real_rev_history.reverse()
1070
 
        if len(real_rev_history) != last_revno:
1071
 
            raise errors.BzrCheckError('revno does not match len(mainline)'
1072
 
                ' %s != %s' % (last_revno, len(real_rev_history)))
1073
 
        # TODO: We should probably also check that real_rev_history actually
1074
 
        #       matches self.revision_history()
1075
 
        for revision_id in real_rev_history:
1076
 
            try:
1077
 
                revision = self.repository.get_revision(revision_id)
1078
 
            except errors.NoSuchRevision, e:
1079
 
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
1080
 
                            % revision_id)
1081
 
            # In general the first entry on the revision history has no parents.
1082
 
            # But it's not illegal for it to have parents listed; this can happen
1083
 
            # in imports from Arch when the parents weren't reachable.
1084
 
            if mainline_parent_id is not None:
1085
 
                if mainline_parent_id not in revision.parent_ids:
1086
 
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
1087
 
                                        "parents of {%s}"
1088
 
                                        % (mainline_parent_id, revision_id))
1089
 
            mainline_parent_id = revision_id
1090
 
        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
1091
1321
 
1092
1322
    def _get_checkout_format(self):
1093
1323
        """Return the most suitable metadir for a checkout of this branch.
1103
1333
        return format
1104
1334
 
1105
1335
    def create_clone_on_transport(self, to_transport, revision_id=None,
1106
 
        stacked_on=None):
 
1336
        stacked_on=None, create_prefix=False, use_existing_dir=False):
1107
1337
        """Create a clone of this branch and its bzrdir.
1108
1338
 
1109
1339
        :param to_transport: The transport to clone onto.
1110
1340
        :param revision_id: The revision id to use as tip in the new branch.
1111
1341
            If None the tip is obtained from this branch.
1112
1342
        :param stacked_on: An optional URL to stack the clone on.
 
1343
        :param create_prefix: Create any missing directories leading up to
 
1344
            to_transport.
 
1345
        :param use_existing_dir: Use an existing directory if one exists.
1113
1346
        """
1114
1347
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1115
1348
        # clone call. Or something. 20090224 RBC/spiv.
 
1349
        if revision_id is None:
 
1350
            revision_id = self.last_revision()
1116
1351
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1117
 
            revision_id=revision_id, stacked_on=stacked_on)
 
1352
            revision_id=revision_id, stacked_on=stacked_on,
 
1353
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1118
1354
        return dir_to.open_branch()
1119
1355
 
1120
1356
    def create_checkout(self, to_location, revision_id=None,
1139
1375
        if lightweight:
1140
1376
            format = self._get_checkout_format()
1141
1377
            checkout = format.initialize_on_transport(t)
1142
 
            from_branch = BranchReferenceFormat().initialize(checkout, self)
 
1378
            from_branch = BranchReferenceFormat().initialize(checkout, 
 
1379
                target_branch=self)
1143
1380
        else:
1144
1381
            format = self._get_checkout_format()
1145
1382
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1174
1411
        reconciler.reconcile()
1175
1412
        return reconciler
1176
1413
 
1177
 
    def reference_parent(self, file_id, path):
 
1414
    def reference_parent(self, file_id, path, possible_transports=None):
1178
1415
        """Return the parent branch for a tree-reference file_id
1179
1416
        :param file_id: The file_id of the tree reference
1180
1417
        :param path: The path of the file_id in the tree
1181
1418
        :return: A branch associated with the file_id
1182
1419
        """
1183
1420
        # FIXME should provide multiple branches, based on config
1184
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
 
1421
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
 
1422
                           possible_transports=possible_transports)
1185
1423
 
1186
1424
    def supports_tags(self):
1187
1425
        return self._format.supports_tags()
1188
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
 
1189
1439
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1190
1440
                                         other_branch):
1191
1441
        """Ensure that revision_b is a descendant of revision_a.
1246
1496
    _formats = {}
1247
1497
    """The known formats."""
1248
1498
 
 
1499
    can_set_append_revisions_only = True
 
1500
 
1249
1501
    def __eq__(self, other):
1250
1502
        return self.__class__ is other.__class__
1251
1503
 
1253
1505
        return not (self == other)
1254
1506
 
1255
1507
    @classmethod
1256
 
    def find_format(klass, a_bzrdir):
 
1508
    def find_format(klass, a_bzrdir, name=None):
1257
1509
        """Return the format for the branch object in a_bzrdir."""
1258
1510
        try:
1259
 
            transport = a_bzrdir.get_branch_transport(None)
1260
 
            format_string = transport.get("format").read()
 
1511
            transport = a_bzrdir.get_branch_transport(None, name=name)
 
1512
            format_string = transport.get_bytes("format")
1261
1513
            return klass._formats[format_string]
1262
1514
        except errors.NoSuchFile:
1263
 
            raise errors.NotBranchError(path=transport.base)
 
1515
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1264
1516
        except KeyError:
1265
1517
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1266
1518
 
1302
1554
        """Return the short format description for this format."""
1303
1555
        raise NotImplementedError(self.get_format_description)
1304
1556
 
1305
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
1306
 
                           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):
1307
1567
        """Initialize a branch in a bzrdir, with specified files
1308
1568
 
1309
1569
        :param a_bzrdir: The bzrdir to initialize the branch in
1310
1570
        :param utf8_files: The files to create as a list of
1311
1571
            (filename, content) tuples
 
1572
        :param name: Name of colocated branch to create, if any
1312
1573
        :param set_format: If True, set the format with
1313
1574
            self.get_format_string.  (BzrBranch4 has its format set
1314
1575
            elsewhere)
1315
1576
        :return: a branch in this format
1316
1577
        """
1317
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1318
 
        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)
1319
1580
        lock_map = {
1320
1581
            'metadir': ('lock', lockdir.LockDir),
1321
1582
            'branch4': ('branch-lock', lockable_files.TransportLock),
1324
1585
        control_files = lockable_files.LockableFiles(branch_transport,
1325
1586
            lock_name, lock_class)
1326
1587
        control_files.create_lock()
1327
 
        control_files.lock_write()
 
1588
        try:
 
1589
            control_files.lock_write()
 
1590
        except errors.LockContention:
 
1591
            if lock_type != 'branch4':
 
1592
                raise
 
1593
            lock_taken = False
 
1594
        else:
 
1595
            lock_taken = True
1328
1596
        if set_format:
1329
1597
            utf8_files += [('format', self.get_format_string())]
1330
1598
        try:
1333
1601
                    filename, content,
1334
1602
                    mode=a_bzrdir._get_file_mode())
1335
1603
        finally:
1336
 
            control_files.unlock()
1337
 
        return self.open(a_bzrdir, _found=True)
 
1604
            if lock_taken:
 
1605
                control_files.unlock()
 
1606
        branch = self.open(a_bzrdir, name, _found=True)
 
1607
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
1608
        return branch
1338
1609
 
1339
 
    def initialize(self, a_bzrdir):
1340
 
        """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
        """
1341
1615
        raise NotImplementedError(self.initialize)
1342
1616
 
1343
1617
    def is_supported(self):
1373
1647
        """
1374
1648
        raise NotImplementedError(self.network_name)
1375
1649
 
1376
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1650
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1377
1651
        """Return the branch object for a_bzrdir
1378
1652
 
1379
1653
        :param a_bzrdir: A BzrDir that contains a branch.
 
1654
        :param name: Name of colocated branch to open
1380
1655
        :param _found: a private parameter, do not use it. It is used to
1381
1656
            indicate if format probing has already be done.
1382
1657
        :param ignore_fallbacks: when set, no fallback branches will be opened
1396
1671
    def set_default_format(klass, format):
1397
1672
        klass._default_format = format
1398
1673
 
 
1674
    def supports_set_append_revisions_only(self):
 
1675
        """True if this format supports set_append_revisions_only."""
 
1676
        return False
 
1677
 
1399
1678
    def supports_stacking(self):
1400
1679
        """True if this format records a stacked-on branch."""
1401
1680
        return False
1486
1765
            "multiple hooks installed for transform_fallback_location, "
1487
1766
            "all are called with the url returned from the previous hook."
1488
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
 
1489
1785
 
1490
1786
 
1491
1787
# install the default hooks into the Branch class.
1530
1826
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1531
1827
 
1532
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
 
1533
1907
class BzrBranchFormat4(BranchFormat):
1534
1908
    """Bzr branch format 4.
1535
1909
 
1542
1916
        """See BranchFormat.get_format_description()."""
1543
1917
        return "Branch format 4"
1544
1918
 
1545
 
    def initialize(self, a_bzrdir):
 
1919
    def initialize(self, a_bzrdir, name=None):
1546
1920
        """Create a branch of this format in a_bzrdir."""
1547
1921
        utf8_files = [('revision-history', ''),
1548
1922
                      ('branch-name', ''),
1549
1923
                      ]
1550
 
        return self._initialize_helper(a_bzrdir, utf8_files,
 
1924
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1551
1925
                                       lock_type='branch4', set_format=False)
1552
1926
 
1553
1927
    def __init__(self):
1558
1932
        """The network name for this format is the control dirs disk label."""
1559
1933
        return self._matchingbzrdir.get_format_string()
1560
1934
 
1561
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1935
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1562
1936
        """See BranchFormat.open()."""
1563
1937
        if not _found:
1564
1938
            # we are being called directly and must probe.
1566
1940
        return BzrBranch(_format=self,
1567
1941
                         _control_files=a_bzrdir._control_files,
1568
1942
                         a_bzrdir=a_bzrdir,
 
1943
                         name=name,
1569
1944
                         _repository=a_bzrdir.open_repository())
1570
1945
 
1571
1946
    def __str__(self):
1586
1961
        """
1587
1962
        return self.get_format_string()
1588
1963
 
1589
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1964
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1590
1965
        """See BranchFormat.open()."""
1591
1966
        if not _found:
1592
 
            format = BranchFormat.find_format(a_bzrdir)
 
1967
            format = BranchFormat.find_format(a_bzrdir, name=name)
1593
1968
            if format.__class__ != self.__class__:
1594
1969
                raise AssertionError("wrong format %r found for %r" %
1595
1970
                    (format, self))
 
1971
        transport = a_bzrdir.get_branch_transport(None, name=name)
1596
1972
        try:
1597
 
            transport = a_bzrdir.get_branch_transport(None)
1598
1973
            control_files = lockable_files.LockableFiles(transport, 'lock',
1599
1974
                                                         lockdir.LockDir)
1600
1975
            return self._branch_class()(_format=self,
1601
1976
                              _control_files=control_files,
 
1977
                              name=name,
1602
1978
                              a_bzrdir=a_bzrdir,
1603
1979
                              _repository=a_bzrdir.find_repository(),
1604
1980
                              ignore_fallbacks=ignore_fallbacks)
1605
1981
        except errors.NoSuchFile:
1606
 
            raise errors.NotBranchError(path=transport.base)
 
1982
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1607
1983
 
1608
1984
    def __init__(self):
1609
1985
        super(BranchFormatMetadir, self).__init__()
1638
2014
        """See BranchFormat.get_format_description()."""
1639
2015
        return "Branch format 5"
1640
2016
 
1641
 
    def initialize(self, a_bzrdir):
 
2017
    def initialize(self, a_bzrdir, name=None):
1642
2018
        """Create a branch of this format in a_bzrdir."""
1643
2019
        utf8_files = [('revision-history', ''),
1644
2020
                      ('branch-name', ''),
1645
2021
                      ]
1646
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2022
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1647
2023
 
1648
2024
    def supports_tags(self):
1649
2025
        return False
1671
2047
        """See BranchFormat.get_format_description()."""
1672
2048
        return "Branch format 6"
1673
2049
 
1674
 
    def initialize(self, a_bzrdir):
1675
 
        """Create a branch of this format in a_bzrdir."""
1676
 
        utf8_files = [('last-revision', '0 null:\n'),
1677
 
                      ('branch.conf', ''),
1678
 
                      ('tags', ''),
1679
 
                      ]
1680
 
        return self._initialize_helper(a_bzrdir, utf8_files)
1681
 
 
1682
 
    def make_tags(self, branch):
1683
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
1684
 
        return BasicTags(branch)
1685
 
 
1686
 
 
1687
 
 
1688
 
class BzrBranchFormat7(BranchFormatMetadir):
 
2050
    def initialize(self, a_bzrdir, name=None):
 
2051
        """Create a branch of this format in a_bzrdir."""
 
2052
        utf8_files = [('last-revision', '0 null:\n'),
 
2053
                      ('branch.conf', ''),
 
2054
                      ('tags', ''),
 
2055
                      ]
 
2056
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2057
 
 
2058
    def make_tags(self, branch):
 
2059
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2060
        return BasicTags(branch)
 
2061
 
 
2062
    def supports_set_append_revisions_only(self):
 
2063
        return True
 
2064
 
 
2065
 
 
2066
class BzrBranchFormat8(BranchFormatMetadir):
 
2067
    """Metadir format supporting storing locations of subtree branches."""
 
2068
 
 
2069
    def _branch_class(self):
 
2070
        return BzrBranch8
 
2071
 
 
2072
    def get_format_string(self):
 
2073
        """See BranchFormat.get_format_string()."""
 
2074
        return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
 
2075
 
 
2076
    def get_format_description(self):
 
2077
        """See BranchFormat.get_format_description()."""
 
2078
        return "Branch format 8"
 
2079
 
 
2080
    def initialize(self, a_bzrdir, name=None):
 
2081
        """Create a branch of this format in a_bzrdir."""
 
2082
        utf8_files = [('last-revision', '0 null:\n'),
 
2083
                      ('branch.conf', ''),
 
2084
                      ('tags', ''),
 
2085
                      ('references', '')
 
2086
                      ]
 
2087
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2088
 
 
2089
    def __init__(self):
 
2090
        super(BzrBranchFormat8, self).__init__()
 
2091
        self._matchingbzrdir.repository_format = \
 
2092
            RepositoryFormatKnitPack5RichRoot()
 
2093
 
 
2094
    def make_tags(self, branch):
 
2095
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2096
        return BasicTags(branch)
 
2097
 
 
2098
    def supports_set_append_revisions_only(self):
 
2099
        return True
 
2100
 
 
2101
    def supports_stacking(self):
 
2102
        return True
 
2103
 
 
2104
    supports_reference_locations = True
 
2105
 
 
2106
 
 
2107
class BzrBranchFormat7(BzrBranchFormat8):
1689
2108
    """Branch format with last-revision, tags, and a stacked location pointer.
1690
2109
 
1691
2110
    The stacked location pointer is passed down to the repository and requires
1694
2113
    This format was introduced in bzr 1.6.
1695
2114
    """
1696
2115
 
 
2116
    def initialize(self, a_bzrdir, name=None):
 
2117
        """Create a branch of this format in a_bzrdir."""
 
2118
        utf8_files = [('last-revision', '0 null:\n'),
 
2119
                      ('branch.conf', ''),
 
2120
                      ('tags', ''),
 
2121
                      ]
 
2122
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2123
 
1697
2124
    def _branch_class(self):
1698
2125
        return BzrBranch7
1699
2126
 
1705
2132
        """See BranchFormat.get_format_description()."""
1706
2133
        return "Branch format 7"
1707
2134
 
1708
 
    def initialize(self, a_bzrdir):
1709
 
        """Create a branch of this format in a_bzrdir."""
1710
 
        utf8_files = [('last-revision', '0 null:\n'),
1711
 
                      ('branch.conf', ''),
1712
 
                      ('tags', ''),
1713
 
                      ]
1714
 
        return self._initialize_helper(a_bzrdir, utf8_files)
1715
 
 
1716
 
    def __init__(self):
1717
 
        super(BzrBranchFormat7, self).__init__()
1718
 
        self._matchingbzrdir.repository_format = \
1719
 
            RepositoryFormatKnitPack5RichRoot()
1720
 
 
1721
 
    def make_tags(self, branch):
1722
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
1723
 
        return BasicTags(branch)
1724
 
 
1725
 
    def supports_stacking(self):
 
2135
    def supports_set_append_revisions_only(self):
1726
2136
        return True
1727
2137
 
 
2138
    supports_reference_locations = False
 
2139
 
1728
2140
 
1729
2141
class BranchReferenceFormat(BranchFormat):
1730
2142
    """Bzr branch reference format.
1748
2160
    def get_reference(self, a_bzrdir):
1749
2161
        """See BranchFormat.get_reference()."""
1750
2162
        transport = a_bzrdir.get_branch_transport(None)
1751
 
        return transport.get('location').read()
 
2163
        return transport.get_bytes('location')
1752
2164
 
1753
2165
    def set_reference(self, a_bzrdir, to_branch):
1754
2166
        """See BranchFormat.set_reference()."""
1755
2167
        transport = a_bzrdir.get_branch_transport(None)
1756
2168
        location = transport.put_bytes('location', to_branch.base)
1757
2169
 
1758
 
    def initialize(self, a_bzrdir, target_branch=None):
 
2170
    def initialize(self, a_bzrdir, name=None, target_branch=None):
1759
2171
        """Create a branch of this format in a_bzrdir."""
1760
2172
        if target_branch is None:
1761
2173
            # this format does not implement branch itself, thus the implicit
1762
2174
            # creation contract must see it as uninitializable
1763
2175
            raise errors.UninitializableFormat(self)
1764
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1765
 
        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)
1766
2178
        branch_transport.put_bytes('location',
1767
 
            target_branch.bzrdir.root_transport.base)
 
2179
            target_branch.bzrdir.user_url)
1768
2180
        branch_transport.put_bytes('format', self.get_format_string())
1769
 
        return self.open(
1770
 
            a_bzrdir, _found=True,
 
2181
        branch = self.open(
 
2182
            a_bzrdir, name, _found=True,
1771
2183
            possible_transports=[target_branch.bzrdir.root_transport])
 
2184
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2185
        return branch
1772
2186
 
1773
2187
    def __init__(self):
1774
2188
        super(BranchReferenceFormat, self).__init__()
1780
2194
        def clone(to_bzrdir, revision_id=None,
1781
2195
            repository_policy=None):
1782
2196
            """See Branch.clone()."""
1783
 
            return format.initialize(to_bzrdir, a_branch)
 
2197
            return format.initialize(to_bzrdir, target_branch=a_branch)
1784
2198
            # cannot obey revision_id limits when cloning a reference ...
1785
2199
            # FIXME RBC 20060210 either nuke revision_id for clone, or
1786
2200
            # emit some sort of warning/error to the caller ?!
1787
2201
        return clone
1788
2202
 
1789
 
    def open(self, a_bzrdir, _found=False, location=None,
 
2203
    def open(self, a_bzrdir, name=None, _found=False, location=None,
1790
2204
             possible_transports=None, ignore_fallbacks=False):
1791
2205
        """Return the branch that the branch reference in a_bzrdir points at.
1792
2206
 
1793
2207
        :param a_bzrdir: A BzrDir that contains a branch.
 
2208
        :param name: Name of colocated branch to open, if any
1794
2209
        :param _found: a private parameter, do not use it. It is used to
1795
2210
            indicate if format probing has already be done.
1796
2211
        :param ignore_fallbacks: when set, no fallback branches will be opened
1801
2216
        :param possible_transports: An optional reusable transports list.
1802
2217
        """
1803
2218
        if not _found:
1804
 
            format = BranchFormat.find_format(a_bzrdir)
 
2219
            format = BranchFormat.find_format(a_bzrdir, name=name)
1805
2220
            if format.__class__ != self.__class__:
1806
2221
                raise AssertionError("wrong format %r found for %r" %
1807
2222
                    (format, self))
1809
2224
            location = self.get_reference(a_bzrdir)
1810
2225
        real_bzrdir = bzrdir.BzrDir.open(
1811
2226
            location, possible_transports=possible_transports)
1812
 
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2227
        result = real_bzrdir.open_branch(name=name, 
 
2228
            ignore_fallbacks=ignore_fallbacks)
1813
2229
        # this changes the behaviour of result.clone to create a new reference
1814
2230
        # rather than a copy of the content of the branch.
1815
2231
        # I did not use a proxy object because that needs much more extensive
1836
2252
__format5 = BzrBranchFormat5()
1837
2253
__format6 = BzrBranchFormat6()
1838
2254
__format7 = BzrBranchFormat7()
 
2255
__format8 = BzrBranchFormat8()
1839
2256
BranchFormat.register_format(__format5)
1840
2257
BranchFormat.register_format(BranchReferenceFormat())
1841
2258
BranchFormat.register_format(__format6)
1842
2259
BranchFormat.register_format(__format7)
1843
 
BranchFormat.set_default_format(__format6)
 
2260
BranchFormat.register_format(__format8)
 
2261
BranchFormat.set_default_format(__format7)
1844
2262
_legacy_formats = [BzrBranchFormat4(),
1845
2263
    ]
1846
2264
network_format_registry.register(
1847
2265
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
1848
2266
 
1849
2267
 
1850
 
class BzrBranch(Branch):
 
2268
class BzrBranch(Branch, _RelockDebugMixin):
1851
2269
    """A branch stored in the actual filesystem.
1852
2270
 
1853
2271
    Note that it's "local" in the context of the filesystem; it doesn't
1859
2277
    :ivar repository: Repository for this branch.
1860
2278
    :ivar base: The url of the base directory for this branch; the one
1861
2279
        containing the .bzr directory.
 
2280
    :ivar name: Optional colocated branch name as it exists in the control
 
2281
        directory.
1862
2282
    """
1863
2283
 
1864
2284
    def __init__(self, _format=None,
1865
 
                 _control_files=None, a_bzrdir=None, _repository=None,
1866
 
                 ignore_fallbacks=False):
 
2285
                 _control_files=None, a_bzrdir=None, name=None,
 
2286
                 _repository=None, ignore_fallbacks=False):
1867
2287
        """Create new branch object at a particular location."""
1868
2288
        if a_bzrdir is None:
1869
2289
            raise ValueError('a_bzrdir must be supplied')
1870
2290
        else:
1871
2291
            self.bzrdir = a_bzrdir
1872
2292
        self._base = self.bzrdir.transport.clone('..').base
 
2293
        self.name = name
1873
2294
        # XXX: We should be able to just do
1874
2295
        #   self.base = self.bzrdir.root_transport.base
1875
2296
        # but this does not quite work yet -- mbp 20080522
1882
2303
        Branch.__init__(self)
1883
2304
 
1884
2305
    def __str__(self):
1885
 
        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)
1886
2311
 
1887
2312
    __repr__ = __str__
1888
2313
 
1899
2324
        return self.control_files.is_locked()
1900
2325
 
1901
2326
    def lock_write(self, token=None):
1902
 
        repo_token = self.repository.lock_write()
 
2327
        if not self.is_locked():
 
2328
            self._note_lock('w')
 
2329
        # All-in-one needs to always unlock/lock.
 
2330
        repo_control = getattr(self.repository, 'control_files', None)
 
2331
        if self.control_files == repo_control or not self.is_locked():
 
2332
            self.repository._warn_if_deprecated(self)
 
2333
            self.repository.lock_write()
 
2334
            took_lock = True
 
2335
        else:
 
2336
            took_lock = False
1903
2337
        try:
1904
 
            token = self.control_files.lock_write(token=token)
 
2338
            return self.control_files.lock_write(token=token)
1905
2339
        except:
1906
 
            self.repository.unlock()
 
2340
            if took_lock:
 
2341
                self.repository.unlock()
1907
2342
            raise
1908
 
        return token
1909
2343
 
1910
2344
    def lock_read(self):
1911
 
        self.repository.lock_read()
 
2345
        if not self.is_locked():
 
2346
            self._note_lock('r')
 
2347
        # All-in-one needs to always unlock/lock.
 
2348
        repo_control = getattr(self.repository, 'control_files', None)
 
2349
        if self.control_files == repo_control or not self.is_locked():
 
2350
            self.repository._warn_if_deprecated(self)
 
2351
            self.repository.lock_read()
 
2352
            took_lock = True
 
2353
        else:
 
2354
            took_lock = False
1912
2355
        try:
1913
2356
            self.control_files.lock_read()
1914
2357
        except:
1915
 
            self.repository.unlock()
 
2358
            if took_lock:
 
2359
                self.repository.unlock()
1916
2360
            raise
1917
2361
 
 
2362
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1918
2363
    def unlock(self):
1919
 
        # TODO: test for failed two phase locks. This is known broken.
1920
2364
        try:
1921
2365
            self.control_files.unlock()
1922
2366
        finally:
1923
 
            self.repository.unlock()
1924
 
        if not self.control_files.is_locked():
1925
 
            # we just released the lock
1926
 
            self._clear_cached_state()
 
2367
            # All-in-one needs to always unlock/lock.
 
2368
            repo_control = getattr(self.repository, 'control_files', None)
 
2369
            if (self.control_files == repo_control or
 
2370
                not self.control_files.is_locked()):
 
2371
                self.repository.unlock()
 
2372
            if not self.control_files.is_locked():
 
2373
                # we just released the lock
 
2374
                self._clear_cached_state()
1927
2375
 
1928
2376
    def peek_lock_mode(self):
1929
2377
        if self.control_files._lock_count == 0:
2048
2496
        """See Branch.basis_tree."""
2049
2497
        return self.repository.revision_tree(self.last_revision())
2050
2498
 
2051
 
    @needs_write_lock
2052
 
    def pull(self, source, overwrite=False, stop_revision=None,
2053
 
             _hook_master=None, run_hooks=True, possible_transports=None,
2054
 
             _override_hook_target=None):
2055
 
        """See Branch.pull.
2056
 
 
2057
 
        :param _hook_master: Private parameter - set the branch to
2058
 
            be supplied as the master to pull hooks.
2059
 
        :param run_hooks: Private parameter - if false, this branch
2060
 
            is being called because it's the master of the primary branch,
2061
 
            so it should not run its hooks.
2062
 
        :param _override_hook_target: Private parameter - set the branch to be
2063
 
            supplied as the target_branch to pull hooks.
2064
 
        """
2065
 
        result = PullResult()
2066
 
        result.source_branch = source
2067
 
        if _override_hook_target is None:
2068
 
            result.target_branch = self
2069
 
        else:
2070
 
            result.target_branch = _override_hook_target
2071
 
        source.lock_read()
2072
 
        try:
2073
 
            # We assume that during 'pull' the local repository is closer than
2074
 
            # the remote one.
2075
 
            graph = self.repository.get_graph(source.repository)
2076
 
            result.old_revno, result.old_revid = self.last_revision_info()
2077
 
            self.update_revisions(source, stop_revision, overwrite=overwrite,
2078
 
                                  graph=graph)
2079
 
            result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
2080
 
            result.new_revno, result.new_revid = self.last_revision_info()
2081
 
            if _hook_master:
2082
 
                result.master_branch = _hook_master
2083
 
                result.local_branch = result.target_branch
2084
 
            else:
2085
 
                result.master_branch = result.target_branch
2086
 
                result.local_branch = None
2087
 
            if run_hooks:
2088
 
                for hook in Branch.hooks['post_pull']:
2089
 
                    hook(result)
2090
 
        finally:
2091
 
            source.unlock()
2092
 
        return result
2093
 
 
2094
2499
    def _get_parent_location(self):
2095
2500
        _locs = ['parent', 'pull', 'x-pull']
2096
2501
        for l in _locs:
2100
2505
                pass
2101
2506
        return None
2102
2507
 
2103
 
    @needs_read_lock
2104
 
    def push(self, target, overwrite=False, stop_revision=None,
2105
 
             _override_hook_source_branch=None):
2106
 
        """See Branch.push.
2107
 
 
2108
 
        This is the basic concrete implementation of push()
2109
 
 
2110
 
        :param _override_hook_source_branch: If specified, run
2111
 
        the hooks passing this Branch as the source, rather than self.
2112
 
        This is for use of RemoteBranch, where push is delegated to the
2113
 
        underlying vfs-based Branch.
2114
 
        """
2115
 
        # TODO: Public option to disable running hooks - should be trivial but
2116
 
        # needs tests.
2117
 
        return _run_with_write_locked_target(
2118
 
            target, self._push_with_bound_branches, target, overwrite,
2119
 
            stop_revision,
2120
 
            _override_hook_source_branch=_override_hook_source_branch)
2121
 
 
2122
 
    def _push_with_bound_branches(self, target, overwrite,
2123
 
            stop_revision,
2124
 
            _override_hook_source_branch=None):
2125
 
        """Push from self into target, and into target's master if any.
2126
 
 
2127
 
        This is on the base BzrBranch class even though it doesn't support
2128
 
        bound branches because the *target* might be bound.
2129
 
        """
2130
 
        def _run_hooks():
2131
 
            if _override_hook_source_branch:
2132
 
                result.source_branch = _override_hook_source_branch
2133
 
            for hook in Branch.hooks['post_push']:
2134
 
                hook(result)
2135
 
 
2136
 
        bound_location = target.get_bound_location()
2137
 
        if bound_location and target.base != bound_location:
2138
 
            # there is a master branch.
2139
 
            #
2140
 
            # XXX: Why the second check?  Is it even supported for a branch to
2141
 
            # be bound to itself? -- mbp 20070507
2142
 
            master_branch = target.get_master_branch()
2143
 
            master_branch.lock_write()
2144
 
            try:
2145
 
                # push into the master from this branch.
2146
 
                self._basic_push(master_branch, overwrite, stop_revision)
2147
 
                # and push into the target branch from this. Note that we push from
2148
 
                # this branch again, because its considered the highest bandwidth
2149
 
                # repository.
2150
 
                result = self._basic_push(target, overwrite, stop_revision)
2151
 
                result.master_branch = master_branch
2152
 
                result.local_branch = target
2153
 
                _run_hooks()
2154
 
                return result
2155
 
            finally:
2156
 
                master_branch.unlock()
2157
 
        else:
2158
 
            # no master branch
2159
 
            result = self._basic_push(target, overwrite, stop_revision)
2160
 
            # TODO: Why set master_branch and local_branch if there's no
2161
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
2162
 
            # 20070504
2163
 
            result.master_branch = target
2164
 
            result.local_branch = None
2165
 
            _run_hooks()
2166
 
            return result
2167
 
 
2168
2508
    def _basic_push(self, target, overwrite, stop_revision):
2169
2509
        """Basic implementation of push without bound branches or hooks.
2170
2510
 
2171
 
        Must be called with self read locked and target write locked.
 
2511
        Must be called with source read locked and target write locked.
2172
2512
        """
2173
2513
        result = BranchPushResult()
2174
2514
        result.source_branch = self
2175
2515
        result.target_branch = target
2176
2516
        result.old_revno, result.old_revid = target.last_revision_info()
 
2517
        self.update_references(target)
2177
2518
        if result.old_revid != self.last_revision():
2178
2519
            # We assume that during 'push' this repository is closer than
2179
2520
            # the target.
2180
2521
            graph = self.repository.get_graph(target.repository)
2181
 
            target.update_revisions(self, stop_revision, overwrite=overwrite,
2182
 
                                    graph=graph)
 
2522
            target.update_revisions(self, stop_revision,
 
2523
                overwrite=overwrite, graph=graph)
2183
2524
        if self._push_should_merge_tags():
2184
 
            result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
 
2525
            result.tag_conflicts = self.tags.merge_to(target.tags,
 
2526
                overwrite)
2185
2527
        result.new_revno, result.new_revid = target.last_revision_info()
2186
2528
        return result
2187
2529
 
2188
2530
    def get_stacked_on_url(self):
2189
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2531
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2190
2532
 
2191
2533
    def set_push_location(self, location):
2192
2534
        """See Branch.set_push_location."""
2194
2536
            'push_location', location,
2195
2537
            store=_mod_config.STORE_LOCATION_NORECURSE)
2196
2538
 
2197
 
    @needs_write_lock
2198
 
    def set_parent(self, url):
2199
 
        """See Branch.set_parent."""
2200
 
        # TODO: Maybe delete old location files?
2201
 
        # URLs should never be unicode, even on the local fs,
2202
 
        # FIXUP this and get_parent in a future branch format bump:
2203
 
        # read and rewrite the file. RBC 20060125
2204
 
        if url is not None:
2205
 
            if isinstance(url, unicode):
2206
 
                try:
2207
 
                    url = url.encode('ascii')
2208
 
                except UnicodeEncodeError:
2209
 
                    raise errors.InvalidURL(url,
2210
 
                        "Urls must be 7-bit ascii, "
2211
 
                        "use bzrlib.urlutils.escape")
2212
 
            url = urlutils.relative_url(self.base, url)
2213
 
        self._set_parent_location(url)
2214
 
 
2215
2539
    def _set_parent_location(self, url):
2216
2540
        if url is None:
2217
2541
            self._transport.delete('parent')
2226
2550
    It has support for a master_branch which is the data for bound branches.
2227
2551
    """
2228
2552
 
2229
 
    @needs_write_lock
2230
 
    def pull(self, source, overwrite=False, stop_revision=None,
2231
 
             run_hooks=True, possible_transports=None,
2232
 
             _override_hook_target=None):
2233
 
        """Pull from source into self, updating my master if any.
2234
 
 
2235
 
        :param run_hooks: Private parameter - if false, this branch
2236
 
            is being called because it's the master of the primary branch,
2237
 
            so it should not run its hooks.
2238
 
        """
2239
 
        bound_location = self.get_bound_location()
2240
 
        master_branch = None
2241
 
        if bound_location and source.base != bound_location:
2242
 
            # not pulling from master, so we need to update master.
2243
 
            master_branch = self.get_master_branch(possible_transports)
2244
 
            master_branch.lock_write()
2245
 
        try:
2246
 
            if master_branch:
2247
 
                # pull from source into master.
2248
 
                master_branch.pull(source, overwrite, stop_revision,
2249
 
                    run_hooks=False)
2250
 
            return super(BzrBranch5, self).pull(source, overwrite,
2251
 
                stop_revision, _hook_master=master_branch,
2252
 
                run_hooks=run_hooks,
2253
 
                _override_hook_target=_override_hook_target)
2254
 
        finally:
2255
 
            if master_branch:
2256
 
                master_branch.unlock()
2257
 
 
2258
2553
    def get_bound_location(self):
2259
2554
        try:
2260
2555
            return self._transport.get_bytes('bound')[:-1]
2347
2642
        return None
2348
2643
 
2349
2644
 
2350
 
class BzrBranch7(BzrBranch5):
2351
 
    """A branch with support for a fallback repository."""
 
2645
class BzrBranch8(BzrBranch5):
 
2646
    """A branch that stores tree-reference locations."""
2352
2647
 
2353
2648
    def _open_hook(self):
2354
2649
        if self._ignore_fallbacks:
2370
2665
 
2371
2666
    def __init__(self, *args, **kwargs):
2372
2667
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2373
 
        super(BzrBranch7, self).__init__(*args, **kwargs)
 
2668
        super(BzrBranch8, self).__init__(*args, **kwargs)
2374
2669
        self._last_revision_info_cache = None
2375
 
        self._partial_revision_history_cache = []
 
2670
        self._reference_info = None
2376
2671
 
2377
2672
    def _clear_cached_state(self):
2378
 
        super(BzrBranch7, self)._clear_cached_state()
 
2673
        super(BzrBranch8, self)._clear_cached_state()
2379
2674
        self._last_revision_info_cache = None
2380
 
        self._partial_revision_history_cache = []
 
2675
        self._reference_info = None
2381
2676
 
2382
2677
    def _last_revision_info(self):
2383
2678
        revision_string = self._transport.get_bytes('last-revision')
2429
2724
        if _mod_revision.is_null(last_revision):
2430
2725
            return
2431
2726
        if last_revision not in self._lefthand_history(revision_id):
2432
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2727
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
2433
2728
 
2434
2729
    def _gen_revision_history(self):
2435
2730
        """Generate the revision history from last revision
2438
2733
        self._extend_partial_history(stop_index=last_revno-1)
2439
2734
        return list(reversed(self._partial_revision_history_cache))
2440
2735
 
2441
 
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
2442
 
        """Extend the partial history to include a given index
2443
 
 
2444
 
        If a stop_index is supplied, stop when that index has been reached.
2445
 
        If a stop_revision is supplied, stop when that revision is
2446
 
        encountered.  Otherwise, stop when the beginning of history is
2447
 
        reached.
2448
 
 
2449
 
        :param stop_index: The index which should be present.  When it is
2450
 
            present, history extension will stop.
2451
 
        :param revision_id: The revision id which should be present.  When
2452
 
            it is encountered, history extension will stop.
2453
 
        """
2454
 
        repo = self.repository
2455
 
        if len(self._partial_revision_history_cache) == 0:
2456
 
            iterator = repo.iter_reverse_revision_history(self.last_revision())
2457
 
        else:
2458
 
            start_revision = self._partial_revision_history_cache[-1]
2459
 
            iterator = repo.iter_reverse_revision_history(start_revision)
2460
 
            #skip the last revision in the list
2461
 
            next_revision = iterator.next()
2462
 
        for revision_id in iterator:
2463
 
            self._partial_revision_history_cache.append(revision_id)
2464
 
            if (stop_index is not None and
2465
 
                len(self._partial_revision_history_cache) > stop_index):
2466
 
                break
2467
 
            if revision_id == stop_revision:
2468
 
                break
2469
 
 
2470
2736
    def _write_revision_history(self, history):
2471
2737
        """Factored out of set_revision_history.
2472
2738
 
2493
2759
        """Set the parent branch"""
2494
2760
        return self._get_config_location('parent_location')
2495
2761
 
 
2762
    @needs_write_lock
 
2763
    def _set_all_reference_info(self, info_dict):
 
2764
        """Replace all reference info stored in a branch.
 
2765
 
 
2766
        :param info_dict: A dict of {file_id: (tree_path, branch_location)}
 
2767
        """
 
2768
        s = StringIO()
 
2769
        writer = rio.RioWriter(s)
 
2770
        for key, (tree_path, branch_location) in info_dict.iteritems():
 
2771
            stanza = rio.Stanza(file_id=key, tree_path=tree_path,
 
2772
                                branch_location=branch_location)
 
2773
            writer.write_stanza(stanza)
 
2774
        self._transport.put_bytes('references', s.getvalue())
 
2775
        self._reference_info = info_dict
 
2776
 
 
2777
    @needs_read_lock
 
2778
    def _get_all_reference_info(self):
 
2779
        """Return all the reference info stored in a branch.
 
2780
 
 
2781
        :return: A dict of {file_id: (tree_path, branch_location)}
 
2782
        """
 
2783
        if self._reference_info is not None:
 
2784
            return self._reference_info
 
2785
        rio_file = self._transport.get('references')
 
2786
        try:
 
2787
            stanzas = rio.read_stanzas(rio_file)
 
2788
            info_dict = dict((s['file_id'], (s['tree_path'],
 
2789
                             s['branch_location'])) for s in stanzas)
 
2790
        finally:
 
2791
            rio_file.close()
 
2792
        self._reference_info = info_dict
 
2793
        return info_dict
 
2794
 
 
2795
    def set_reference_info(self, file_id, tree_path, branch_location):
 
2796
        """Set the branch location to use for a tree reference.
 
2797
 
 
2798
        :param file_id: The file-id of the tree reference.
 
2799
        :param tree_path: The path of the tree reference in the tree.
 
2800
        :param branch_location: The location of the branch to retrieve tree
 
2801
            references from.
 
2802
        """
 
2803
        info_dict = self._get_all_reference_info()
 
2804
        info_dict[file_id] = (tree_path, branch_location)
 
2805
        if None in (tree_path, branch_location):
 
2806
            if tree_path is not None:
 
2807
                raise ValueError('tree_path must be None when branch_location'
 
2808
                                 ' is None.')
 
2809
            if branch_location is not None:
 
2810
                raise ValueError('branch_location must be None when tree_path'
 
2811
                                 ' is None.')
 
2812
            del info_dict[file_id]
 
2813
        self._set_all_reference_info(info_dict)
 
2814
 
 
2815
    def get_reference_info(self, file_id):
 
2816
        """Get the tree_path and branch_location for a tree reference.
 
2817
 
 
2818
        :return: a tuple of (tree_path, branch_location)
 
2819
        """
 
2820
        return self._get_all_reference_info().get(file_id, (None, None))
 
2821
 
 
2822
    def reference_parent(self, file_id, path, possible_transports=None):
 
2823
        """Return the parent branch for a tree-reference file_id.
 
2824
 
 
2825
        :param file_id: The file_id of the tree reference
 
2826
        :param path: The path of the file_id in the tree
 
2827
        :return: A branch associated with the file_id
 
2828
        """
 
2829
        branch_location = self.get_reference_info(file_id)[1]
 
2830
        if branch_location is None:
 
2831
            return Branch.reference_parent(self, file_id, path,
 
2832
                                           possible_transports)
 
2833
        branch_location = urlutils.join(self.user_url, branch_location)
 
2834
        return Branch.open(branch_location,
 
2835
                           possible_transports=possible_transports)
 
2836
 
2496
2837
    def set_push_location(self, location):
2497
2838
        """See Branch.set_push_location."""
2498
2839
        self._set_config_location('push_location', location)
2540
2881
            raise errors.NotStacked(self)
2541
2882
        return stacked_url
2542
2883
 
2543
 
    def set_append_revisions_only(self, enabled):
2544
 
        if enabled:
2545
 
            value = 'True'
2546
 
        else:
2547
 
            value = 'False'
2548
 
        self.get_config().set_user_option('append_revisions_only', value,
2549
 
            warn_masked=True)
2550
 
 
2551
2884
    def _get_append_revisions_only(self):
2552
 
        value = self.get_config().get_user_option('append_revisions_only')
2553
 
        return value == 'True'
 
2885
        return self.get_config(
 
2886
            ).get_user_option_as_bool('append_revisions_only')
2554
2887
 
2555
2888
    @needs_write_lock
2556
2889
    def generate_revision_history(self, revision_id, last_rev=None,
2596
2929
        return self.revno() - index
2597
2930
 
2598
2931
 
 
2932
class BzrBranch7(BzrBranch8):
 
2933
    """A branch with support for a fallback repository."""
 
2934
 
 
2935
    def set_reference_info(self, file_id, tree_path, branch_location):
 
2936
        Branch.set_reference_info(self, file_id, tree_path, branch_location)
 
2937
 
 
2938
    def get_reference_info(self, file_id):
 
2939
        Branch.get_reference_info(self, file_id)
 
2940
 
 
2941
    def reference_parent(self, file_id, path, possible_transports=None):
 
2942
        return Branch.reference_parent(self, file_id, path,
 
2943
                                       possible_transports)
 
2944
 
 
2945
 
2599
2946
class BzrBranch6(BzrBranch7):
2600
2947
    """See BzrBranchFormat6 for the capabilities of this branch.
2601
2948
 
2604
2951
    """
2605
2952
 
2606
2953
    def get_stacked_on_url(self):
2607
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2954
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2608
2955
 
2609
2956
 
2610
2957
######################################################################
2689
3036
 
2690
3037
    def __init__(self, branch):
2691
3038
        self.branch = branch
 
3039
        self.errors = []
2692
3040
 
2693
3041
    def report_results(self, verbose):
2694
3042
        """Report the check results via trace.note.
2696
3044
        :param verbose: Requests more detailed display of what was checked,
2697
3045
            if any.
2698
3046
        """
2699
 
        note('checked branch %s format %s',
2700
 
             self.branch.base,
2701
 
             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)
2702
3051
 
2703
3052
 
2704
3053
class Converter5to6(object):
2742
3091
        branch._transport.put_bytes('format', format.get_format_string())
2743
3092
 
2744
3093
 
 
3094
class Converter7to8(object):
 
3095
    """Perform an in-place upgrade of format 6 to format 7"""
 
3096
 
 
3097
    def convert(self, branch):
 
3098
        format = BzrBranchFormat8()
 
3099
        branch._transport.put_bytes('references', '')
 
3100
        # update target format
 
3101
        branch._transport.put_bytes('format', format.get_format_string())
 
3102
 
2745
3103
 
2746
3104
def _run_with_write_locked_target(target, callable, *args, **kwargs):
2747
3105
    """Run ``callable(*args, **kwargs)``, write-locking target for the
2790
3148
    @staticmethod
2791
3149
    def _get_branch_formats_to_test():
2792
3150
        """Return a tuple with the Branch formats to use when testing."""
2793
 
        raise NotImplementedError(self._get_branch_formats_to_test)
 
3151
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
 
3152
 
 
3153
    def pull(self, overwrite=False, stop_revision=None,
 
3154
             possible_transports=None, local=False):
 
3155
        """Mirror source into target branch.
 
3156
 
 
3157
        The target branch is considered to be 'local', having low latency.
 
3158
 
 
3159
        :returns: PullResult instance
 
3160
        """
 
3161
        raise NotImplementedError(self.pull)
2794
3162
 
2795
3163
    def update_revisions(self, stop_revision=None, overwrite=False,
2796
3164
                         graph=None):
2805
3173
        """
2806
3174
        raise NotImplementedError(self.update_revisions)
2807
3175
 
 
3176
    def push(self, overwrite=False, stop_revision=None,
 
3177
             _override_hook_source_branch=None):
 
3178
        """Mirror the source branch into the target branch.
 
3179
 
 
3180
        The source branch is considered to be 'local', having low latency.
 
3181
        """
 
3182
        raise NotImplementedError(self.push)
 
3183
 
2808
3184
 
2809
3185
class GenericInterBranch(InterBranch):
2810
3186
    """InterBranch implementation that uses public Branch functions.
2857
3233
        finally:
2858
3234
            self.source.unlock()
2859
3235
 
 
3236
    def pull(self, overwrite=False, stop_revision=None,
 
3237
             possible_transports=None, _hook_master=None, run_hooks=True,
 
3238
             _override_hook_target=None, local=False):
 
3239
        """See Branch.pull.
 
3240
 
 
3241
        :param _hook_master: Private parameter - set the branch to
 
3242
            be supplied as the master to pull hooks.
 
3243
        :param run_hooks: Private parameter - if false, this branch
 
3244
            is being called because it's the master of the primary branch,
 
3245
            so it should not run its hooks.
 
3246
        :param _override_hook_target: Private parameter - set the branch to be
 
3247
            supplied as the target_branch to pull hooks.
 
3248
        :param local: Only update the local branch, and not the bound branch.
 
3249
        """
 
3250
        # This type of branch can't be bound.
 
3251
        if local:
 
3252
            raise errors.LocalRequiresBoundBranch()
 
3253
        result = PullResult()
 
3254
        result.source_branch = self.source
 
3255
        if _override_hook_target is None:
 
3256
            result.target_branch = self.target
 
3257
        else:
 
3258
            result.target_branch = _override_hook_target
 
3259
        self.source.lock_read()
 
3260
        try:
 
3261
            # We assume that during 'pull' the target repository is closer than
 
3262
            # the source one.
 
3263
            self.source.update_references(self.target)
 
3264
            graph = self.target.repository.get_graph(self.source.repository)
 
3265
            # TODO: Branch formats should have a flag that indicates 
 
3266
            # that revno's are expensive, and pull() should honor that flag.
 
3267
            # -- JRV20090506
 
3268
            result.old_revno, result.old_revid = \
 
3269
                self.target.last_revision_info()
 
3270
            self.target.update_revisions(self.source, stop_revision,
 
3271
                overwrite=overwrite, graph=graph)
 
3272
            # TODO: The old revid should be specified when merging tags, 
 
3273
            # so a tags implementation that versions tags can only 
 
3274
            # pull in the most recent changes. -- JRV20090506
 
3275
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
3276
                overwrite)
 
3277
            result.new_revno, result.new_revid = self.target.last_revision_info()
 
3278
            if _hook_master:
 
3279
                result.master_branch = _hook_master
 
3280
                result.local_branch = result.target_branch
 
3281
            else:
 
3282
                result.master_branch = result.target_branch
 
3283
                result.local_branch = None
 
3284
            if run_hooks:
 
3285
                for hook in Branch.hooks['post_pull']:
 
3286
                    hook(result)
 
3287
        finally:
 
3288
            self.source.unlock()
 
3289
        return result
 
3290
 
 
3291
    def push(self, overwrite=False, stop_revision=None,
 
3292
             _override_hook_source_branch=None):
 
3293
        """See InterBranch.push.
 
3294
 
 
3295
        This is the basic concrete implementation of push()
 
3296
 
 
3297
        :param _override_hook_source_branch: If specified, run
 
3298
        the hooks passing this Branch as the source, rather than self.
 
3299
        This is for use of RemoteBranch, where push is delegated to the
 
3300
        underlying vfs-based Branch.
 
3301
        """
 
3302
        # TODO: Public option to disable running hooks - should be trivial but
 
3303
        # needs tests.
 
3304
        self.source.lock_read()
 
3305
        try:
 
3306
            return _run_with_write_locked_target(
 
3307
                self.target, self._push_with_bound_branches, overwrite,
 
3308
                stop_revision,
 
3309
                _override_hook_source_branch=_override_hook_source_branch)
 
3310
        finally:
 
3311
            self.source.unlock()
 
3312
 
 
3313
    def _push_with_bound_branches(self, overwrite, stop_revision,
 
3314
            _override_hook_source_branch=None):
 
3315
        """Push from source into target, and into target's master if any.
 
3316
        """
 
3317
        def _run_hooks():
 
3318
            if _override_hook_source_branch:
 
3319
                result.source_branch = _override_hook_source_branch
 
3320
            for hook in Branch.hooks['post_push']:
 
3321
                hook(result)
 
3322
 
 
3323
        bound_location = self.target.get_bound_location()
 
3324
        if bound_location and self.target.base != bound_location:
 
3325
            # there is a master branch.
 
3326
            #
 
3327
            # XXX: Why the second check?  Is it even supported for a branch to
 
3328
            # be bound to itself? -- mbp 20070507
 
3329
            master_branch = self.target.get_master_branch()
 
3330
            master_branch.lock_write()
 
3331
            try:
 
3332
                # push into the master from the source branch.
 
3333
                self.source._basic_push(master_branch, overwrite, stop_revision)
 
3334
                # and push into the target branch from the source. Note that we
 
3335
                # push from the source branch again, because its considered the
 
3336
                # highest bandwidth repository.
 
3337
                result = self.source._basic_push(self.target, overwrite,
 
3338
                    stop_revision)
 
3339
                result.master_branch = master_branch
 
3340
                result.local_branch = self.target
 
3341
                _run_hooks()
 
3342
                return result
 
3343
            finally:
 
3344
                master_branch.unlock()
 
3345
        else:
 
3346
            # no master branch
 
3347
            result = self.source._basic_push(self.target, overwrite,
 
3348
                stop_revision)
 
3349
            # TODO: Why set master_branch and local_branch if there's no
 
3350
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
3351
            # 20070504
 
3352
            result.master_branch = self.target
 
3353
            result.local_branch = None
 
3354
            _run_hooks()
 
3355
            return result
 
3356
 
2860
3357
    @classmethod
2861
3358
    def is_compatible(self, source, target):
2862
3359
        # GenericBranch uses the public API, so always compatible
2863
3360
        return True
2864
3361
 
2865
3362
 
 
3363
class InterToBranch5(GenericInterBranch):
 
3364
 
 
3365
    @staticmethod
 
3366
    def _get_branch_formats_to_test():
 
3367
        return BranchFormat._default_format, BzrBranchFormat5()
 
3368
 
 
3369
    def pull(self, overwrite=False, stop_revision=None,
 
3370
             possible_transports=None, run_hooks=True,
 
3371
             _override_hook_target=None, local=False):
 
3372
        """Pull from source into self, updating my master if any.
 
3373
 
 
3374
        :param run_hooks: Private parameter - if false, this branch
 
3375
            is being called because it's the master of the primary branch,
 
3376
            so it should not run its hooks.
 
3377
        """
 
3378
        bound_location = self.target.get_bound_location()
 
3379
        if local and not bound_location:
 
3380
            raise errors.LocalRequiresBoundBranch()
 
3381
        master_branch = None
 
3382
        if not local and bound_location and self.source.user_url != bound_location:
 
3383
            # not pulling from master, so we need to update master.
 
3384
            master_branch = self.target.get_master_branch(possible_transports)
 
3385
            master_branch.lock_write()
 
3386
        try:
 
3387
            if master_branch:
 
3388
                # pull from source into master.
 
3389
                master_branch.pull(self.source, overwrite, stop_revision,
 
3390
                    run_hooks=False)
 
3391
            return super(InterToBranch5, self).pull(overwrite,
 
3392
                stop_revision, _hook_master=master_branch,
 
3393
                run_hooks=run_hooks,
 
3394
                _override_hook_target=_override_hook_target)
 
3395
        finally:
 
3396
            if master_branch:
 
3397
                master_branch.unlock()
 
3398
 
 
3399
 
2866
3400
InterBranch.register_optimiser(GenericInterBranch)
 
3401
InterBranch.register_optimiser(InterToBranch5)