/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Vincent Ladeuil
  • Date: 2011-06-16 10:45:17 UTC
  • mto: This revision was merged to the branch mainline in revision 5981.
  • Revision ID: v.ladeuil+lp@free.fr-20110616104517-4qzhmzkxgozji88y
Add copyright notice, some docs and some cleanups.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
24
24
from bzrlib import (
25
25
        bzrdir,
26
26
        cache_utf8,
 
27
        cleanup,
27
28
        config as _mod_config,
28
29
        debug,
29
30
        errors,
 
31
        fetch,
 
32
        graph as _mod_graph,
30
33
        lockdir,
31
34
        lockable_files,
 
35
        remote,
32
36
        repository,
33
37
        revision as _mod_revision,
34
38
        rio,
35
 
        symbol_versioning,
36
39
        transport,
37
 
        tsort,
38
40
        ui,
39
41
        urlutils,
40
42
        )
41
43
from bzrlib.config import BranchConfig, TransportConfig
42
 
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
43
44
from bzrlib.tag import (
44
45
    BasicTags,
45
46
    DisabledTags,
46
47
    )
47
48
""")
48
49
 
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
 
from bzrlib.hooks import HookPoint, Hooks
 
50
from bzrlib import (
 
51
    controldir,
 
52
    )
 
53
from bzrlib.decorators import (
 
54
    needs_read_lock,
 
55
    needs_write_lock,
 
56
    only_raises,
 
57
    )
 
58
from bzrlib.hooks import Hooks
51
59
from bzrlib.inter import InterObject
52
60
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
53
61
from bzrlib import registry
63
71
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
64
72
 
65
73
 
66
 
class Branch(bzrdir.ControlComponent):
 
74
class Branch(controldir.ControlComponent):
67
75
    """Branch holding a history of revisions.
68
76
 
69
77
    :ivar base:
70
78
        Base directory/url of the branch; using control_url and
71
79
        control_transport is more standardized.
72
 
 
73
 
    hooks: An instance of BranchHooks.
 
80
    :ivar hooks: An instance of BranchHooks.
 
81
    :ivar _master_branch_cache: cached result of get_master_branch, see
 
82
        _clear_cached_state.
74
83
    """
75
84
    # this is really an instance variable - FIXME move it there
76
85
    # - RBC 20060112
90
99
        self._revision_id_to_revno_cache = None
91
100
        self._partial_revision_id_to_revno_cache = {}
92
101
        self._partial_revision_history_cache = []
 
102
        self._tags_bytes = None
93
103
        self._last_revision_info_cache = None
 
104
        self._master_branch_cache = None
94
105
        self._merge_sorted_revisions_cache = None
95
106
        self._open_hook()
96
107
        hooks = Branch.hooks['open']
102
113
 
103
114
    def _activate_fallback_location(self, url):
104
115
        """Activate the branch/repository from url as a fallback repository."""
 
116
        for existing_fallback_repo in self.repository._fallback_repositories:
 
117
            if existing_fallback_repo.user_url == url:
 
118
                # This fallback is already configured.  This probably only
 
119
                # happens because BzrDir.sprout is a horrible mess.  To avoid
 
120
                # confusing _unstack we don't add this a second time.
 
121
                mutter('duplicate activation of fallback %r on %r', url, self)
 
122
                return
105
123
        repo = self._get_fallback_repository(url)
106
124
        if repo.has_same_location(self.repository):
107
125
            raise errors.UnstackableLocationError(self.user_url, url)
197
215
        return self.supports_tags() and self.tags.get_tag_dict()
198
216
 
199
217
    def get_config(self):
 
218
        """Get a bzrlib.config.BranchConfig for this Branch.
 
219
 
 
220
        This can then be used to get and set configuration options for the
 
221
        branch.
 
222
 
 
223
        :return: A bzrlib.config.BranchConfig.
 
224
        """
200
225
        return BranchConfig(self)
201
226
 
202
227
    def _get_config(self):
218
243
            possible_transports=[self.bzrdir.root_transport])
219
244
        return a_branch.repository
220
245
 
 
246
    @needs_read_lock
221
247
    def _get_tags_bytes(self):
222
248
        """Get the bytes of a serialised tags dict.
223
249
 
230
256
        :return: The bytes of the tags file.
231
257
        :seealso: Branch._set_tags_bytes.
232
258
        """
233
 
        return self._transport.get_bytes('tags')
 
259
        if self._tags_bytes is None:
 
260
            self._tags_bytes = self._transport.get_bytes('tags')
 
261
        return self._tags_bytes
234
262
 
235
263
    def _get_nick(self, local=False, possible_transports=None):
236
264
        config = self.get_config()
238
266
        if not local and not config.has_explicit_nickname():
239
267
            try:
240
268
                master = self.get_master_branch(possible_transports)
 
269
                if master and self.user_url == master.user_url:
 
270
                    raise errors.RecursiveBind(self.user_url)
241
271
                if master is not None:
242
272
                    # return the master branch value
243
273
                    return master.nick
 
274
            except errors.RecursiveBind, e:
 
275
                raise e
244
276
            except errors.BzrError, e:
245
277
                # Silently fall back to local implicit nick if the master is
246
278
                # unavailable
423
455
            after. If None, the rest of history is included.
424
456
        :param stop_rule: if stop_revision_id is not None, the precise rule
425
457
            to use for termination:
 
458
 
426
459
            * 'exclude' - leave the stop revision out of the result (default)
427
460
            * 'include' - the stop revision is the last item in the result
428
461
            * 'with-merges' - include the stop revision and all of its
430
463
            * 'with-merges-without-common-ancestry' - filter out revisions 
431
464
              that are in both ancestries
432
465
        :param direction: either 'reverse' or 'forward':
 
466
 
433
467
            * reverse means return the start_revision_id first, i.e.
434
468
              start at the most recent revision and go backwards in history
435
469
            * forward returns tuples in the opposite order to reverse.
636
670
        raise errors.UnsupportedOperation(self.get_reference_info, self)
637
671
 
638
672
    @needs_write_lock
639
 
    def fetch(self, from_branch, last_revision=None, pb=None):
 
673
    def fetch(self, from_branch, last_revision=None, limit=None):
640
674
        """Copy revisions from from_branch into this branch.
641
675
 
642
676
        :param from_branch: Where to copy from.
643
677
        :param last_revision: What revision to stop at (None for at the end
644
678
                              of the branch.
645
 
        :param pb: An optional progress bar to use.
 
679
        :param limit: Optional rough limit of revisions to fetch
646
680
        :return: None
647
681
        """
648
 
        if self.base == from_branch.base:
649
 
            return (0, [])
650
 
        if pb is not None:
651
 
            symbol_versioning.warn(
652
 
                symbol_versioning.deprecated_in((1, 14, 0))
653
 
                % "pb parameter to fetch()")
654
 
        from_branch.lock_read()
655
 
        try:
656
 
            if last_revision is None:
657
 
                last_revision = from_branch.last_revision()
658
 
                last_revision = _mod_revision.ensure_null(last_revision)
659
 
            return self.repository.fetch(from_branch.repository,
660
 
                                         revision_id=last_revision,
661
 
                                         pb=pb)
662
 
        finally:
663
 
            from_branch.unlock()
 
682
        return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
664
683
 
665
684
    def get_bound_location(self):
666
685
        """Return the URL of the branch we are bound to.
677
696
 
678
697
    def get_commit_builder(self, parents, config=None, timestamp=None,
679
698
                           timezone=None, committer=None, revprops=None,
680
 
                           revision_id=None):
 
699
                           revision_id=None, lossy=False):
681
700
        """Obtain a CommitBuilder for this branch.
682
701
 
683
702
        :param parents: Revision ids of the parents of the new revision.
687
706
        :param committer: Optional committer to set for commit.
688
707
        :param revprops: Optional dictionary of revision properties.
689
708
        :param revision_id: Optional revision id.
 
709
        :param lossy: Whether to discard data that can not be natively
 
710
            represented, when pushing to a foreign VCS 
690
711
        """
691
712
 
692
713
        if config is None:
693
714
            config = self.get_config()
694
715
 
695
716
        return self.repository.get_commit_builder(self, parents, config,
696
 
            timestamp, timezone, committer, revprops, revision_id)
 
717
            timestamp, timezone, committer, revprops, revision_id,
 
718
            lossy)
697
719
 
698
720
    def get_master_branch(self, possible_transports=None):
699
721
        """Return the branch we are bound to.
726
748
        """Print `file` to stdout."""
727
749
        raise NotImplementedError(self.print_file)
728
750
 
 
751
    @deprecated_method(deprecated_in((2, 4, 0)))
729
752
    def set_revision_history(self, rev_history):
730
 
        raise NotImplementedError(self.set_revision_history)
 
753
        """See Branch.set_revision_history."""
 
754
        self._set_revision_history(rev_history)
 
755
 
 
756
    @needs_write_lock
 
757
    def _set_revision_history(self, rev_history):
 
758
        if len(rev_history) == 0:
 
759
            revid = _mod_revision.NULL_REVISION
 
760
        else:
 
761
            revid = rev_history[-1]
 
762
        if rev_history != self._lefthand_history(revid):
 
763
            raise errors.NotLefthandHistory(rev_history)
 
764
        self.set_last_revision_info(len(rev_history), revid)
 
765
        self._cache_revision_history(rev_history)
 
766
        for hook in Branch.hooks['set_rh']:
 
767
            hook(self, rev_history)
 
768
 
 
769
    @needs_write_lock
 
770
    def set_last_revision_info(self, revno, revision_id):
 
771
        """Set the last revision of this branch.
 
772
 
 
773
        The caller is responsible for checking that the revno is correct
 
774
        for this revision id.
 
775
 
 
776
        It may be possible to set the branch last revision to an id not
 
777
        present in the repository.  However, branches can also be
 
778
        configured to check constraints on history, in which case this may not
 
779
        be permitted.
 
780
        """
 
781
        raise NotImplementedError(self.set_last_revision_info)
 
782
 
 
783
    @needs_write_lock
 
784
    def generate_revision_history(self, revision_id, last_rev=None,
 
785
                                  other_branch=None):
 
786
        """See Branch.generate_revision_history"""
 
787
        graph = self.repository.get_graph()
 
788
        known_revision_ids = [
 
789
            self.last_revision_info(),
 
790
            (_mod_revision.NULL_REVISION, 0),
 
791
            ]
 
792
        if last_rev is not None:
 
793
            if not graph.is_ancestor(last_rev, revision_id):
 
794
                # our previous tip is not merged into stop_revision
 
795
                raise errors.DivergedBranches(self, other_branch)
 
796
        revno = graph.find_distance_to_null(revision_id, known_revision_ids)
 
797
        self.set_last_revision_info(revno, revision_id)
731
798
 
732
799
    @needs_write_lock
733
800
    def set_parent(self, url):
777
844
 
778
845
    def _unstack(self):
779
846
        """Change a branch to be unstacked, copying data as needed.
780
 
        
 
847
 
781
848
        Don't call this directly, use set_stacked_on_url(None).
782
849
        """
783
850
        pb = ui.ui_factory.nested_progress_bar()
792
859
            old_repository = self.repository
793
860
            if len(old_repository._fallback_repositories) != 1:
794
861
                raise AssertionError("can't cope with fallback repositories "
795
 
                    "of %r" % (self.repository,))
796
 
            # unlock it, including unlocking the fallback
 
862
                    "of %r (fallbacks: %r)" % (old_repository,
 
863
                        old_repository._fallback_repositories))
 
864
            # Open the new repository object.
 
865
            # Repositories don't offer an interface to remove fallback
 
866
            # repositories today; take the conceptually simpler option and just
 
867
            # reopen it.  We reopen it starting from the URL so that we
 
868
            # get a separate connection for RemoteRepositories and can
 
869
            # stream from one of them to the other.  This does mean doing
 
870
            # separate SSH connection setup, but unstacking is not a
 
871
            # common operation so it's tolerable.
 
872
            new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
873
            new_repository = new_bzrdir.find_repository()
 
874
            if new_repository._fallback_repositories:
 
875
                raise AssertionError("didn't expect %r to have "
 
876
                    "fallback_repositories"
 
877
                    % (self.repository,))
 
878
            # Replace self.repository with the new repository.
 
879
            # Do our best to transfer the lock state (i.e. lock-tokens and
 
880
            # lock count) of self.repository to the new repository.
 
881
            lock_token = old_repository.lock_write().repository_token
 
882
            self.repository = new_repository
 
883
            if isinstance(self, remote.RemoteBranch):
 
884
                # Remote branches can have a second reference to the old
 
885
                # repository that need to be replaced.
 
886
                if self._real_branch is not None:
 
887
                    self._real_branch.repository = new_repository
 
888
            self.repository.lock_write(token=lock_token)
 
889
            if lock_token is not None:
 
890
                old_repository.leave_lock_in_place()
797
891
            old_repository.unlock()
 
892
            if lock_token is not None:
 
893
                # XXX: self.repository.leave_lock_in_place() before this
 
894
                # function will not be preserved.  Fortunately that doesn't
 
895
                # affect the current default format (2a), and would be a
 
896
                # corner-case anyway.
 
897
                #  - Andrew Bennetts, 2010/06/30
 
898
                self.repository.dont_leave_lock_in_place()
 
899
            old_lock_count = 0
 
900
            while True:
 
901
                try:
 
902
                    old_repository.unlock()
 
903
                except errors.LockNotHeld:
 
904
                    break
 
905
                old_lock_count += 1
 
906
            if old_lock_count == 0:
 
907
                raise AssertionError(
 
908
                    'old_repository should have been locked at least once.')
 
909
            for i in range(old_lock_count-1):
 
910
                self.repository.lock_write()
 
911
            # Fetch from the old repository into the new.
798
912
            old_repository.lock_read()
799
913
            try:
800
 
                # Repositories don't offer an interface to remove fallback
801
 
                # repositories today; take the conceptually simpler option and just
802
 
                # reopen it.  We reopen it starting from the URL so that we
803
 
                # get a separate connection for RemoteRepositories and can
804
 
                # stream from one of them to the other.  This does mean doing
805
 
                # separate SSH connection setup, but unstacking is not a
806
 
                # common operation so it's tolerable.
807
 
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
808
 
                new_repository = new_bzrdir.find_repository()
809
 
                self.repository = new_repository
810
 
                if self.repository._fallback_repositories:
811
 
                    raise AssertionError("didn't expect %r to have "
812
 
                        "fallback_repositories"
813
 
                        % (self.repository,))
814
 
                # this is not paired with an unlock because it's just restoring
815
 
                # the previous state; the lock's released when set_stacked_on_url
816
 
                # returns
817
 
                self.repository.lock_write()
818
914
                # XXX: If you unstack a branch while it has a working tree
819
915
                # with a pending merge, the pending-merged revisions will no
820
916
                # longer be present.  You can (probably) revert and remerge.
821
 
                #
822
 
                # XXX: This only fetches up to the tip of the repository; it
823
 
                # doesn't bring across any tags.  That's fairly consistent
824
 
                # with how branch works, but perhaps not ideal.
825
 
                self.repository.fetch(old_repository,
826
 
                    revision_id=self.last_revision(),
827
 
                    find_ghosts=True)
 
917
                try:
 
918
                    tags_to_fetch = set(self.tags.get_reverse_tag_dict())
 
919
                except errors.TagsNotSupported:
 
920
                    tags_to_fetch = set()
 
921
                fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
 
922
                    old_repository, required_ids=[self.last_revision()],
 
923
                    if_present_ids=tags_to_fetch, find_ghosts=True).execute()
 
924
                self.repository.fetch(old_repository, fetch_spec=fetch_spec)
828
925
            finally:
829
926
                old_repository.unlock()
830
927
        finally:
835
932
 
836
933
        :seealso: Branch._get_tags_bytes.
837
934
        """
838
 
        return _run_with_write_locked_target(self, self._transport.put_bytes,
839
 
            'tags', bytes)
 
935
        op = cleanup.OperationWithCleanups(self._set_tags_bytes_locked)
 
936
        op.add_cleanup(self.lock_write().unlock)
 
937
        return op.run_simple(bytes)
 
938
 
 
939
    def _set_tags_bytes_locked(self, bytes):
 
940
        self._tags_bytes = bytes
 
941
        return self._transport.put_bytes('tags', bytes)
840
942
 
841
943
    def _cache_revision_history(self, rev_history):
842
944
        """Set the cached revision history to rev_history.
869
971
        self._revision_history_cache = None
870
972
        self._revision_id_to_revno_cache = None
871
973
        self._last_revision_info_cache = None
 
974
        self._master_branch_cache = None
872
975
        self._merge_sorted_revisions_cache = None
873
976
        self._partial_revision_history_cache = []
874
977
        self._partial_revision_id_to_revno_cache = {}
 
978
        self._tags_bytes = None
875
979
 
876
980
    def _gen_revision_history(self):
877
981
        """Return sequence of revision hashes on to this branch.
927
1031
        :return: A tuple (revno, revision_id).
928
1032
        """
929
1033
        if self._last_revision_info_cache is None:
930
 
            self._last_revision_info_cache = self._last_revision_info()
 
1034
            self._last_revision_info_cache = self._read_last_revision_info()
931
1035
        return self._last_revision_info_cache
932
1036
 
933
 
    def _last_revision_info(self):
934
 
        rh = self.revision_history()
935
 
        revno = len(rh)
936
 
        if revno:
937
 
            return (revno, rh[-1])
938
 
        else:
939
 
            return (0, _mod_revision.NULL_REVISION)
940
 
 
941
 
    @deprecated_method(deprecated_in((1, 6, 0)))
942
 
    def missing_revisions(self, other, stop_revision=None):
943
 
        """Return a list of new revisions that would perfectly fit.
944
 
 
945
 
        If self and other have not diverged, return a list of the revisions
946
 
        present in other, but missing from self.
947
 
        """
948
 
        self_history = self.revision_history()
949
 
        self_len = len(self_history)
950
 
        other_history = other.revision_history()
951
 
        other_len = len(other_history)
952
 
        common_index = min(self_len, other_len) -1
953
 
        if common_index >= 0 and \
954
 
            self_history[common_index] != other_history[common_index]:
955
 
            raise errors.DivergedBranches(self, other)
956
 
 
957
 
        if stop_revision is None:
958
 
            stop_revision = other_len
959
 
        else:
960
 
            if stop_revision > other_len:
961
 
                raise errors.NoSuchRevision(self, stop_revision)
962
 
        return other_history[self_len:stop_revision]
963
 
 
964
 
    @needs_write_lock
965
 
    def update_revisions(self, other, stop_revision=None, overwrite=False,
966
 
                         graph=None):
967
 
        """Pull in new perfect-fit revisions.
968
 
 
969
 
        :param other: Another Branch to pull from
970
 
        :param stop_revision: Updated until the given revision
971
 
        :param overwrite: Always set the branch pointer, rather than checking
972
 
            to see if it is a proper descendant.
973
 
        :param graph: A Graph object that can be used to query history
974
 
            information. This can be None.
975
 
        :return: None
976
 
        """
977
 
        return InterBranch.get(other, self).update_revisions(stop_revision,
978
 
            overwrite, graph)
979
 
 
 
1037
    def _read_last_revision_info(self):
 
1038
        raise NotImplementedError(self._read_last_revision_info)
 
1039
 
 
1040
    @deprecated_method(deprecated_in((2, 4, 0)))
980
1041
    def import_last_revision_info(self, source_repo, revno, revid):
981
1042
        """Set the last revision info, importing from another repo if necessary.
982
1043
 
983
 
        This is used by the bound branch code to upload a revision to
984
 
        the master branch first before updating the tip of the local branch.
985
 
 
986
1044
        :param source_repo: Source repository to optionally fetch from
987
1045
        :param revno: Revision number of the new tip
988
1046
        :param revid: Revision id of the new tip
991
1049
            self.repository.fetch(source_repo, revision_id=revid)
992
1050
        self.set_last_revision_info(revno, revid)
993
1051
 
 
1052
    def import_last_revision_info_and_tags(self, source, revno, revid,
 
1053
                                           lossy=False):
 
1054
        """Set the last revision info, importing from another repo if necessary.
 
1055
 
 
1056
        This is used by the bound branch code to upload a revision to
 
1057
        the master branch first before updating the tip of the local branch.
 
1058
        Revisions referenced by source's tags are also transferred.
 
1059
 
 
1060
        :param source: Source branch to optionally fetch from
 
1061
        :param revno: Revision number of the new tip
 
1062
        :param revid: Revision id of the new tip
 
1063
        :param lossy: Whether to discard metadata that can not be
 
1064
            natively represented
 
1065
        :return: Tuple with the new revision number and revision id
 
1066
            (should only be different from the arguments when lossy=True)
 
1067
        """
 
1068
        if not self.repository.has_same_location(source.repository):
 
1069
            self.fetch(source, revid)
 
1070
        self.set_last_revision_info(revno, revid)
 
1071
        return (revno, revid)
 
1072
 
994
1073
    def revision_id_to_revno(self, revision_id):
995
1074
        """Given a revision id, return its revno"""
996
1075
        if _mod_revision.is_null(revision_id):
1016
1095
            self._extend_partial_history(distance_from_last)
1017
1096
        return self._partial_revision_history_cache[distance_from_last]
1018
1097
 
1019
 
    @needs_write_lock
1020
1098
    def pull(self, source, overwrite=False, stop_revision=None,
1021
1099
             possible_transports=None, *args, **kwargs):
1022
1100
        """Mirror source into this branch.
1029
1107
            stop_revision=stop_revision,
1030
1108
            possible_transports=possible_transports, *args, **kwargs)
1031
1109
 
1032
 
    def push(self, target, overwrite=False, stop_revision=None, *args,
1033
 
        **kwargs):
 
1110
    def push(self, target, overwrite=False, stop_revision=None, lossy=False,
 
1111
            *args, **kwargs):
1034
1112
        """Mirror this branch into target.
1035
1113
 
1036
1114
        This branch is considered to be 'local', having low latency.
1037
1115
        """
1038
1116
        return InterBranch.get(self, target).push(overwrite, stop_revision,
1039
 
            *args, **kwargs)
1040
 
 
1041
 
    def lossy_push(self, target, stop_revision=None):
1042
 
        """Push deltas into another branch.
1043
 
 
1044
 
        :note: This does not, like push, retain the revision ids from 
1045
 
            the source branch and will, rather than adding bzr-specific 
1046
 
            metadata, push only those semantics of the revision that can be 
1047
 
            natively represented by this branch' VCS.
1048
 
 
1049
 
        :param target: Target branch
1050
 
        :param stop_revision: Revision to push, defaults to last revision.
1051
 
        :return: BranchPushResult with an extra member revidmap: 
1052
 
            A dictionary mapping revision ids from the target branch 
1053
 
            to new revision ids in the target branch, for each 
1054
 
            revision that was pushed.
1055
 
        """
1056
 
        inter = InterBranch.get(self, target)
1057
 
        lossy_push = getattr(inter, "lossy_push", None)
1058
 
        if lossy_push is None:
1059
 
            raise errors.LossyPushToSameVCS(self, target)
1060
 
        return lossy_push(stop_revision)
 
1117
            lossy, *args, **kwargs)
1061
1118
 
1062
1119
    def basis_tree(self):
1063
1120
        """Return `Tree` object for last revision."""
1218
1275
        return result
1219
1276
 
1220
1277
    @needs_read_lock
1221
 
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
 
1278
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None,
 
1279
            repository=None):
1222
1280
        """Create a new line of development from the branch, into to_bzrdir.
1223
1281
 
1224
1282
        to_bzrdir controls the branch format.
1229
1287
        if (repository_policy is not None and
1230
1288
            repository_policy.requires_stacking()):
1231
1289
            to_bzrdir._format.require_stacking(_skip_repo=True)
1232
 
        result = to_bzrdir.create_branch()
 
1290
        result = to_bzrdir.create_branch(repository=repository)
1233
1291
        result.lock_write()
1234
1292
        try:
1235
1293
            if repository_policy is not None:
1236
1294
                repository_policy.configure_branch(result)
1237
1295
            self.copy_content_into(result, revision_id=revision_id)
1238
 
            result.set_parent(self.bzrdir.root_transport.base)
 
1296
            master_branch = self.get_master_branch()
 
1297
            if master_branch is None:
 
1298
                result.set_parent(self.bzrdir.root_transport.base)
 
1299
            else:
 
1300
                result.set_parent(master_branch.bzrdir.root_transport.base)
1239
1301
        finally:
1240
1302
            result.unlock()
1241
1303
        return result
1265
1327
                revno = 1
1266
1328
        destination.set_last_revision_info(revno, revision_id)
1267
1329
 
1268
 
    @needs_read_lock
1269
1330
    def copy_content_into(self, destination, revision_id=None):
1270
1331
        """Copy the content of self into destination.
1271
1332
 
1272
1333
        revision_id: if not None, the revision history in the new branch will
1273
1334
                     be truncated to end with revision_id.
1274
1335
        """
1275
 
        self.update_references(destination)
1276
 
        self._synchronize_history(destination, revision_id)
1277
 
        try:
1278
 
            parent = self.get_parent()
1279
 
        except errors.InaccessibleParent, e:
1280
 
            mutter('parent was not accessible to copy: %s', e)
1281
 
        else:
1282
 
            if parent:
1283
 
                destination.set_parent(parent)
1284
 
        if self._push_should_merge_tags():
1285
 
            self.tags.merge_to(destination.tags)
 
1336
        return InterBranch.get(self, destination).copy_content_into(
 
1337
            revision_id=revision_id)
1286
1338
 
1287
1339
    def update_references(self, target):
1288
1340
        if not getattr(self._format, 'supports_reference_locations', False):
1333
1385
        """Return the most suitable metadir for a checkout of this branch.
1334
1386
        Weaves are used if this branch's repository uses weaves.
1335
1387
        """
1336
 
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1337
 
            from bzrlib.repofmt import weaverepo
1338
 
            format = bzrdir.BzrDirMetaFormat1()
1339
 
            format.repository_format = weaverepo.RepositoryFormat7()
1340
 
        else:
1341
 
            format = self.repository.bzrdir.checkout_metadir()
1342
 
            format.set_branch_format(self._format)
 
1388
        format = self.repository.bzrdir.checkout_metadir()
 
1389
        format.set_branch_format(self._format)
1343
1390
        return format
1344
1391
 
1345
1392
    def create_clone_on_transport(self, to_transport, revision_id=None,
1346
 
        stacked_on=None, create_prefix=False, use_existing_dir=False):
 
1393
        stacked_on=None, create_prefix=False, use_existing_dir=False,
 
1394
        no_tree=None):
1347
1395
        """Create a clone of this branch and its bzrdir.
1348
1396
 
1349
1397
        :param to_transport: The transport to clone onto.
1362
1410
            revision_id = self.last_revision()
1363
1411
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1364
1412
            revision_id=revision_id, stacked_on=stacked_on,
1365
 
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
 
1413
            create_prefix=create_prefix, use_existing_dir=use_existing_dir,
 
1414
            no_tree=no_tree)
1366
1415
        return dir_to.open_branch()
1367
1416
 
1368
1417
    def create_checkout(self, to_location, revision_id=None,
1373
1422
        :param to_location: The url to produce the checkout at
1374
1423
        :param revision_id: The revision to check out
1375
1424
        :param lightweight: If True, produce a lightweight checkout, otherwise,
1376
 
        produce a bound branch (heavyweight checkout)
 
1425
            produce a bound branch (heavyweight checkout)
1377
1426
        :param accelerator_tree: A tree which can be used for retrieving file
1378
1427
            contents more quickly than the revision tree, i.e. a workingtree.
1379
1428
            The revision tree will be used for cases where accelerator_tree's
1425
1474
 
1426
1475
    def reference_parent(self, file_id, path, possible_transports=None):
1427
1476
        """Return the parent branch for a tree-reference file_id
 
1477
 
1428
1478
        :param file_id: The file_id of the tree reference
1429
1479
        :param path: The path of the file_id in the tree
1430
1480
        :return: A branch associated with the file_id
1483
1533
        else:
1484
1534
            raise AssertionError("invalid heads: %r" % (heads,))
1485
1535
 
1486
 
 
1487
 
class BranchFormat(object):
 
1536
    def heads_to_fetch(self):
 
1537
        """Return the heads that must and that should be fetched to copy this
 
1538
        branch into another repo.
 
1539
 
 
1540
        :returns: a 2-tuple of (must_fetch, if_present_fetch).  must_fetch is a
 
1541
            set of heads that must be fetched.  if_present_fetch is a set of
 
1542
            heads that must be fetched if present, but no error is necessary if
 
1543
            they are not present.
 
1544
        """
 
1545
        # For bzr native formats must_fetch is just the tip, and if_present_fetch
 
1546
        # are the tags.
 
1547
        must_fetch = set([self.last_revision()])
 
1548
        try:
 
1549
            if_present_fetch = set(self.tags.get_reverse_tag_dict())
 
1550
        except errors.TagsNotSupported:
 
1551
            if_present_fetch = set()
 
1552
        must_fetch.discard(_mod_revision.NULL_REVISION)
 
1553
        if_present_fetch.discard(_mod_revision.NULL_REVISION)
 
1554
        return must_fetch, if_present_fetch
 
1555
 
 
1556
 
 
1557
class BranchFormat(controldir.ControlComponentFormat):
1488
1558
    """An encapsulation of the initialization and open routines for a format.
1489
1559
 
1490
1560
    Formats provide three things:
1493
1563
     * an open routine.
1494
1564
 
1495
1565
    Formats are placed in an dict by their format string for reference
1496
 
    during branch opening. Its not required that these be instances, they
 
1566
    during branch opening. It's not required that these be instances, they
1497
1567
    can be classes themselves with class methods - it simply depends on
1498
1568
    whether state is needed for a given format or not.
1499
1569
 
1502
1572
    object will be created every time regardless.
1503
1573
    """
1504
1574
 
1505
 
    _default_format = None
1506
 
    """The default format used for new branches."""
1507
 
 
1508
 
    _formats = {}
1509
 
    """The known formats."""
1510
 
 
1511
1575
    can_set_append_revisions_only = True
1512
1576
 
1513
1577
    def __eq__(self, other):
1522
1586
        try:
1523
1587
            transport = a_bzrdir.get_branch_transport(None, name=name)
1524
1588
            format_string = transport.get_bytes("format")
1525
 
            return klass._formats[format_string]
 
1589
            return format_registry.get(format_string)
1526
1590
        except errors.NoSuchFile:
1527
1591
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1528
1592
        except KeyError:
1529
1593
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1530
1594
 
1531
1595
    @classmethod
 
1596
    @deprecated_method(deprecated_in((2, 4, 0)))
1532
1597
    def get_default_format(klass):
1533
1598
        """Return the current default format."""
1534
 
        return klass._default_format
 
1599
        return format_registry.get_default()
 
1600
 
 
1601
    @classmethod
 
1602
    @deprecated_method(deprecated_in((2, 4, 0)))
 
1603
    def get_formats(klass):
 
1604
        """Get all the known formats.
 
1605
 
 
1606
        Warning: This triggers a load of all lazy registered formats: do not
 
1607
        use except when that is desireed.
 
1608
        """
 
1609
        return format_registry._get_all()
1535
1610
 
1536
1611
    def get_reference(self, a_bzrdir, name=None):
1537
1612
        """Get the target reference of the branch in a_bzrdir.
1576
1651
        for hook in hooks:
1577
1652
            hook(params)
1578
1653
 
1579
 
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1580
 
                           lock_type='metadir', set_format=True):
1581
 
        """Initialize a branch in a bzrdir, with specified files
1582
 
 
1583
 
        :param a_bzrdir: The bzrdir to initialize the branch in
1584
 
        :param utf8_files: The files to create as a list of
1585
 
            (filename, content) tuples
1586
 
        :param name: Name of colocated branch to create, if any
1587
 
        :param set_format: If True, set the format with
1588
 
            self.get_format_string.  (BzrBranch4 has its format set
1589
 
            elsewhere)
1590
 
        :return: a branch in this format
1591
 
        """
1592
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1593
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1594
 
        lock_map = {
1595
 
            'metadir': ('lock', lockdir.LockDir),
1596
 
            'branch4': ('branch-lock', lockable_files.TransportLock),
1597
 
        }
1598
 
        lock_name, lock_class = lock_map[lock_type]
1599
 
        control_files = lockable_files.LockableFiles(branch_transport,
1600
 
            lock_name, lock_class)
1601
 
        control_files.create_lock()
1602
 
        try:
1603
 
            control_files.lock_write()
1604
 
        except errors.LockContention:
1605
 
            if lock_type != 'branch4':
1606
 
                raise
1607
 
            lock_taken = False
1608
 
        else:
1609
 
            lock_taken = True
1610
 
        if set_format:
1611
 
            utf8_files += [('format', self.get_format_string())]
1612
 
        try:
1613
 
            for (filename, content) in utf8_files:
1614
 
                branch_transport.put_bytes(
1615
 
                    filename, content,
1616
 
                    mode=a_bzrdir._get_file_mode())
1617
 
        finally:
1618
 
            if lock_taken:
1619
 
                control_files.unlock()
1620
 
        branch = self.open(a_bzrdir, name, _found=True)
1621
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1622
 
        return branch
1623
 
 
1624
 
    def initialize(self, a_bzrdir, name=None):
 
1654
    def initialize(self, a_bzrdir, name=None, repository=None):
1625
1655
        """Create a branch of this format in a_bzrdir.
1626
1656
        
1627
1657
        :param name: Name of the colocated branch to create.
1661
1691
        """
1662
1692
        raise NotImplementedError(self.network_name)
1663
1693
 
1664
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1694
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
 
1695
            found_repository=None):
1665
1696
        """Return the branch object for a_bzrdir
1666
1697
 
1667
1698
        :param a_bzrdir: A BzrDir that contains a branch.
1674
1705
        raise NotImplementedError(self.open)
1675
1706
 
1676
1707
    @classmethod
 
1708
    @deprecated_method(deprecated_in((2, 4, 0)))
1677
1709
    def register_format(klass, format):
1678
 
        """Register a metadir format."""
1679
 
        klass._formats[format.get_format_string()] = format
1680
 
        # Metadir formats have a network name of their format string, and get
1681
 
        # registered as class factories.
1682
 
        network_format_registry.register(format.get_format_string(), format.__class__)
 
1710
        """Register a metadir format.
 
1711
 
 
1712
        See MetaDirBranchFormatFactory for the ability to register a format
 
1713
        without loading the code the format needs until it is actually used.
 
1714
        """
 
1715
        format_registry.register(format)
1683
1716
 
1684
1717
    @classmethod
 
1718
    @deprecated_method(deprecated_in((2, 4, 0)))
1685
1719
    def set_default_format(klass, format):
1686
 
        klass._default_format = format
 
1720
        format_registry.set_default(format)
1687
1721
 
1688
1722
    def supports_set_append_revisions_only(self):
1689
1723
        """True if this format supports set_append_revisions_only."""
1693
1727
        """True if this format records a stacked-on branch."""
1694
1728
        return False
1695
1729
 
 
1730
    def supports_leaving_lock(self):
 
1731
        """True if this format supports leaving locks in place."""
 
1732
        return False # by default
 
1733
 
1696
1734
    @classmethod
 
1735
    @deprecated_method(deprecated_in((2, 4, 0)))
1697
1736
    def unregister_format(klass, format):
1698
 
        del klass._formats[format.get_format_string()]
 
1737
        format_registry.remove(format)
1699
1738
 
1700
1739
    def __str__(self):
1701
1740
        return self.get_format_description().rstrip()
1705
1744
        return False  # by default
1706
1745
 
1707
1746
 
 
1747
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
 
1748
    """A factory for a BranchFormat object, permitting simple lazy registration.
 
1749
    
 
1750
    While none of the built in BranchFormats are lazy registered yet,
 
1751
    bzrlib.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
 
1752
    use it, and the bzr-loom plugin uses it as well (see
 
1753
    bzrlib.plugins.loom.formats).
 
1754
    """
 
1755
 
 
1756
    def __init__(self, format_string, module_name, member_name):
 
1757
        """Create a MetaDirBranchFormatFactory.
 
1758
 
 
1759
        :param format_string: The format string the format has.
 
1760
        :param module_name: Module to load the format class from.
 
1761
        :param member_name: Attribute name within the module for the format class.
 
1762
        """
 
1763
        registry._LazyObjectGetter.__init__(self, module_name, member_name)
 
1764
        self._format_string = format_string
 
1765
        
 
1766
    def get_format_string(self):
 
1767
        """See BranchFormat.get_format_string."""
 
1768
        return self._format_string
 
1769
 
 
1770
    def __call__(self):
 
1771
        """Used for network_format_registry support."""
 
1772
        return self.get_obj()()
 
1773
 
 
1774
 
1708
1775
class BranchHooks(Hooks):
1709
1776
    """A dictionary mapping hook name to a list of callables for branch hooks.
1710
1777
 
1718
1785
        These are all empty initially, because by default nothing should get
1719
1786
        notified.
1720
1787
        """
1721
 
        Hooks.__init__(self)
1722
 
        self.create_hook(HookPoint('set_rh',
 
1788
        Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
 
1789
        self.add_hook('set_rh',
1723
1790
            "Invoked whenever the revision history has been set via "
1724
1791
            "set_revision_history. The api signature is (branch, "
1725
1792
            "revision_history), and the branch will be write-locked. "
1726
1793
            "The set_rh hook can be expensive for bzr to trigger, a better "
1727
 
            "hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1728
 
        self.create_hook(HookPoint('open',
 
1794
            "hook to use is Branch.post_change_branch_tip.", (0, 15))
 
1795
        self.add_hook('open',
1729
1796
            "Called with the Branch object that has been opened after a "
1730
 
            "branch is opened.", (1, 8), None))
1731
 
        self.create_hook(HookPoint('post_push',
 
1797
            "branch is opened.", (1, 8))
 
1798
        self.add_hook('post_push',
1732
1799
            "Called after a push operation completes. post_push is called "
1733
1800
            "with a bzrlib.branch.BranchPushResult object and only runs in the "
1734
 
            "bzr client.", (0, 15), None))
1735
 
        self.create_hook(HookPoint('post_pull',
 
1801
            "bzr client.", (0, 15))
 
1802
        self.add_hook('post_pull',
1736
1803
            "Called after a pull operation completes. post_pull is called "
1737
1804
            "with a bzrlib.branch.PullResult object and only runs in the "
1738
 
            "bzr client.", (0, 15), None))
1739
 
        self.create_hook(HookPoint('pre_commit',
1740
 
            "Called after a commit is calculated but before it is is "
 
1805
            "bzr client.", (0, 15))
 
1806
        self.add_hook('pre_commit',
 
1807
            "Called after a commit is calculated but before it is "
1741
1808
            "completed. pre_commit is called with (local, master, old_revno, "
1742
1809
            "old_revid, future_revno, future_revid, tree_delta, future_tree"
1743
1810
            "). old_revid is NULL_REVISION for the first commit to a branch, "
1745
1812
            "basis revision. hooks MUST NOT modify this delta. "
1746
1813
            " future_tree is an in-memory tree obtained from "
1747
1814
            "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1748
 
            "tree.", (0,91), None))
1749
 
        self.create_hook(HookPoint('post_commit',
 
1815
            "tree.", (0,91))
 
1816
        self.add_hook('post_commit',
1750
1817
            "Called in the bzr client after a commit has completed. "
1751
1818
            "post_commit is called with (local, master, old_revno, old_revid, "
1752
1819
            "new_revno, new_revid). old_revid is NULL_REVISION for the first "
1753
 
            "commit to a branch.", (0, 15), None))
1754
 
        self.create_hook(HookPoint('post_uncommit',
 
1820
            "commit to a branch.", (0, 15))
 
1821
        self.add_hook('post_uncommit',
1755
1822
            "Called in the bzr client after an uncommit completes. "
1756
1823
            "post_uncommit is called with (local, master, old_revno, "
1757
1824
            "old_revid, new_revno, new_revid) where local is the local branch "
1758
1825
            "or None, master is the target branch, and an empty branch "
1759
 
            "receives new_revno of 0, new_revid of None.", (0, 15), None))
1760
 
        self.create_hook(HookPoint('pre_change_branch_tip',
 
1826
            "receives new_revno of 0, new_revid of None.", (0, 15))
 
1827
        self.add_hook('pre_change_branch_tip',
1761
1828
            "Called in bzr client and server before a change to the tip of a "
1762
1829
            "branch is made. pre_change_branch_tip is called with a "
1763
1830
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1764
 
            "commit, uncommit will all trigger this hook.", (1, 6), None))
1765
 
        self.create_hook(HookPoint('post_change_branch_tip',
 
1831
            "commit, uncommit will all trigger this hook.", (1, 6))
 
1832
        self.add_hook('post_change_branch_tip',
1766
1833
            "Called in bzr client and server after a change to the tip of a "
1767
1834
            "branch is made. post_change_branch_tip is called with a "
1768
1835
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1769
 
            "commit, uncommit will all trigger this hook.", (1, 4), None))
1770
 
        self.create_hook(HookPoint('transform_fallback_location',
 
1836
            "commit, uncommit will all trigger this hook.", (1, 4))
 
1837
        self.add_hook('transform_fallback_location',
1771
1838
            "Called when a stacked branch is activating its fallback "
1772
1839
            "locations. transform_fallback_location is called with (branch, "
1773
1840
            "url), and should return a new url. Returning the same url "
1778
1845
            "fallback locations have not been activated. When there are "
1779
1846
            "multiple hooks installed for transform_fallback_location, "
1780
1847
            "all are called with the url returned from the previous hook."
1781
 
            "The order is however undefined.", (1, 9), None))
1782
 
        self.create_hook(HookPoint('automatic_tag_name',
1783
 
            "Called to determine an automatic tag name for a revision."
 
1848
            "The order is however undefined.", (1, 9))
 
1849
        self.add_hook('automatic_tag_name',
 
1850
            "Called to determine an automatic tag name for a revision. "
1784
1851
            "automatic_tag_name is called with (branch, revision_id) and "
1785
1852
            "should return a tag name or None if no tag name could be "
1786
1853
            "determined. The first non-None tag name returned will be used.",
1787
 
            (2, 2), None))
1788
 
        self.create_hook(HookPoint('post_branch_init',
 
1854
            (2, 2))
 
1855
        self.add_hook('post_branch_init',
1789
1856
            "Called after new branch initialization completes. "
1790
1857
            "post_branch_init is called with a "
1791
1858
            "bzrlib.branch.BranchInitHookParams. "
1792
1859
            "Note that init, branch and checkout (both heavyweight and "
1793
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1794
 
        self.create_hook(HookPoint('post_switch',
 
1860
            "lightweight) will all trigger this hook.", (2, 2))
 
1861
        self.add_hook('post_switch',
1795
1862
            "Called after a checkout switches branch. "
1796
1863
            "post_switch is called with a "
1797
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
 
1864
            "bzrlib.branch.SwitchHookParams.", (2, 2))
1798
1865
 
1799
1866
 
1800
1867
 
1803
1870
 
1804
1871
 
1805
1872
class ChangeBranchTipParams(object):
1806
 
    """Object holding parameters passed to *_change_branch_tip hooks.
 
1873
    """Object holding parameters passed to `*_change_branch_tip` hooks.
1807
1874
 
1808
1875
    There are 5 fields that hooks may wish to access:
1809
1876
 
1841
1908
 
1842
1909
 
1843
1910
class BranchInitHookParams(object):
1844
 
    """Object holding parameters passed to *_branch_init hooks.
 
1911
    """Object holding parameters passed to `*_branch_init` hooks.
1845
1912
 
1846
1913
    There are 4 fields that hooks may wish to access:
1847
1914
 
1877
1944
        return self.__dict__ == other.__dict__
1878
1945
 
1879
1946
    def __repr__(self):
1880
 
        if self.branch:
1881
 
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
1882
 
        else:
1883
 
            return "<%s of format:%s bzrdir:%s>" % (
1884
 
                self.__class__.__name__, self.branch,
1885
 
                self.format, self.bzrdir)
 
1947
        return "<%s of %s>" % (self.__class__.__name__, self.branch)
1886
1948
 
1887
1949
 
1888
1950
class SwitchHookParams(object):
1889
 
    """Object holding parameters passed to *_switch hooks.
 
1951
    """Object holding parameters passed to `*_switch` hooks.
1890
1952
 
1891
1953
    There are 4 fields that hooks may wish to access:
1892
1954
 
1918
1980
            self.revision_id)
1919
1981
 
1920
1982
 
1921
 
class BzrBranchFormat4(BranchFormat):
1922
 
    """Bzr branch format 4.
1923
 
 
1924
 
    This format has:
1925
 
     - a revision-history file.
1926
 
     - a branch-lock lock file [ to be shared with the bzrdir ]
1927
 
    """
1928
 
 
1929
 
    def get_format_description(self):
1930
 
        """See BranchFormat.get_format_description()."""
1931
 
        return "Branch format 4"
1932
 
 
1933
 
    def initialize(self, a_bzrdir, name=None):
1934
 
        """Create a branch of this format in a_bzrdir."""
1935
 
        utf8_files = [('revision-history', ''),
1936
 
                      ('branch-name', ''),
1937
 
                      ]
1938
 
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1939
 
                                       lock_type='branch4', set_format=False)
1940
 
 
1941
 
    def __init__(self):
1942
 
        super(BzrBranchFormat4, self).__init__()
1943
 
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
1944
 
 
1945
 
    def network_name(self):
1946
 
        """The network name for this format is the control dirs disk label."""
1947
 
        return self._matchingbzrdir.get_format_string()
1948
 
 
1949
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1950
 
        """See BranchFormat.open()."""
1951
 
        if not _found:
1952
 
            # we are being called directly and must probe.
1953
 
            raise NotImplementedError
1954
 
        return BzrBranch(_format=self,
1955
 
                         _control_files=a_bzrdir._control_files,
1956
 
                         a_bzrdir=a_bzrdir,
1957
 
                         name=name,
1958
 
                         _repository=a_bzrdir.open_repository())
1959
 
 
1960
 
    def __str__(self):
1961
 
        return "Bazaar-NG branch format 4"
1962
 
 
1963
 
 
1964
1983
class BranchFormatMetadir(BranchFormat):
1965
1984
    """Common logic for meta-dir based branch formats."""
1966
1985
 
1968
1987
        """What class to instantiate on open calls."""
1969
1988
        raise NotImplementedError(self._branch_class)
1970
1989
 
 
1990
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
 
1991
                           repository=None):
 
1992
        """Initialize a branch in a bzrdir, with specified files
 
1993
 
 
1994
        :param a_bzrdir: The bzrdir to initialize the branch in
 
1995
        :param utf8_files: The files to create as a list of
 
1996
            (filename, content) tuples
 
1997
        :param name: Name of colocated branch to create, if any
 
1998
        :return: a branch in this format
 
1999
        """
 
2000
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
 
2001
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
2002
        control_files = lockable_files.LockableFiles(branch_transport,
 
2003
            'lock', lockdir.LockDir)
 
2004
        control_files.create_lock()
 
2005
        control_files.lock_write()
 
2006
        try:
 
2007
            utf8_files += [('format', self.get_format_string())]
 
2008
            for (filename, content) in utf8_files:
 
2009
                branch_transport.put_bytes(
 
2010
                    filename, content,
 
2011
                    mode=a_bzrdir._get_file_mode())
 
2012
        finally:
 
2013
            control_files.unlock()
 
2014
        branch = self.open(a_bzrdir, name, _found=True,
 
2015
                found_repository=repository)
 
2016
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2017
        return branch
 
2018
 
1971
2019
    def network_name(self):
1972
2020
        """A simple byte string uniquely identifying this format for RPC calls.
1973
2021
 
1975
2023
        """
1976
2024
        return self.get_format_string()
1977
2025
 
1978
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
2026
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
 
2027
            found_repository=None):
1979
2028
        """See BranchFormat.open()."""
1980
2029
        if not _found:
1981
2030
            format = BranchFormat.find_format(a_bzrdir, name=name)
1986
2035
        try:
1987
2036
            control_files = lockable_files.LockableFiles(transport, 'lock',
1988
2037
                                                         lockdir.LockDir)
 
2038
            if found_repository is None:
 
2039
                found_repository = a_bzrdir.find_repository()
1989
2040
            return self._branch_class()(_format=self,
1990
2041
                              _control_files=control_files,
1991
2042
                              name=name,
1992
2043
                              a_bzrdir=a_bzrdir,
1993
 
                              _repository=a_bzrdir.find_repository(),
 
2044
                              _repository=found_repository,
1994
2045
                              ignore_fallbacks=ignore_fallbacks)
1995
2046
        except errors.NoSuchFile:
1996
2047
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2003
2054
    def supports_tags(self):
2004
2055
        return True
2005
2056
 
 
2057
    def supports_leaving_lock(self):
 
2058
        return True
 
2059
 
2006
2060
 
2007
2061
class BzrBranchFormat5(BranchFormatMetadir):
2008
2062
    """Bzr branch format 5.
2028
2082
        """See BranchFormat.get_format_description()."""
2029
2083
        return "Branch format 5"
2030
2084
 
2031
 
    def initialize(self, a_bzrdir, name=None):
 
2085
    def initialize(self, a_bzrdir, name=None, repository=None):
2032
2086
        """Create a branch of this format in a_bzrdir."""
2033
2087
        utf8_files = [('revision-history', ''),
2034
2088
                      ('branch-name', ''),
2035
2089
                      ]
2036
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2090
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2037
2091
 
2038
2092
    def supports_tags(self):
2039
2093
        return False
2061
2115
        """See BranchFormat.get_format_description()."""
2062
2116
        return "Branch format 6"
2063
2117
 
2064
 
    def initialize(self, a_bzrdir, name=None):
 
2118
    def initialize(self, a_bzrdir, name=None, repository=None):
2065
2119
        """Create a branch of this format in a_bzrdir."""
2066
2120
        utf8_files = [('last-revision', '0 null:\n'),
2067
2121
                      ('branch.conf', ''),
2068
2122
                      ('tags', ''),
2069
2123
                      ]
2070
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2124
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2071
2125
 
2072
2126
    def make_tags(self, branch):
2073
2127
        """See bzrlib.branch.BranchFormat.make_tags()."""
2091
2145
        """See BranchFormat.get_format_description()."""
2092
2146
        return "Branch format 8"
2093
2147
 
2094
 
    def initialize(self, a_bzrdir, name=None):
 
2148
    def initialize(self, a_bzrdir, name=None, repository=None):
2095
2149
        """Create a branch of this format in a_bzrdir."""
2096
2150
        utf8_files = [('last-revision', '0 null:\n'),
2097
2151
                      ('branch.conf', ''),
2098
2152
                      ('tags', ''),
2099
2153
                      ('references', '')
2100
2154
                      ]
2101
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2102
 
 
2103
 
    def __init__(self):
2104
 
        super(BzrBranchFormat8, self).__init__()
2105
 
        self._matchingbzrdir.repository_format = \
2106
 
            RepositoryFormatKnitPack5RichRoot()
 
2155
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2107
2156
 
2108
2157
    def make_tags(self, branch):
2109
2158
        """See bzrlib.branch.BranchFormat.make_tags()."""
2118
2167
    supports_reference_locations = True
2119
2168
 
2120
2169
 
2121
 
class BzrBranchFormat7(BzrBranchFormat8):
 
2170
class BzrBranchFormat7(BranchFormatMetadir):
2122
2171
    """Branch format with last-revision, tags, and a stacked location pointer.
2123
2172
 
2124
2173
    The stacked location pointer is passed down to the repository and requires
2127
2176
    This format was introduced in bzr 1.6.
2128
2177
    """
2129
2178
 
2130
 
    def initialize(self, a_bzrdir, name=None):
 
2179
    def initialize(self, a_bzrdir, name=None, repository=None):
2131
2180
        """Create a branch of this format in a_bzrdir."""
2132
2181
        utf8_files = [('last-revision', '0 null:\n'),
2133
2182
                      ('branch.conf', ''),
2134
2183
                      ('tags', ''),
2135
2184
                      ]
2136
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2185
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2137
2186
 
2138
2187
    def _branch_class(self):
2139
2188
        return BzrBranch7
2149
2198
    def supports_set_append_revisions_only(self):
2150
2199
        return True
2151
2200
 
 
2201
    def supports_stacking(self):
 
2202
        return True
 
2203
 
 
2204
    def make_tags(self, branch):
 
2205
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2206
        return BasicTags(branch)
 
2207
 
2152
2208
    supports_reference_locations = False
2153
2209
 
2154
2210
 
2181
2237
        transport = a_bzrdir.get_branch_transport(None, name=name)
2182
2238
        location = transport.put_bytes('location', to_branch.base)
2183
2239
 
2184
 
    def initialize(self, a_bzrdir, name=None, target_branch=None):
 
2240
    def initialize(self, a_bzrdir, name=None, target_branch=None,
 
2241
            repository=None):
2185
2242
        """Create a branch of this format in a_bzrdir."""
2186
2243
        if target_branch is None:
2187
2244
            # this format does not implement branch itself, thus the implicit
2215
2272
        return clone
2216
2273
 
2217
2274
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2218
 
             possible_transports=None, ignore_fallbacks=False):
 
2275
             possible_transports=None, ignore_fallbacks=False,
 
2276
             found_repository=None):
2219
2277
        """Return the branch that the branch reference in a_bzrdir points at.
2220
2278
 
2221
2279
        :param a_bzrdir: A BzrDir that contains a branch.
2252
2310
        return result
2253
2311
 
2254
2312
 
 
2313
class BranchFormatRegistry(controldir.ControlComponentFormatRegistry):
 
2314
    """Branch format registry."""
 
2315
 
 
2316
    def __init__(self, other_registry=None):
 
2317
        super(BranchFormatRegistry, self).__init__(other_registry)
 
2318
        self._default_format = None
 
2319
 
 
2320
    def set_default(self, format):
 
2321
        self._default_format = format
 
2322
 
 
2323
    def get_default(self):
 
2324
        return self._default_format
 
2325
 
 
2326
 
2255
2327
network_format_registry = registry.FormatRegistry()
2256
2328
"""Registry of formats indexed by their network name.
2257
2329
 
2260
2332
BranchFormat.network_name() for more detail.
2261
2333
"""
2262
2334
 
 
2335
format_registry = BranchFormatRegistry(network_format_registry)
 
2336
 
2263
2337
 
2264
2338
# formats which have no format string are not discoverable
2265
2339
# and not independently creatable, so are not registered.
2267
2341
__format6 = BzrBranchFormat6()
2268
2342
__format7 = BzrBranchFormat7()
2269
2343
__format8 = BzrBranchFormat8()
2270
 
BranchFormat.register_format(__format5)
2271
 
BranchFormat.register_format(BranchReferenceFormat())
2272
 
BranchFormat.register_format(__format6)
2273
 
BranchFormat.register_format(__format7)
2274
 
BranchFormat.register_format(__format8)
2275
 
BranchFormat.set_default_format(__format7)
2276
 
_legacy_formats = [BzrBranchFormat4(),
2277
 
    ]
2278
 
network_format_registry.register(
2279
 
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
 
2344
format_registry.register(__format5)
 
2345
format_registry.register(BranchReferenceFormat())
 
2346
format_registry.register(__format6)
 
2347
format_registry.register(__format7)
 
2348
format_registry.register(__format8)
 
2349
format_registry.set_default(__format7)
2280
2350
 
2281
2351
 
2282
2352
class BranchWriteLockResult(LogicalLockResult):
2430
2500
        """See Branch.print_file."""
2431
2501
        return self.repository.print_file(file, revision_id)
2432
2502
 
2433
 
    def _write_revision_history(self, history):
2434
 
        """Factored out of set_revision_history.
2435
 
 
2436
 
        This performs the actual writing to disk.
2437
 
        It is intended to be called by BzrBranch5.set_revision_history."""
2438
 
        self._transport.put_bytes(
2439
 
            'revision-history', '\n'.join(history),
2440
 
            mode=self.bzrdir._get_file_mode())
2441
 
 
2442
 
    @needs_write_lock
2443
 
    def set_revision_history(self, rev_history):
2444
 
        """See Branch.set_revision_history."""
2445
 
        if 'evil' in debug.debug_flags:
2446
 
            mutter_callsite(3, "set_revision_history scales with history.")
2447
 
        check_not_reserved_id = _mod_revision.check_not_reserved_id
2448
 
        for rev_id in rev_history:
2449
 
            check_not_reserved_id(rev_id)
2450
 
        if Branch.hooks['post_change_branch_tip']:
2451
 
            # Don't calculate the last_revision_info() if there are no hooks
2452
 
            # that will use it.
2453
 
            old_revno, old_revid = self.last_revision_info()
2454
 
        if len(rev_history) == 0:
2455
 
            revid = _mod_revision.NULL_REVISION
2456
 
        else:
2457
 
            revid = rev_history[-1]
2458
 
        self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2459
 
        self._write_revision_history(rev_history)
2460
 
        self._clear_cached_state()
2461
 
        self._cache_revision_history(rev_history)
2462
 
        for hook in Branch.hooks['set_rh']:
2463
 
            hook(self, rev_history)
2464
 
        if Branch.hooks['post_change_branch_tip']:
2465
 
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2466
 
 
2467
 
    def _synchronize_history(self, destination, revision_id):
2468
 
        """Synchronize last revision and revision history between branches.
2469
 
 
2470
 
        This version is most efficient when the destination is also a
2471
 
        BzrBranch5, but works for BzrBranch6 as long as the revision
2472
 
        history is the true lefthand parent history, and all of the revisions
2473
 
        are in the destination's repository.  If not, set_revision_history
2474
 
        will fail.
2475
 
 
2476
 
        :param destination: The branch to copy the history into
2477
 
        :param revision_id: The revision-id to truncate history at.  May
2478
 
          be None to copy complete history.
2479
 
        """
2480
 
        if not isinstance(destination._format, BzrBranchFormat5):
2481
 
            super(BzrBranch, self)._synchronize_history(
2482
 
                destination, revision_id)
2483
 
            return
2484
 
        if revision_id == _mod_revision.NULL_REVISION:
2485
 
            new_history = []
2486
 
        else:
2487
 
            new_history = self.revision_history()
2488
 
        if revision_id is not None and new_history != []:
2489
 
            try:
2490
 
                new_history = new_history[:new_history.index(revision_id) + 1]
2491
 
            except ValueError:
2492
 
                rev = self.repository.get_revision(revision_id)
2493
 
                new_history = rev.get_history(self.repository)[1:]
2494
 
        destination.set_revision_history(new_history)
2495
 
 
2496
2503
    @needs_write_lock
2497
2504
    def set_last_revision_info(self, revno, revision_id):
2498
 
        """Set the last revision of this branch.
2499
 
 
2500
 
        The caller is responsible for checking that the revno is correct
2501
 
        for this revision id.
2502
 
 
2503
 
        It may be possible to set the branch last revision to an id not
2504
 
        present in the repository.  However, branches can also be
2505
 
        configured to check constraints on history, in which case this may not
2506
 
        be permitted.
2507
 
        """
 
2505
        if not revision_id or not isinstance(revision_id, basestring):
 
2506
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2508
2507
        revision_id = _mod_revision.ensure_null(revision_id)
2509
 
        # this old format stores the full history, but this api doesn't
2510
 
        # provide it, so we must generate, and might as well check it's
2511
 
        # correct
2512
 
        history = self._lefthand_history(revision_id)
2513
 
        if len(history) != revno:
2514
 
            raise AssertionError('%d != %d' % (len(history), revno))
2515
 
        self.set_revision_history(history)
2516
 
 
2517
 
    def _gen_revision_history(self):
2518
 
        history = self._transport.get_bytes('revision-history').split('\n')
2519
 
        if history[-1:] == ['']:
2520
 
            # There shouldn't be a trailing newline, but just in case.
2521
 
            history.pop()
2522
 
        return history
2523
 
 
2524
 
    @needs_write_lock
2525
 
    def generate_revision_history(self, revision_id, last_rev=None,
2526
 
        other_branch=None):
2527
 
        """Create a new revision history that will finish with revision_id.
2528
 
 
2529
 
        :param revision_id: the new tip to use.
2530
 
        :param last_rev: The previous last_revision. If not None, then this
2531
 
            must be a ancestory of revision_id, or DivergedBranches is raised.
2532
 
        :param other_branch: The other branch that DivergedBranches should
2533
 
            raise with respect to.
2534
 
        """
2535
 
        self.set_revision_history(self._lefthand_history(revision_id,
2536
 
            last_rev, other_branch))
 
2508
        old_revno, old_revid = self.last_revision_info()
 
2509
        if self._get_append_revisions_only():
 
2510
            self._check_history_violation(revision_id)
 
2511
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
 
2512
        self._write_last_revision_info(revno, revision_id)
 
2513
        self._clear_cached_state()
 
2514
        self._last_revision_info_cache = revno, revision_id
 
2515
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2537
2516
 
2538
2517
    def basis_tree(self):
2539
2518
        """See Branch.basis_tree."""
2548
2527
                pass
2549
2528
        return None
2550
2529
 
2551
 
    def _basic_push(self, target, overwrite, stop_revision):
2552
 
        """Basic implementation of push without bound branches or hooks.
2553
 
 
2554
 
        Must be called with source read locked and target write locked.
2555
 
        """
2556
 
        result = BranchPushResult()
2557
 
        result.source_branch = self
2558
 
        result.target_branch = target
2559
 
        result.old_revno, result.old_revid = target.last_revision_info()
2560
 
        self.update_references(target)
2561
 
        if result.old_revid != self.last_revision():
2562
 
            # We assume that during 'push' this repository is closer than
2563
 
            # the target.
2564
 
            graph = self.repository.get_graph(target.repository)
2565
 
            target.update_revisions(self, stop_revision,
2566
 
                overwrite=overwrite, graph=graph)
2567
 
        if self._push_should_merge_tags():
2568
 
            result.tag_conflicts = self.tags.merge_to(target.tags,
2569
 
                overwrite)
2570
 
        result.new_revno, result.new_revid = target.last_revision_info()
2571
 
        return result
2572
 
 
2573
2530
    def get_stacked_on_url(self):
2574
2531
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2575
2532
 
2586
2543
            self._transport.put_bytes('parent', url + '\n',
2587
2544
                mode=self.bzrdir._get_file_mode())
2588
2545
 
2589
 
 
2590
 
class BzrBranch5(BzrBranch):
2591
 
    """A format 5 branch. This supports new features over plain branches.
2592
 
 
2593
 
    It has support for a master_branch which is the data for bound branches.
2594
 
    """
2595
 
 
2596
 
    def get_bound_location(self):
2597
 
        try:
2598
 
            return self._transport.get_bytes('bound')[:-1]
2599
 
        except errors.NoSuchFile:
2600
 
            return None
2601
 
 
2602
 
    @needs_read_lock
2603
 
    def get_master_branch(self, possible_transports=None):
2604
 
        """Return the branch we are bound to.
2605
 
 
2606
 
        :return: Either a Branch, or None
2607
 
 
2608
 
        This could memoise the branch, but if thats done
2609
 
        it must be revalidated on each new lock.
2610
 
        So for now we just don't memoise it.
2611
 
        # RBC 20060304 review this decision.
2612
 
        """
2613
 
        bound_loc = self.get_bound_location()
2614
 
        if not bound_loc:
2615
 
            return None
2616
 
        try:
2617
 
            return Branch.open(bound_loc,
2618
 
                               possible_transports=possible_transports)
2619
 
        except (errors.NotBranchError, errors.ConnectionError), e:
2620
 
            raise errors.BoundBranchConnectionFailure(
2621
 
                    self, bound_loc, e)
2622
 
 
2623
2546
    @needs_write_lock
2624
 
    def set_bound_location(self, location):
2625
 
        """Set the target where this branch is bound to.
2626
 
 
2627
 
        :param location: URL to the target branch
2628
 
        """
2629
 
        if location:
2630
 
            self._transport.put_bytes('bound', location+'\n',
2631
 
                mode=self.bzrdir._get_file_mode())
2632
 
        else:
2633
 
            try:
2634
 
                self._transport.delete('bound')
2635
 
            except errors.NoSuchFile:
2636
 
                return False
2637
 
            return True
 
2547
    def unbind(self):
 
2548
        """If bound, unbind"""
 
2549
        return self.set_bound_location(None)
2638
2550
 
2639
2551
    @needs_write_lock
2640
2552
    def bind(self, other):
2662
2574
        # history around
2663
2575
        self.set_bound_location(other.base)
2664
2576
 
 
2577
    def get_bound_location(self):
 
2578
        try:
 
2579
            return self._transport.get_bytes('bound')[:-1]
 
2580
        except errors.NoSuchFile:
 
2581
            return None
 
2582
 
 
2583
    @needs_read_lock
 
2584
    def get_master_branch(self, possible_transports=None):
 
2585
        """Return the branch we are bound to.
 
2586
 
 
2587
        :return: Either a Branch, or None
 
2588
        """
 
2589
        if self._master_branch_cache is None:
 
2590
            self._master_branch_cache = self._get_master_branch(
 
2591
                possible_transports)
 
2592
        return self._master_branch_cache
 
2593
 
 
2594
    def _get_master_branch(self, possible_transports):
 
2595
        bound_loc = self.get_bound_location()
 
2596
        if not bound_loc:
 
2597
            return None
 
2598
        try:
 
2599
            return Branch.open(bound_loc,
 
2600
                               possible_transports=possible_transports)
 
2601
        except (errors.NotBranchError, errors.ConnectionError), e:
 
2602
            raise errors.BoundBranchConnectionFailure(
 
2603
                    self, bound_loc, e)
 
2604
 
2665
2605
    @needs_write_lock
2666
 
    def unbind(self):
2667
 
        """If bound, unbind"""
2668
 
        return self.set_bound_location(None)
 
2606
    def set_bound_location(self, location):
 
2607
        """Set the target where this branch is bound to.
 
2608
 
 
2609
        :param location: URL to the target branch
 
2610
        """
 
2611
        self._master_branch_cache = None
 
2612
        if location:
 
2613
            self._transport.put_bytes('bound', location+'\n',
 
2614
                mode=self.bzrdir._get_file_mode())
 
2615
        else:
 
2616
            try:
 
2617
                self._transport.delete('bound')
 
2618
            except errors.NoSuchFile:
 
2619
                return False
 
2620
            return True
2669
2621
 
2670
2622
    @needs_write_lock
2671
2623
    def update(self, possible_transports=None):
2684
2636
            return old_tip
2685
2637
        return None
2686
2638
 
2687
 
 
2688
 
class BzrBranch8(BzrBranch5):
 
2639
    def _read_last_revision_info(self):
 
2640
        revision_string = self._transport.get_bytes('last-revision')
 
2641
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
 
2642
        revision_id = cache_utf8.get_cached_utf8(revision_id)
 
2643
        revno = int(revno)
 
2644
        return revno, revision_id
 
2645
 
 
2646
    def _write_last_revision_info(self, revno, revision_id):
 
2647
        """Simply write out the revision id, with no checks.
 
2648
 
 
2649
        Use set_last_revision_info to perform this safely.
 
2650
 
 
2651
        Does not update the revision_history cache.
 
2652
        """
 
2653
        revision_id = _mod_revision.ensure_null(revision_id)
 
2654
        out_string = '%d %s\n' % (revno, revision_id)
 
2655
        self._transport.put_bytes('last-revision', out_string,
 
2656
            mode=self.bzrdir._get_file_mode())
 
2657
 
 
2658
 
 
2659
class FullHistoryBzrBranch(BzrBranch):
 
2660
    """Bzr branch which contains the full revision history."""
 
2661
 
 
2662
    @needs_write_lock
 
2663
    def set_last_revision_info(self, revno, revision_id):
 
2664
        if not revision_id or not isinstance(revision_id, basestring):
 
2665
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
 
2666
        revision_id = _mod_revision.ensure_null(revision_id)
 
2667
        # this old format stores the full history, but this api doesn't
 
2668
        # provide it, so we must generate, and might as well check it's
 
2669
        # correct
 
2670
        history = self._lefthand_history(revision_id)
 
2671
        if len(history) != revno:
 
2672
            raise AssertionError('%d != %d' % (len(history), revno))
 
2673
        self._set_revision_history(history)
 
2674
 
 
2675
    def _read_last_revision_info(self):
 
2676
        rh = self.revision_history()
 
2677
        revno = len(rh)
 
2678
        if revno:
 
2679
            return (revno, rh[-1])
 
2680
        else:
 
2681
            return (0, _mod_revision.NULL_REVISION)
 
2682
 
 
2683
    @deprecated_method(deprecated_in((2, 4, 0)))
 
2684
    @needs_write_lock
 
2685
    def set_revision_history(self, rev_history):
 
2686
        """See Branch.set_revision_history."""
 
2687
        self._set_revision_history(rev_history)
 
2688
 
 
2689
    def _set_revision_history(self, rev_history):
 
2690
        if 'evil' in debug.debug_flags:
 
2691
            mutter_callsite(3, "set_revision_history scales with history.")
 
2692
        check_not_reserved_id = _mod_revision.check_not_reserved_id
 
2693
        for rev_id in rev_history:
 
2694
            check_not_reserved_id(rev_id)
 
2695
        if Branch.hooks['post_change_branch_tip']:
 
2696
            # Don't calculate the last_revision_info() if there are no hooks
 
2697
            # that will use it.
 
2698
            old_revno, old_revid = self.last_revision_info()
 
2699
        if len(rev_history) == 0:
 
2700
            revid = _mod_revision.NULL_REVISION
 
2701
        else:
 
2702
            revid = rev_history[-1]
 
2703
        self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
 
2704
        self._write_revision_history(rev_history)
 
2705
        self._clear_cached_state()
 
2706
        self._cache_revision_history(rev_history)
 
2707
        for hook in Branch.hooks['set_rh']:
 
2708
            hook(self, rev_history)
 
2709
        if Branch.hooks['post_change_branch_tip']:
 
2710
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
2711
 
 
2712
    def _write_revision_history(self, history):
 
2713
        """Factored out of set_revision_history.
 
2714
 
 
2715
        This performs the actual writing to disk.
 
2716
        It is intended to be called by set_revision_history."""
 
2717
        self._transport.put_bytes(
 
2718
            'revision-history', '\n'.join(history),
 
2719
            mode=self.bzrdir._get_file_mode())
 
2720
 
 
2721
    def _gen_revision_history(self):
 
2722
        history = self._transport.get_bytes('revision-history').split('\n')
 
2723
        if history[-1:] == ['']:
 
2724
            # There shouldn't be a trailing newline, but just in case.
 
2725
            history.pop()
 
2726
        return history
 
2727
 
 
2728
    def _synchronize_history(self, destination, revision_id):
 
2729
        if not isinstance(destination, FullHistoryBzrBranch):
 
2730
            super(BzrBranch, self)._synchronize_history(
 
2731
                destination, revision_id)
 
2732
            return
 
2733
        if revision_id == _mod_revision.NULL_REVISION:
 
2734
            new_history = []
 
2735
        else:
 
2736
            new_history = self.revision_history()
 
2737
        if revision_id is not None and new_history != []:
 
2738
            try:
 
2739
                new_history = new_history[:new_history.index(revision_id) + 1]
 
2740
            except ValueError:
 
2741
                rev = self.repository.get_revision(revision_id)
 
2742
                new_history = rev.get_history(self.repository)[1:]
 
2743
        destination._set_revision_history(new_history)
 
2744
 
 
2745
    @needs_write_lock
 
2746
    def generate_revision_history(self, revision_id, last_rev=None,
 
2747
        other_branch=None):
 
2748
        """Create a new revision history that will finish with revision_id.
 
2749
 
 
2750
        :param revision_id: the new tip to use.
 
2751
        :param last_rev: The previous last_revision. If not None, then this
 
2752
            must be a ancestory of revision_id, or DivergedBranches is raised.
 
2753
        :param other_branch: The other branch that DivergedBranches should
 
2754
            raise with respect to.
 
2755
        """
 
2756
        self._set_revision_history(self._lefthand_history(revision_id,
 
2757
            last_rev, other_branch))
 
2758
 
 
2759
 
 
2760
class BzrBranch5(FullHistoryBzrBranch):
 
2761
    """A format 5 branch. This supports new features over plain branches.
 
2762
 
 
2763
    It has support for a master_branch which is the data for bound branches.
 
2764
    """
 
2765
 
 
2766
 
 
2767
class BzrBranch8(BzrBranch):
2689
2768
    """A branch that stores tree-reference locations."""
2690
2769
 
2691
2770
    def _open_hook(self):
2717
2796
        self._last_revision_info_cache = None
2718
2797
        self._reference_info = None
2719
2798
 
2720
 
    def _last_revision_info(self):
2721
 
        revision_string = self._transport.get_bytes('last-revision')
2722
 
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2723
 
        revision_id = cache_utf8.get_cached_utf8(revision_id)
2724
 
        revno = int(revno)
2725
 
        return revno, revision_id
2726
 
 
2727
 
    def _write_last_revision_info(self, revno, revision_id):
2728
 
        """Simply write out the revision id, with no checks.
2729
 
 
2730
 
        Use set_last_revision_info to perform this safely.
2731
 
 
2732
 
        Does not update the revision_history cache.
2733
 
        Intended to be called by set_last_revision_info and
2734
 
        _write_revision_history.
2735
 
        """
2736
 
        revision_id = _mod_revision.ensure_null(revision_id)
2737
 
        out_string = '%d %s\n' % (revno, revision_id)
2738
 
        self._transport.put_bytes('last-revision', out_string,
2739
 
            mode=self.bzrdir._get_file_mode())
2740
 
 
2741
 
    @needs_write_lock
2742
 
    def set_last_revision_info(self, revno, revision_id):
2743
 
        revision_id = _mod_revision.ensure_null(revision_id)
2744
 
        old_revno, old_revid = self.last_revision_info()
2745
 
        if self._get_append_revisions_only():
2746
 
            self._check_history_violation(revision_id)
2747
 
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2748
 
        self._write_last_revision_info(revno, revision_id)
2749
 
        self._clear_cached_state()
2750
 
        self._last_revision_info_cache = revno, revision_id
2751
 
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2752
 
 
2753
 
    def _synchronize_history(self, destination, revision_id):
2754
 
        """Synchronize last revision and revision history between branches.
2755
 
 
2756
 
        :see: Branch._synchronize_history
2757
 
        """
2758
 
        # XXX: The base Branch has a fast implementation of this method based
2759
 
        # on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2760
 
        # that uses set_revision_history.  This class inherits from BzrBranch5,
2761
 
        # but wants the fast implementation, so it calls
2762
 
        # Branch._synchronize_history directly.
2763
 
        Branch._synchronize_history(self, destination, revision_id)
2764
 
 
2765
2799
    def _check_history_violation(self, revision_id):
2766
 
        last_revision = _mod_revision.ensure_null(self.last_revision())
 
2800
        current_revid = self.last_revision()
 
2801
        last_revision = _mod_revision.ensure_null(current_revid)
2767
2802
        if _mod_revision.is_null(last_revision):
2768
2803
            return
2769
 
        if last_revision not in self._lefthand_history(revision_id):
2770
 
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
 
2804
        graph = self.repository.get_graph()
 
2805
        for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
 
2806
            if lh_ancestor == current_revid:
 
2807
                return
 
2808
        raise errors.AppendRevisionsOnlyViolation(self.user_url)
2771
2809
 
2772
2810
    def _gen_revision_history(self):
2773
2811
        """Generate the revision history from last revision
2776
2814
        self._extend_partial_history(stop_index=last_revno-1)
2777
2815
        return list(reversed(self._partial_revision_history_cache))
2778
2816
 
2779
 
    def _write_revision_history(self, history):
2780
 
        """Factored out of set_revision_history.
2781
 
 
2782
 
        This performs the actual writing to disk, with format-specific checks.
2783
 
        It is intended to be called by BzrBranch5.set_revision_history.
2784
 
        """
2785
 
        if len(history) == 0:
2786
 
            last_revision = 'null:'
2787
 
        else:
2788
 
            if history != self._lefthand_history(history[-1]):
2789
 
                raise errors.NotLefthandHistory(history)
2790
 
            last_revision = history[-1]
2791
 
        if self._get_append_revisions_only():
2792
 
            self._check_history_violation(last_revision)
2793
 
        self._write_last_revision_info(len(history), last_revision)
2794
 
 
2795
2817
    @needs_write_lock
2796
2818
    def _set_parent_location(self, url):
2797
2819
        """Set the parent branch"""
2883
2905
 
2884
2906
    def set_bound_location(self, location):
2885
2907
        """See Branch.set_push_location."""
 
2908
        self._master_branch_cache = None
2886
2909
        result = None
2887
2910
        config = self.get_config()
2888
2911
        if location is None:
2928
2951
        return self.get_config(
2929
2952
            ).get_user_option_as_bool('append_revisions_only')
2930
2953
 
2931
 
    @needs_write_lock
2932
 
    def generate_revision_history(self, revision_id, last_rev=None,
2933
 
                                  other_branch=None):
2934
 
        """See BzrBranch5.generate_revision_history"""
2935
 
        history = self._lefthand_history(revision_id, last_rev, other_branch)
2936
 
        revno = len(history)
2937
 
        self.set_last_revision_info(revno, revision_id)
2938
 
 
2939
2954
    @needs_read_lock
2940
2955
    def get_rev_id(self, revno, history=None):
2941
2956
        """Find the revision id of the specified revno."""
2965
2980
        try:
2966
2981
            index = self._partial_revision_history_cache.index(revision_id)
2967
2982
        except ValueError:
2968
 
            self._extend_partial_history(stop_revision=revision_id)
 
2983
            try:
 
2984
                self._extend_partial_history(stop_revision=revision_id)
 
2985
            except errors.RevisionNotPresent, e:
 
2986
                raise errors.GhostRevisionsHaveNoRevno(revision_id, e.revision_id)
2969
2987
            index = len(self._partial_revision_history_cache) - 1
2970
2988
            if self._partial_revision_history_cache[index] != revision_id:
2971
2989
                raise errors.NoSuchRevision(self, revision_id)
3026
3044
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
3027
3045
    """
3028
3046
 
 
3047
    @deprecated_method(deprecated_in((2, 3, 0)))
3029
3048
    def __int__(self):
3030
 
        # DEPRECATED: pull used to return the change in revno
 
3049
        """Return the relative change in revno.
 
3050
 
 
3051
        :deprecated: Use `new_revno` and `old_revno` instead.
 
3052
        """
3031
3053
        return self.new_revno - self.old_revno
3032
3054
 
3033
3055
    def report(self, to_file):
3058
3080
        target, otherwise it will be None.
3059
3081
    """
3060
3082
 
 
3083
    @deprecated_method(deprecated_in((2, 3, 0)))
3061
3084
    def __int__(self):
3062
 
        # DEPRECATED: push used to return the change in revno
 
3085
        """Return the relative change in revno.
 
3086
 
 
3087
        :deprecated: Use `new_revno` and `old_revno` instead.
 
3088
        """
3063
3089
        return self.new_revno - self.old_revno
3064
3090
 
3065
3091
    def report(self, to_file):
3144
3170
        branch._transport.put_bytes('format', format.get_format_string())
3145
3171
 
3146
3172
 
3147
 
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3148
 
    """Run ``callable(*args, **kwargs)``, write-locking target for the
3149
 
    duration.
3150
 
 
3151
 
    _run_with_write_locked_target will attempt to release the lock it acquires.
3152
 
 
3153
 
    If an exception is raised by callable, then that exception *will* be
3154
 
    propagated, even if the unlock attempt raises its own error.  Thus
3155
 
    _run_with_write_locked_target should be preferred to simply doing::
3156
 
 
3157
 
        target.lock_write()
3158
 
        try:
3159
 
            return callable(*args, **kwargs)
3160
 
        finally:
3161
 
            target.unlock()
3162
 
 
3163
 
    """
3164
 
    # This is very similar to bzrlib.decorators.needs_write_lock.  Perhaps they
3165
 
    # should share code?
3166
 
    target.lock_write()
3167
 
    try:
3168
 
        result = callable(*args, **kwargs)
3169
 
    except:
3170
 
        exc_info = sys.exc_info()
3171
 
        try:
3172
 
            target.unlock()
3173
 
        finally:
3174
 
            raise exc_info[0], exc_info[1], exc_info[2]
3175
 
    else:
3176
 
        target.unlock()
3177
 
        return result
3178
 
 
3179
 
 
3180
3173
class InterBranch(InterObject):
3181
3174
    """This class represents operations taking place between two branches.
3182
3175
 
3188
3181
    _optimisers = []
3189
3182
    """The available optimised InterBranch types."""
3190
3183
 
3191
 
    @staticmethod
3192
 
    def _get_branch_formats_to_test():
3193
 
        """Return a tuple with the Branch formats to use when testing."""
3194
 
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
 
3184
    @classmethod
 
3185
    def _get_branch_formats_to_test(klass):
 
3186
        """Return an iterable of format tuples for testing.
 
3187
        
 
3188
        :return: An iterable of (from_format, to_format) to use when testing
 
3189
            this InterBranch class. Each InterBranch class should define this
 
3190
            method itself.
 
3191
        """
 
3192
        raise NotImplementedError(klass._get_branch_formats_to_test)
3195
3193
 
 
3194
    @needs_write_lock
3196
3195
    def pull(self, overwrite=False, stop_revision=None,
3197
3196
             possible_transports=None, local=False):
3198
3197
        """Mirror source into target branch.
3203
3202
        """
3204
3203
        raise NotImplementedError(self.pull)
3205
3204
 
3206
 
    def update_revisions(self, stop_revision=None, overwrite=False,
3207
 
                         graph=None):
3208
 
        """Pull in new perfect-fit revisions.
3209
 
 
3210
 
        :param stop_revision: Updated until the given revision
3211
 
        :param overwrite: Always set the branch pointer, rather than checking
3212
 
            to see if it is a proper descendant.
3213
 
        :param graph: A Graph object that can be used to query history
3214
 
            information. This can be None.
3215
 
        :return: None
3216
 
        """
3217
 
        raise NotImplementedError(self.update_revisions)
3218
 
 
3219
 
    def push(self, overwrite=False, stop_revision=None,
 
3205
    @needs_write_lock
 
3206
    def push(self, overwrite=False, stop_revision=None, lossy=False,
3220
3207
             _override_hook_source_branch=None):
3221
3208
        """Mirror the source branch into the target branch.
3222
3209
 
3224
3211
        """
3225
3212
        raise NotImplementedError(self.push)
3226
3213
 
 
3214
    @needs_write_lock
 
3215
    def copy_content_into(self, revision_id=None):
 
3216
        """Copy the content of source into target
 
3217
 
 
3218
        revision_id: if not None, the revision history in the new branch will
 
3219
                     be truncated to end with revision_id.
 
3220
        """
 
3221
        raise NotImplementedError(self.copy_content_into)
 
3222
 
 
3223
    @needs_write_lock
 
3224
    def fetch(self, stop_revision=None, limit=None):
 
3225
        """Fetch revisions.
 
3226
 
 
3227
        :param stop_revision: Last revision to fetch
 
3228
        :param limit: Optional rough limit of revisions to fetch
 
3229
        """
 
3230
        raise NotImplementedError(self.fetch)
 
3231
 
3227
3232
 
3228
3233
class GenericInterBranch(InterBranch):
3229
 
    """InterBranch implementation that uses public Branch functions.
3230
 
    """
3231
 
 
3232
 
    @staticmethod
3233
 
    def _get_branch_formats_to_test():
3234
 
        return BranchFormat._default_format, BranchFormat._default_format
3235
 
 
3236
 
    def update_revisions(self, stop_revision=None, overwrite=False,
3237
 
        graph=None):
3238
 
        """See InterBranch.update_revisions()."""
 
3234
    """InterBranch implementation that uses public Branch functions."""
 
3235
 
 
3236
    @classmethod
 
3237
    def is_compatible(klass, source, target):
 
3238
        # GenericBranch uses the public API, so always compatible
 
3239
        return True
 
3240
 
 
3241
    @classmethod
 
3242
    def _get_branch_formats_to_test(klass):
 
3243
        return [(format_registry.get_default(), format_registry.get_default())]
 
3244
 
 
3245
    @classmethod
 
3246
    def unwrap_format(klass, format):
 
3247
        if isinstance(format, remote.RemoteBranchFormat):
 
3248
            format._ensure_real()
 
3249
            return format._custom_format
 
3250
        return format
 
3251
 
 
3252
    @needs_write_lock
 
3253
    def copy_content_into(self, revision_id=None):
 
3254
        """Copy the content of source into target
 
3255
 
 
3256
        revision_id: if not None, the revision history in the new branch will
 
3257
                     be truncated to end with revision_id.
 
3258
        """
 
3259
        self.source.update_references(self.target)
 
3260
        self.source._synchronize_history(self.target, revision_id)
 
3261
        try:
 
3262
            parent = self.source.get_parent()
 
3263
        except errors.InaccessibleParent, e:
 
3264
            mutter('parent was not accessible to copy: %s', e)
 
3265
        else:
 
3266
            if parent:
 
3267
                self.target.set_parent(parent)
 
3268
        if self.source._push_should_merge_tags():
 
3269
            self.source.tags.merge_to(self.target.tags)
 
3270
 
 
3271
    @needs_write_lock
 
3272
    def fetch(self, stop_revision=None, limit=None):
 
3273
        if self.target.base == self.source.base:
 
3274
            return (0, [])
3239
3275
        self.source.lock_read()
3240
3276
        try:
3241
 
            other_revno, other_last_revision = self.source.last_revision_info()
3242
 
            stop_revno = None # unknown
3243
 
            if stop_revision is None:
3244
 
                stop_revision = other_last_revision
3245
 
                if _mod_revision.is_null(stop_revision):
3246
 
                    # if there are no commits, we're done.
3247
 
                    return
3248
 
                stop_revno = other_revno
3249
 
 
3250
 
            # what's the current last revision, before we fetch [and change it
3251
 
            # possibly]
3252
 
            last_rev = _mod_revision.ensure_null(self.target.last_revision())
3253
 
            # we fetch here so that we don't process data twice in the common
3254
 
            # case of having something to pull, and so that the check for
3255
 
            # already merged can operate on the just fetched graph, which will
3256
 
            # be cached in memory.
3257
 
            self.target.fetch(self.source, stop_revision)
3258
 
            # Check to see if one is an ancestor of the other
3259
 
            if not overwrite:
3260
 
                if graph is None:
3261
 
                    graph = self.target.repository.get_graph()
3262
 
                if self.target._check_if_descendant_or_diverged(
3263
 
                        stop_revision, last_rev, graph, self.source):
3264
 
                    # stop_revision is a descendant of last_rev, but we aren't
3265
 
                    # overwriting, so we're done.
3266
 
                    return
3267
 
            if stop_revno is None:
3268
 
                if graph is None:
3269
 
                    graph = self.target.repository.get_graph()
3270
 
                this_revno, this_last_revision = \
3271
 
                        self.target.last_revision_info()
3272
 
                stop_revno = graph.find_distance_to_null(stop_revision,
3273
 
                                [(other_last_revision, other_revno),
3274
 
                                 (this_last_revision, this_revno)])
3275
 
            self.target.set_last_revision_info(stop_revno, stop_revision)
 
3277
            fetch_spec_factory = fetch.FetchSpecFactory()
 
3278
            fetch_spec_factory.source_branch = self.source
 
3279
            fetch_spec_factory.source_branch_stop_revision_id = stop_revision
 
3280
            fetch_spec_factory.source_repo = self.source.repository
 
3281
            fetch_spec_factory.target_repo = self.target.repository
 
3282
            fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
 
3283
            fetch_spec_factory.limit = limit
 
3284
            fetch_spec = fetch_spec_factory.make_fetch_spec()
 
3285
            return self.target.repository.fetch(self.source.repository,
 
3286
                fetch_spec=fetch_spec)
3276
3287
        finally:
3277
3288
            self.source.unlock()
3278
3289
 
 
3290
    @needs_write_lock
 
3291
    def _update_revisions(self, stop_revision=None, overwrite=False,
 
3292
            graph=None):
 
3293
        other_revno, other_last_revision = self.source.last_revision_info()
 
3294
        stop_revno = None # unknown
 
3295
        if stop_revision is None:
 
3296
            stop_revision = other_last_revision
 
3297
            if _mod_revision.is_null(stop_revision):
 
3298
                # if there are no commits, we're done.
 
3299
                return
 
3300
            stop_revno = other_revno
 
3301
 
 
3302
        # what's the current last revision, before we fetch [and change it
 
3303
        # possibly]
 
3304
        last_rev = _mod_revision.ensure_null(self.target.last_revision())
 
3305
        # we fetch here so that we don't process data twice in the common
 
3306
        # case of having something to pull, and so that the check for
 
3307
        # already merged can operate on the just fetched graph, which will
 
3308
        # be cached in memory.
 
3309
        self.fetch(stop_revision=stop_revision)
 
3310
        # Check to see if one is an ancestor of the other
 
3311
        if not overwrite:
 
3312
            if graph is None:
 
3313
                graph = self.target.repository.get_graph()
 
3314
            if self.target._check_if_descendant_or_diverged(
 
3315
                    stop_revision, last_rev, graph, self.source):
 
3316
                # stop_revision is a descendant of last_rev, but we aren't
 
3317
                # overwriting, so we're done.
 
3318
                return
 
3319
        if stop_revno is None:
 
3320
            if graph is None:
 
3321
                graph = self.target.repository.get_graph()
 
3322
            this_revno, this_last_revision = \
 
3323
                    self.target.last_revision_info()
 
3324
            stop_revno = graph.find_distance_to_null(stop_revision,
 
3325
                            [(other_last_revision, other_revno),
 
3326
                             (this_last_revision, this_revno)])
 
3327
        self.target.set_last_revision_info(stop_revno, stop_revision)
 
3328
 
 
3329
    @needs_write_lock
3279
3330
    def pull(self, overwrite=False, stop_revision=None,
 
3331
             possible_transports=None, run_hooks=True,
 
3332
             _override_hook_target=None, local=False):
 
3333
        """Pull from source into self, updating my master if any.
 
3334
 
 
3335
        :param run_hooks: Private parameter - if false, this branch
 
3336
            is being called because it's the master of the primary branch,
 
3337
            so it should not run its hooks.
 
3338
        """
 
3339
        bound_location = self.target.get_bound_location()
 
3340
        if local and not bound_location:
 
3341
            raise errors.LocalRequiresBoundBranch()
 
3342
        master_branch = None
 
3343
        source_is_master = (self.source.user_url == bound_location)
 
3344
        if not local and bound_location and not source_is_master:
 
3345
            # not pulling from master, so we need to update master.
 
3346
            master_branch = self.target.get_master_branch(possible_transports)
 
3347
            master_branch.lock_write()
 
3348
        try:
 
3349
            if master_branch:
 
3350
                # pull from source into master.
 
3351
                master_branch.pull(self.source, overwrite, stop_revision,
 
3352
                    run_hooks=False)
 
3353
            return self._pull(overwrite,
 
3354
                stop_revision, _hook_master=master_branch,
 
3355
                run_hooks=run_hooks,
 
3356
                _override_hook_target=_override_hook_target,
 
3357
                merge_tags_to_master=not source_is_master)
 
3358
        finally:
 
3359
            if master_branch:
 
3360
                master_branch.unlock()
 
3361
 
 
3362
    def push(self, overwrite=False, stop_revision=None, lossy=False,
 
3363
             _override_hook_source_branch=None):
 
3364
        """See InterBranch.push.
 
3365
 
 
3366
        This is the basic concrete implementation of push()
 
3367
 
 
3368
        :param _override_hook_source_branch: If specified, run the hooks
 
3369
            passing this Branch as the source, rather than self.  This is for
 
3370
            use of RemoteBranch, where push is delegated to the underlying
 
3371
            vfs-based Branch.
 
3372
        """
 
3373
        if lossy:
 
3374
            raise errors.LossyPushToSameVCS(self.source, self.target)
 
3375
        # TODO: Public option to disable running hooks - should be trivial but
 
3376
        # needs tests.
 
3377
 
 
3378
        op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
 
3379
        op.add_cleanup(self.source.lock_read().unlock)
 
3380
        op.add_cleanup(self.target.lock_write().unlock)
 
3381
        return op.run(overwrite, stop_revision,
 
3382
            _override_hook_source_branch=_override_hook_source_branch)
 
3383
 
 
3384
    def _basic_push(self, overwrite, stop_revision):
 
3385
        """Basic implementation of push without bound branches or hooks.
 
3386
 
 
3387
        Must be called with source read locked and target write locked.
 
3388
        """
 
3389
        result = BranchPushResult()
 
3390
        result.source_branch = self.source
 
3391
        result.target_branch = self.target
 
3392
        result.old_revno, result.old_revid = self.target.last_revision_info()
 
3393
        self.source.update_references(self.target)
 
3394
        if result.old_revid != stop_revision:
 
3395
            # We assume that during 'push' this repository is closer than
 
3396
            # the target.
 
3397
            graph = self.source.repository.get_graph(self.target.repository)
 
3398
            self._update_revisions(stop_revision, overwrite=overwrite,
 
3399
                    graph=graph)
 
3400
        if self.source._push_should_merge_tags():
 
3401
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
3402
                overwrite)
 
3403
        result.new_revno, result.new_revid = self.target.last_revision_info()
 
3404
        return result
 
3405
 
 
3406
    def _push_with_bound_branches(self, operation, overwrite, stop_revision,
 
3407
            _override_hook_source_branch=None):
 
3408
        """Push from source into target, and into target's master if any.
 
3409
        """
 
3410
        def _run_hooks():
 
3411
            if _override_hook_source_branch:
 
3412
                result.source_branch = _override_hook_source_branch
 
3413
            for hook in Branch.hooks['post_push']:
 
3414
                hook(result)
 
3415
 
 
3416
        bound_location = self.target.get_bound_location()
 
3417
        if bound_location and self.target.base != bound_location:
 
3418
            # there is a master branch.
 
3419
            #
 
3420
            # XXX: Why the second check?  Is it even supported for a branch to
 
3421
            # be bound to itself? -- mbp 20070507
 
3422
            master_branch = self.target.get_master_branch()
 
3423
            master_branch.lock_write()
 
3424
            operation.add_cleanup(master_branch.unlock)
 
3425
            # push into the master from the source branch.
 
3426
            master_inter = InterBranch.get(self.source, master_branch)
 
3427
            master_inter._basic_push(overwrite, stop_revision)
 
3428
            # and push into the target branch from the source. Note that
 
3429
            # we push from the source branch again, because it's considered
 
3430
            # the highest bandwidth repository.
 
3431
            result = self._basic_push(overwrite, stop_revision)
 
3432
            result.master_branch = master_branch
 
3433
            result.local_branch = self.target
 
3434
        else:
 
3435
            master_branch = None
 
3436
            # no master branch
 
3437
            result = self._basic_push(overwrite, stop_revision)
 
3438
            # TODO: Why set master_branch and local_branch if there's no
 
3439
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
3440
            # 20070504
 
3441
            result.master_branch = self.target
 
3442
            result.local_branch = None
 
3443
        _run_hooks()
 
3444
        return result
 
3445
 
 
3446
    def _pull(self, overwrite=False, stop_revision=None,
3280
3447
             possible_transports=None, _hook_master=None, run_hooks=True,
3281
 
             _override_hook_target=None, local=False):
 
3448
             _override_hook_target=None, local=False,
 
3449
             merge_tags_to_master=True):
3282
3450
        """See Branch.pull.
3283
3451
 
 
3452
        This function is the core worker, used by GenericInterBranch.pull to
 
3453
        avoid duplication when pulling source->master and source->local.
 
3454
 
3284
3455
        :param _hook_master: Private parameter - set the branch to
3285
3456
            be supplied as the master to pull hooks.
3286
3457
        :param run_hooks: Private parameter - if false, this branch
3287
3458
            is being called because it's the master of the primary branch,
3288
3459
            so it should not run its hooks.
 
3460
            is being called because it's the master of the primary branch,
 
3461
            so it should not run its hooks.
3289
3462
        :param _override_hook_target: Private parameter - set the branch to be
3290
3463
            supplied as the target_branch to pull hooks.
3291
3464
        :param local: Only update the local branch, and not the bound branch.
3310
3483
            # -- JRV20090506
3311
3484
            result.old_revno, result.old_revid = \
3312
3485
                self.target.last_revision_info()
3313
 
            self.target.update_revisions(self.source, stop_revision,
3314
 
                overwrite=overwrite, graph=graph)
 
3486
            self._update_revisions(stop_revision, overwrite=overwrite,
 
3487
                graph=graph)
3315
3488
            # TODO: The old revid should be specified when merging tags, 
3316
3489
            # so a tags implementation that versions tags can only 
3317
3490
            # pull in the most recent changes. -- JRV20090506
3318
3491
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3319
 
                overwrite)
 
3492
                overwrite, ignore_master=not merge_tags_to_master)
3320
3493
            result.new_revno, result.new_revid = self.target.last_revision_info()
3321
3494
            if _hook_master:
3322
3495
                result.master_branch = _hook_master
3331
3504
            self.source.unlock()
3332
3505
        return result
3333
3506
 
3334
 
    def push(self, overwrite=False, stop_revision=None,
3335
 
             _override_hook_source_branch=None):
3336
 
        """See InterBranch.push.
3337
 
 
3338
 
        This is the basic concrete implementation of push()
3339
 
 
3340
 
        :param _override_hook_source_branch: If specified, run
3341
 
        the hooks passing this Branch as the source, rather than self.
3342
 
        This is for use of RemoteBranch, where push is delegated to the
3343
 
        underlying vfs-based Branch.
3344
 
        """
3345
 
        # TODO: Public option to disable running hooks - should be trivial but
3346
 
        # needs tests.
3347
 
        self.source.lock_read()
3348
 
        try:
3349
 
            return _run_with_write_locked_target(
3350
 
                self.target, self._push_with_bound_branches, overwrite,
3351
 
                stop_revision,
3352
 
                _override_hook_source_branch=_override_hook_source_branch)
3353
 
        finally:
3354
 
            self.source.unlock()
3355
 
 
3356
 
    def _push_with_bound_branches(self, overwrite, stop_revision,
3357
 
            _override_hook_source_branch=None):
3358
 
        """Push from source into target, and into target's master if any.
3359
 
        """
3360
 
        def _run_hooks():
3361
 
            if _override_hook_source_branch:
3362
 
                result.source_branch = _override_hook_source_branch
3363
 
            for hook in Branch.hooks['post_push']:
3364
 
                hook(result)
3365
 
 
3366
 
        bound_location = self.target.get_bound_location()
3367
 
        if bound_location and self.target.base != bound_location:
3368
 
            # there is a master branch.
3369
 
            #
3370
 
            # XXX: Why the second check?  Is it even supported for a branch to
3371
 
            # be bound to itself? -- mbp 20070507
3372
 
            master_branch = self.target.get_master_branch()
3373
 
            master_branch.lock_write()
3374
 
            try:
3375
 
                # push into the master from the source branch.
3376
 
                self.source._basic_push(master_branch, overwrite, stop_revision)
3377
 
                # and push into the target branch from the source. Note that we
3378
 
                # push from the source branch again, because its considered the
3379
 
                # highest bandwidth repository.
3380
 
                result = self.source._basic_push(self.target, overwrite,
3381
 
                    stop_revision)
3382
 
                result.master_branch = master_branch
3383
 
                result.local_branch = self.target
3384
 
                _run_hooks()
3385
 
                return result
3386
 
            finally:
3387
 
                master_branch.unlock()
3388
 
        else:
3389
 
            # no master branch
3390
 
            result = self.source._basic_push(self.target, overwrite,
3391
 
                stop_revision)
3392
 
            # TODO: Why set master_branch and local_branch if there's no
3393
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
3394
 
            # 20070504
3395
 
            result.master_branch = self.target
3396
 
            result.local_branch = None
3397
 
            _run_hooks()
3398
 
            return result
3399
 
 
3400
 
    @classmethod
3401
 
    def is_compatible(self, source, target):
3402
 
        # GenericBranch uses the public API, so always compatible
3403
 
        return True
3404
 
 
3405
 
 
3406
 
class InterToBranch5(GenericInterBranch):
3407
 
 
3408
 
    @staticmethod
3409
 
    def _get_branch_formats_to_test():
3410
 
        return BranchFormat._default_format, BzrBranchFormat5()
3411
 
 
3412
 
    def pull(self, overwrite=False, stop_revision=None,
3413
 
             possible_transports=None, run_hooks=True,
3414
 
             _override_hook_target=None, local=False):
3415
 
        """Pull from source into self, updating my master if any.
3416
 
 
3417
 
        :param run_hooks: Private parameter - if false, this branch
3418
 
            is being called because it's the master of the primary branch,
3419
 
            so it should not run its hooks.
3420
 
        """
3421
 
        bound_location = self.target.get_bound_location()
3422
 
        if local and not bound_location:
3423
 
            raise errors.LocalRequiresBoundBranch()
3424
 
        master_branch = None
3425
 
        if not local and bound_location and self.source.user_url != bound_location:
3426
 
            # not pulling from master, so we need to update master.
3427
 
            master_branch = self.target.get_master_branch(possible_transports)
3428
 
            master_branch.lock_write()
3429
 
        try:
3430
 
            if master_branch:
3431
 
                # pull from source into master.
3432
 
                master_branch.pull(self.source, overwrite, stop_revision,
3433
 
                    run_hooks=False)
3434
 
            return super(InterToBranch5, self).pull(overwrite,
3435
 
                stop_revision, _hook_master=master_branch,
3436
 
                run_hooks=run_hooks,
3437
 
                _override_hook_target=_override_hook_target)
3438
 
        finally:
3439
 
            if master_branch:
3440
 
                master_branch.unlock()
3441
 
 
3442
3507
 
3443
3508
InterBranch.register_optimiser(GenericInterBranch)
3444
 
InterBranch.register_optimiser(InterToBranch5)